lkml.org 
[lkml]   [2018]   [Nov]   [3]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v15 18/23] x86/sgx: Add sgx_einit() for initializing enclaves
    Date
    From: Sean Christopherson <sean.j.christopherson@intel.com>

    Add a helper function to perform ENCLS(EINIT) with the correct LE
    hash MSR values. ENCLS[EINIT] initializes an enclave, verifying the
    enclave's measurement and preparing it for execution, i.e. the enclave
    cannot be run until it has been initialized. The measurement aspect
    of EINIT references the MSR_IA32_SGXLEPUBKEYHASH* MSRs, with the CPU
    comparing CPU compares the key (technically its hash) used to sign the
    enclave[1] with the key hash stored in the MSRs, and will reject EINIT
    if the keys do not match.

    A per-cpu cache is used to avoid writing the MSRs as writing the MSRs
    is extraordinarily expensive, e.g. 300-400 cycles per MSR. Because
    the cache may become stale, force update the MSRs and retry EINIT if
    the first EINIT fails due to an "invalid token". An invalid token
    error does not necessarily mean the MSRs need to be updated, but the
    cost of an unnecessary write is minimal relative to the cost of EINIT
    itself.

    [1] For EINIT's purposes, the effective signer of the enclave may be
    the enclave's owner, or a separate Launch Enclave that has created
    an EINIT token for the target enclave. When using an EINIT token,
    the key used to sign the token must match the MSRs in order for
    EINIT to succeed.

    Signed-off-by: Sean Christopherson <sean.j.christopherson@intel.com>
    Co-developed-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
    Signed-off-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
    ---
    arch/x86/include/asm/sgx.h | 2 ++
    arch/x86/kernel/cpu/intel_sgx.c | 50 +++++++++++++++++++++++++++++++++
    2 files changed, 52 insertions(+)

    diff --git a/arch/x86/include/asm/sgx.h b/arch/x86/include/asm/sgx.h
    index 4e39bcfad018..b6f014d0d88d 100644
    --- a/arch/x86/include/asm/sgx.h
    +++ b/arch/x86/include/asm/sgx.h
    @@ -312,5 +312,7 @@ static inline int __emodt(struct sgx_secinfo *secinfo, void __iomem *addr)
    struct sgx_epc_page *sgx_alloc_page(void);
    int __sgx_free_page(struct sgx_epc_page *page);
    void sgx_free_page(struct sgx_epc_page *page);
    +int sgx_einit(struct sgx_sigstruct *sigstruct, struct sgx_einittoken *token,
    + struct sgx_epc_page *secs, u64 *lepubkeyhash);

    #endif /* _ASM_X86_SGX_H */
    diff --git a/arch/x86/kernel/cpu/intel_sgx.c b/arch/x86/kernel/cpu/intel_sgx.c
    index b06709a9ea65..19041e96d1da 100644
    --- a/arch/x86/kernel/cpu/intel_sgx.c
    +++ b/arch/x86/kernel/cpu/intel_sgx.c
    @@ -15,6 +15,9 @@ EXPORT_SYMBOL_GPL(sgx_epc_sections);

    static int sgx_nr_epc_sections;

    +/* A per-cpu cache for the last known values of IA32_SGXLEPUBKEYHASHx MSRs. */
    +static DEFINE_PER_CPU(u64 [4], sgx_lepubkeyhash_cache);
    +
    /**
    * sgx_alloc_page - Allocate an EPC page
    *
    @@ -91,6 +94,53 @@ void sgx_free_page(struct sgx_epc_page *page)
    }
    EXPORT_SYMBOL_GPL(sgx_free_page);

    +static void sgx_update_lepubkeyhash_msrs(u64 *lepubkeyhash, bool enforce)
    +{
    + u64 __percpu *cache;
    + int i;
    +
    + cache = per_cpu(sgx_lepubkeyhash_cache, smp_processor_id());
    + for (i = 0; i < 4; i++) {
    + if (enforce || (lepubkeyhash[i] != cache[i])) {
    + wrmsrl(MSR_IA32_SGXLEPUBKEYHASH0 + i, lepubkeyhash[i]);
    + cache[i] = lepubkeyhash[i];
    + }
    + }
    +}
    +
    +/**
    + * sgx_einit - initialize an enclave
    + * @sigstruct: a pointer a SIGSTRUCT
    + * @token: a pointer an EINITTOKEN (optional)
    + * @secs: a pointer a SECS
    + * @lepubkeyhash: the desired value for IA32_SGXLEPUBKEYHASHx MSRs
    + *
    + * Execute ENCLS[EINIT], writing the IA32_SGXLEPUBKEYHASHx MSRs according
    + * to @lepubkeyhash (if possible and necessary).
    + *
    + * Return:
    + * 0 on success,
    + * -errno or SGX error on failure
    + */
    +int sgx_einit(struct sgx_sigstruct *sigstruct, struct sgx_einittoken *token,
    + struct sgx_epc_page *secs, u64 *lepubkeyhash)
    +{
    + int ret;
    +
    + if (!boot_cpu_has(X86_FEATURE_SGX_LC))
    + return __einit(sigstruct, token, sgx_epc_addr(secs));
    +
    + preempt_disable();
    + sgx_update_lepubkeyhash_msrs(lepubkeyhash, false);
    + ret = __einit(sigstruct, token, sgx_epc_addr(secs));
    + if (ret == SGX_INVALID_EINITTOKEN) {
    + sgx_update_lepubkeyhash_msrs(lepubkeyhash, true);
    + ret = __einit(sigstruct, token, sgx_epc_addr(secs));
    + }
    + preempt_enable();
    + return ret;
    +}
    +EXPORT_SYMBOL(sgx_einit);

    static __init void sgx_free_epc_section(struct sgx_epc_section *section)
    {
    --
    2.19.1
    \
     
     \ /
      Last update: 2018-11-03 00:18    [W:3.779 / U:0.056 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site