From patchwork Tue Sep 25 14:40:18 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 147479 Delivered-To: patches@linaro.org Received: by 2002:a2e:8595:0:0:0:0:0 with SMTP id b21-v6csp812744lji; Tue, 25 Sep 2018 07:40:51 -0700 (PDT) X-Received: by 2002:a19:f817:: with SMTP id a23-v6mr1090907lff.67.1537886451507; Tue, 25 Sep 2018 07:40:51 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1537886451; cv=none; d=google.com; s=arc-20160816; b=tNvj1vLUCfV7qROcFk6Dn6WzAOGpaBQ6oabNt3x0L3TA6EHHa6ONszm4OmEpUuXGjS ODUsRJzvrfFeY4tSjD74bEHWfKK3g6YPoD3b7M86IYmcmV3ECF2def7R8+MX2UtBLBxn mZTkNS0pZ6o3naKzJkTgtJzFC3N8C2KfWX7K6TJmlul7p7feViw+6rIfpSx8IseFApVs wQTrO0B9QgBv8m+0ak1F/UxeyA+fE6JYlz4wl7IznIwSjqN+4uq329tldbQxZK4h7DpS HLb/9b9E63iv5hjNHeZ437gDxZu7pVU7T2byOKJE7JlOJiQTabRESuzL8heLIIz4lGIz IYSw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=Rp/ZCXPYRtdgISjdOOiOni0SDqz93sGn9zJuuVnIyW0=; b=hrEWBVhAZRaXOZxtXC84iXddkwx7BasMPey7/TRk2LGjN+10Jz+HUvrCLGN1yS72gJ ikOZXhjyI6KnGIO9m9rTsiGUoIfyPpYWya/GcKgKNa4g6jcc5xgqHA/bmkMg9A0WkHnH iBMGsWYkGvz71fGOGAls00aP3WUUP4jsz4JVDGMhfzHcYgLDyfCXshB/M/XxsgpupNNv MZZtg1IcDr/zqvZbZ606EipeaOk5xPolBDJAPiOfiyiEm7vt5aBo5Ju4G0NVNTvawBzh o602aDUsrz0NxkmxDylviiLrD6wRbVI8Whl8F/19zdUbhMLvc8fBzrM8QNrBPQQh2TX2 xXBA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Mg5hMlt4; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id j23-v6sor1621520ljh.35.2018.09.25.07.40.51 for (Google Transport Security); Tue, 25 Sep 2018 07:40:51 -0700 (PDT) Received-SPF: pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Mg5hMlt4; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=Rp/ZCXPYRtdgISjdOOiOni0SDqz93sGn9zJuuVnIyW0=; b=Mg5hMlt4H9knIexbVUOjIrrMV/VzMYD7cgLHJ2PovAb5y/hwKwIhZFcd5y2jH3a/bZ ZVDoGEUujG8dRM7fp7jvNzyAmIl/ap37G8u6JnfR5AIclpGl7w2mLbta13yjT/za75/k SoaItd014eQdRsDGE3UFnHRx8XKilamMyD2CA= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=Rp/ZCXPYRtdgISjdOOiOni0SDqz93sGn9zJuuVnIyW0=; b=SbJ5pv3SZUSq4Nj8Yqi2Bu4miF48MwWVQN4OQY4x7iEiG7AuCELQ7YOFOjWKM/rP3T gTyNAorpIYBX+ww8GBWINJNE2L32XgmvJlAm4nHqYQWBY3W5O37sPOTnb/DrKBjk0QLI VboeQtzAIYZj/jT8LmxZbWQ/DYFwczARhzwRfv9/5DRaZbPEVlWrPdvomwgf2sT4Gjy8 eDG7gRek96Kjb6qhtYmyPlcSj6tqS8aoPQPe/JTOP+7CWigb9BA3CpQQtKadSM+HQl1E ZlOO9sf3muC8orfPyulb2nVTwRN9XBcRFj6iOYxYtazfLVTZ+PgjCAod2PQovTE9bbbO 7Jmg== X-Gm-Message-State: ABuFfoiKDXv9Dhp2z+ueX24C5qDrk1SvfymbgqaHnq69+BPQJ9MCRSr+ 4DCkF64lozAlgiMgPPqnm4c25aDN X-Google-Smtp-Source: ACcGV62KfKahAa0sW1a4VN5wufv4r4h4+buzjEtMPqcedxwlkUsyDfSS34inLyaHQWrrBDiUuSDSTQ== X-Received: by 2002:a2e:5215:: with SMTP id g21-v6mr1155949ljb.144.1537886451074; Tue, 25 Sep 2018 07:40:51 -0700 (PDT) Return-Path: Received: from jax.urgonet (h-84-105.A175.priv.bahnhof.se. [79.136.84.105]) by smtp.gmail.com with ESMTPSA id g14-v6sm14483lja.96.2018.09.25.07.40.49 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 25 Sep 2018 07:40:50 -0700 (PDT) From: Jens Wiklander To: u-boot@lists.denx.de Cc: Simon Glass , Igor Opaniuk , Tom Rini , Jaehoon Chung , Pierre Aubert , Albert Aribaud , Peter Griffin , Michal Simek , Jens Wiklander Subject: [PATCH v4 14/19] tee: add sandbox driver Date: Tue, 25 Sep 2018 16:40:18 +0200 Message-Id: <20180925144023.24555-15-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180925144023.24555-1-jens.wiklander@linaro.org> References: <20180925144023.24555-1-jens.wiklander@linaro.org> Adds a sandbox tee driver which emulates a generic TEE with the OP-TEE AVB TA. Reviewed-by: Simon Glass Signed-off-by: Jens Wiklander --- drivers/tee/Kconfig | 18 ++- drivers/tee/Makefile | 1 + drivers/tee/optee/Kconfig | 2 +- drivers/tee/sandbox.c | 308 ++++++++++++++++++++++++++++++++++++++ include/sandboxtee.h | 21 +++ 5 files changed, 347 insertions(+), 3 deletions(-) create mode 100644 drivers/tee/sandbox.c create mode 100644 include/sandboxtee.h -- 2.17.1 Reviewed-by: Simon Glass diff --git a/drivers/tee/Kconfig b/drivers/tee/Kconfig index 835c256e9239..5c0c89043fac 100644 --- a/drivers/tee/Kconfig +++ b/drivers/tee/Kconfig @@ -1,8 +1,8 @@ # Generic Trusted Execution Environment Configuration config TEE bool "Trusted Execution Environment support" - depends on ARM && (ARM64 || CPU_V7A) - select ARM_SMCCC + depends on (ARM && (ARM64 || CPU_V7A)) || SANDBOX + select ARM_SMCCC if ARM help This implements a generic interface towards a Trusted Execution Environment (TEE). A TEE is a trusted OS running in some secure @@ -14,6 +14,20 @@ if TEE menu "TEE drivers" +config SANDBOX_TEE + bool "Sandbox TEE emulator" + depends on SANDBOX + default y + help + This emulates a generic TEE needed for testing including the AVB + TA. The emulation provides all callbacks of a regular TEE and + supports session and shared memory management. The AVB TA is + emulated with rollback indexes and device lock-state, the state + of the TA is only kept in RAM and will be reset on each boot. + The emulation only supports one open session at a time. + Interaction from the U-Boot command line in possible via the + "avb" commands. + source "drivers/tee/optee/Kconfig" endmenu diff --git a/drivers/tee/Makefile b/drivers/tee/Makefile index 19633b60f235..f72c68c09f33 100644 --- a/drivers/tee/Makefile +++ b/drivers/tee/Makefile @@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0+ obj-y += tee-uclass.o +obj-$(CONFIG_SANDBOX) += sandbox.o obj-$(CONFIG_OPTEE) += optee/ diff --git a/drivers/tee/optee/Kconfig b/drivers/tee/optee/Kconfig index dbfa7846a30f..d489834df926 100644 --- a/drivers/tee/optee/Kconfig +++ b/drivers/tee/optee/Kconfig @@ -10,7 +10,7 @@ config OPTEE handle Remote Procedure Calls (RPC) from OP-TEE needed to execute a service. For more information see: https://www.op-tee.org -if OPTEE +if OPTEE || SANDBOX menu "OP-TEE options" diff --git a/drivers/tee/sandbox.c b/drivers/tee/sandbox.c new file mode 100644 index 000000000000..10a1e8dffa69 --- /dev/null +++ b/drivers/tee/sandbox.c @@ -0,0 +1,308 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Copyright (C) 2018 Linaro Limited + */ +#include +#include +#include +#include +#include + +/* + * The sandbox tee driver tries to emulate a generic Trusted Exectution + * Environment (TEE) with the Trusted Application (TA) OPTEE_TA_AVB + * available. + */ + +/** + * struct ta_entry - TA entries + * @uuid: UUID of an emulated TA + * @open_session Called when a session is openened to the TA + * @invoke_func Called when a function in the TA is to be invoked + * + * This struct is used to register TAs in this sandbox emulation of a TEE. + */ +struct ta_entry { + struct tee_optee_ta_uuid uuid; + u32 (*open_session)(uint num_params, struct tee_param *params); + u32 (*invoke_func)(u32 func, uint num_params, struct tee_param *params); +}; + +#ifdef CONFIG_OPTEE_TA_AVB +static u32 get_attr(uint n, uint num_params, struct tee_param *params) +{ + if (n >= num_params) + return TEE_PARAM_ATTR_TYPE_NONE; + + return params[n].attr; +} + +static u32 check_params(u8 p0, u8 p1, u8 p2, u8 p3, uint num_params, + struct tee_param *params) +{ + u8 p[] = { p0, p1, p2, p3}; + uint n; + + for (n = 0; n < ARRAY_SIZE(p); n++) + if (p[n] != get_attr(n, num_params, params)) + goto bad_params; + + for (; n < num_params; n++) + if (get_attr(n, num_params, params)) + goto bad_params; + + return TEE_SUCCESS; + +bad_params: + printf("Bad param attrs\n"); + + return TEE_ERROR_BAD_PARAMETERS; +} + +static u64 ta_avb_rollback_indexes[TA_AVB_MAX_ROLLBACK_LOCATIONS]; +static u32 ta_avb_lock_state; + +static u32 ta_avb_open_session(uint num_params, struct tee_param *params) +{ + /* + * We don't expect additional parameters when opening a session to + * this TA. + */ + return check_params(TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE, + TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE, + num_params, params); +} + +static u32 ta_avb_invoke_func(u32 func, uint num_params, + struct tee_param *params) +{ + u32 res; + uint slot; + u64 val; + + switch (func) { + case TA_AVB_CMD_READ_ROLLBACK_INDEX: + res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT, + TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT, + TEE_PARAM_ATTR_TYPE_NONE, + TEE_PARAM_ATTR_TYPE_NONE, + num_params, params); + if (res) + return res; + + slot = params[0].u.value.a; + if (slot >= ARRAY_SIZE(ta_avb_rollback_indexes)) { + printf("Rollback index slot out of bounds %lu\n", slot); + return TEE_ERROR_BAD_PARAMETERS; + } + + val = ta_avb_rollback_indexes[slot]; + params[1].u.value.a = val >> 32; + params[1].u.value.b = val; + return TEE_SUCCESS; + + case TA_AVB_CMD_WRITE_ROLLBACK_INDEX: + res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT, + TEE_PARAM_ATTR_TYPE_VALUE_INPUT, + TEE_PARAM_ATTR_TYPE_NONE, + TEE_PARAM_ATTR_TYPE_NONE, + num_params, params); + if (res) + return res; + + slot = params[0].u.value.a; + if (slot >= ARRAY_SIZE(ta_avb_rollback_indexes)) { + printf("Rollback index slot out of bounds %lu\n", slot); + return TEE_ERROR_BAD_PARAMETERS; + } + + val = (u64)params[1].u.value.a << 32 | params[1].u.value.b; + if (val < ta_avb_rollback_indexes[slot]) + return TEE_ERROR_SECURITY; + + ta_avb_rollback_indexes[slot] = val; + return TEE_SUCCESS; + + case TA_AVB_CMD_READ_LOCK_STATE: + res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT, + TEE_PARAM_ATTR_TYPE_NONE, + TEE_PARAM_ATTR_TYPE_NONE, + TEE_PARAM_ATTR_TYPE_NONE, + num_params, params); + if (res) + return res; + + params[0].u.value.a = ta_avb_lock_state; + return TEE_SUCCESS; + + case TA_AVB_CMD_WRITE_LOCK_STATE: + res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT, + TEE_PARAM_ATTR_TYPE_NONE, + TEE_PARAM_ATTR_TYPE_NONE, + TEE_PARAM_ATTR_TYPE_NONE, + num_params, params); + if (res) + return res; + + if (ta_avb_lock_state != params[0].u.value.a) { + ta_avb_lock_state = params[0].u.value.a; + memset(ta_avb_rollback_indexes, 0, + sizeof(ta_avb_rollback_indexes)); + } + + return TEE_SUCCESS; + + default: + return TEE_ERROR_NOT_SUPPORTED; + } +} +#endif /*OPTEE_TA_AVB*/ + +static const struct ta_entry ta_entries[] = { +#ifdef CONFIG_OPTEE_TA_AVB + { .uuid = TA_AVB_UUID, + .open_session = ta_avb_open_session, + .invoke_func = ta_avb_invoke_func, + }, +#endif +}; + +static void sandbox_tee_get_version(struct udevice *dev, + struct tee_version_data *vers) +{ + struct tee_version_data v = { + .gen_caps = TEE_GEN_CAP_GP | TEE_GEN_CAP_REG_MEM, + }; + + *vers = v; +} + +static int sandbox_tee_close_session(struct udevice *dev, u32 session) +{ + struct sandbox_tee_state *state = dev_get_priv(dev); + + if (!state->ta || state->session != session) + return -EINVAL; + + state->session = 0; + state->ta = NULL; + + return 0; +} + +static const struct ta_entry *find_ta_entry(u8 uuid[TEE_UUID_LEN]) +{ + struct tee_optee_ta_uuid u; + uint n; + + tee_optee_ta_uuid_from_octets(&u, uuid); + + for (n = 0; n < ARRAY_SIZE(ta_entries); n++) + if (!memcmp(&u, &ta_entries[n].uuid, sizeof(u))) + return ta_entries + n; + + return NULL; +} + +static int sandbox_tee_open_session(struct udevice *dev, + struct tee_open_session_arg *arg, + uint num_params, struct tee_param *params) +{ + struct sandbox_tee_state *state = dev_get_priv(dev); + const struct ta_entry *ta; + + if (state->ta) { + printf("A session is already open\n"); + return -EBUSY; + } + + ta = find_ta_entry(arg->uuid); + if (!ta) { + printf("Cannot find TA\n"); + arg->ret = TEE_ERROR_ITEM_NOT_FOUND; + arg->ret_origin = TEE_ORIGIN_TEE; + + return 0; + } + + arg->ret = ta->open_session(num_params, params); + arg->ret_origin = TEE_ORIGIN_TRUSTED_APP; + + if (!arg->ret) { + state->ta = (void *)ta; + state->session = 1; + arg->session = state->session; + } else { + printf("Cannot open session, TA returns error\n"); + } + + return 0; +} + +static int sandbox_tee_invoke_func(struct udevice *dev, + struct tee_invoke_arg *arg, + uint num_params, struct tee_param *params) +{ + struct sandbox_tee_state *state = dev_get_priv(dev); + struct ta_entry *ta = state->ta; + + if (!arg->session) { + printf("Missing session\n"); + return -EINVAL; + } + + if (!ta) { + printf("TA session not available\n"); + return -EINVAL; + } + + if (arg->session != state->session) { + printf("Session mismatch\n"); + return -EINVAL; + } + + arg->ret = ta->invoke_func(arg->func, num_params, params); + arg->ret_origin = TEE_ORIGIN_TRUSTED_APP; + + return 0; +} + +static int sandbox_tee_shm_register(struct udevice *dev, struct tee_shm *shm) +{ + struct sandbox_tee_state *state = dev_get_priv(dev); + + state->num_shms++; + + return 0; +} + +static int sandbox_tee_shm_unregister(struct udevice *dev, struct tee_shm *shm) +{ + struct sandbox_tee_state *state = dev_get_priv(dev); + + state->num_shms--; + + return 0; +} + +static const struct tee_driver_ops sandbox_tee_ops = { + .get_version = sandbox_tee_get_version, + .open_session = sandbox_tee_open_session, + .close_session = sandbox_tee_close_session, + .invoke_func = sandbox_tee_invoke_func, + .shm_register = sandbox_tee_shm_register, + .shm_unregister = sandbox_tee_shm_unregister, +}; + +static const struct udevice_id sandbox_tee_match[] = { + { .compatible = "sandbox,tee" }, + {}, +}; + +U_BOOT_DRIVER(sandbox_tee) = { + .name = "sandbox_tee", + .id = UCLASS_TEE, + .of_match = sandbox_tee_match, + .ops = &sandbox_tee_ops, + .priv_auto_alloc_size = sizeof(struct sandbox_tee_state), +}; diff --git a/include/sandboxtee.h b/include/sandboxtee.h new file mode 100644 index 000000000000..44f653d9cf3b --- /dev/null +++ b/include/sandboxtee.h @@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (C) 2018 Linaro Limited + */ + +#ifndef __SANDBOXTEE_H +#define __SANDBOXTEE_H + +/** + * struct sandbox_tee_state - internal state of the sandbox TEE + * @session: current open session + * @num_shms: number of registered shared memory objects + * @ta: Trusted Application of current session + */ +struct sandbox_tee_state { + u32 session; + int num_shms; + void *ta; +}; + +#endif /*__SANDBOXTEE_H*/