Feature licensing in a secure processing environment

Embodiments of an invention for feature licensing in a secure processing environment are disclosed. In one embodiment, a processor includes an instruction unit and an execution unit. The instruction unit is to receive an instruction to initialize a secure enclave. The execution unit is to execute the instruction. Execution of the instruction includes determining whether a requested feature is licensed for use in the secure enclave.

BACKGROUND

The present disclosure pertains to the field of information processing, and more particularly, to the field of security in information processing systems.

2. Description of Related Art

Confidential information is stored, transmitted, and used by many information processing systems. Therefore, techniques have been developed to provide for the secure handling and storing of confidential information. These techniques include various approaches to creating and maintaining a secured, protected, or isolated container, partition, or environment within an information processing system.

DETAILED DESCRIPTION

Embodiments of an invention for feature licensing in a secure processing environment are described. In this description, numerous specific details, such as component and system configurations, may be set forth in order to provide a more thorough understanding of the present invention. It will be appreciated, however, by one skilled in the art, that the invention may be practiced without such specific details. Additionally, some well-known structures, circuits, and other features have not been shown in detail, to avoid unnecessarily obscuring the present invention.

In the following description, references to “one embodiment,” “an embodiment,” “example embodiment,” “various embodiments,” etc., indicate that the embodiment(s) of the invention so described may include particular features, structures, or characteristics, but more than one embodiment may and not every embodiment necessarily does include the particular features, structures, or characteristics. Further, some embodiments may have some, all, or none of the features described for other embodiments.

As used in the claims, unless otherwise specified the use of the ordinal adjectives “first,” “second,” “third,” etc. to describe an element merely indicate that a particular instance of an element or different instances of like elements are being referred to, and is not intended to imply that the elements so described must be in a particular sequence, either temporally, spatially, in ranking, or in any other manner.

Also, the terms “bit,” “flag,” “field,” “entry,” “indicator,” etc., may be used to describe any type of storage location in a register, table, database, or other data structure, whether implemented in hardware or software, but are not meant to limit embodiments of the invention to any particular type of storage location or number of bits or other elements within any particular storage location. The term “clear” may be used to indicate storing or otherwise causing the logical value of zero to be stored in a storage location, and the term “set” may be used to indicate storing or otherwise causing the logical value of one, all ones, or some other specified value to be stored in a storage location; however, these terms are not meant to limit embodiments of the present invention to any particular logical convention, as any logical convention may be used within embodiments of the present invention.

As described in the background section, various approaches to creating and maintaining a secured, protected, or isolated container, partition, or environment within an information processing system have been developed. One such approach involves secure enclaves as described in the co-pending U.S. patent application entitled “Method and Apparatus to Provide Secure application Execution,” filed Jun. 19, 2012, Ser. No. 13/527,547, which provides information regarding at least one embodiment of a secured, protected, or isolated container, partition, or environment. However, this reference is not intended to limit the scope of embodiments of the invention in any way and other embodiments may be used while remaining within the spirit and scope of the present invention. Therefore, any instance of any secured, protected, or isolated container, partition, or environment used in any embodiment of the present invention may be referred to herein as a secure enclave or an enclave.

FIG. 1illustrates system100, an information processing system in which features may be licensed in a secure processing environment according to an embodiment of the present invention. System100may represent any type of information processing system, such as a server, a desktop computer, a portable computer, a set-top box, a hand-held device such as a tablet or a smart phone, or an embedded control system. System100includes processor110, peripheral control agent120, system memory130, and information storage device140. Systems embodying the present invention may include any number of each of these components and any other components or other elements, such as peripherals and input/output devices. Any or all of the components or other elements in this or any system embodiment, may be connected, coupled, or otherwise in communication with each other through any number of buses, point-to-point, or other wired or wireless interfaces or connections, unless specified otherwise. Any components or other portions of system100, whether shown inFIG. 1or not shown inFIG. 1, may be integrated or otherwise included on or in a single chip (a system-on-a-chip or SOC), die, substrate, or package.

Peripheral control agent120may represent any component including or through which peripheral, input/output, or other components or devices may be connected or coupled to processor110, such as a chipset. Peripheral control agent120may be connected or coupled to processor110by interface115, which may represent any type of bus, point-to-point, or other wired or wireless interface or connection, including a link in an interconnect fabric such as an Intel® Quick Path Interconnect or an embodiment of a High Performance Interconnect described in the co-pending U.S. patent application entitled Method, Apparatus, System for a High Performance Interconnect architecture, filed Oct. 22, 2012, Ser. No. 61/717,091, or any other type of connection according to any other communication architecture.

System memory130may be dynamic random access memory or any other type of medium readable by processor110. Information storage device140may include any type of persistent or non-volatile memory or storage, such as a flash memory and/or a solid state, magnetic, or optical disk drive.

Processor110may represent one or more processors integrated on a single substrate or packaged within a single package, each of which may include multiple threads and/or multiple execution cores, in any combination. Each processor represented as or in processor110may be any type of processor, including a general purpose microprocessor, such as a processor in the Intel® Core® Processor Family, Intel® Atom® Processor Family, or other processor family from Intel® Corporation, or another processor from another company, or a special purpose processor or microcontroller.

Processor110may operate according to an instruction set architecture that includes a first instruction to create a secure enclave, a second instruction to add content to an enclave, a third instruction to measure content of an enclave, a fourth instruction to initialize an enclave, and a fifth instruction to get a key to be used for licensing. Although embodiments of the present invention may be practiced with a processor having any instruction set architecture and are not limited to the architecture of a processor family from Intel® Corporation, the instructions may be part of a set of software protection extensions to an existing architecture, and may be referred to herein as an ECREATE instruction, an EADD instruction, an EEXTEND instruction, an EINIT instruction, and an EGETKEY instruction respectively. Support for these instructions may be implemented in a processor using any combination of circuitry and/or logic embedded in hardware, microcode, firmware, and/or other structures arranged as described below or according to any other approach, and is represented inFIG. 1as ECREATE hardware112, EADD hardware114, EEXTEND hardware116, EINIT hardware118, and EGETKEY hardware119.

FIG. 2illustrates processor200, an embodiment of which may serve as processor110in system100. Processor200may include core210, core220, and uncore230. Core210may include storage unit212, instruction unit214, execution unit270, control unit218, and key216. Core220may include storage unit222, instruction unit224, execution unit270, control unit228, and key226. Uncore230may include cache unit232, interface unit234, processor reserved memory range registers250, and memory access control unit260. Processor200may also include any other circuitry, structures, or logic not shown inFIG. 2. The functionality of the ECREATE hardware112, the EADD hardware114, the EEXTEND hardware116, the EINIT hardware118, and the EGETKEY hardware119, as introduced above and further described below, may be distributed among any of the labeled units or elsewhere in processor200.

Storage units212and222may include any combination of any type of storage usable for any purpose within cores210and220, respectively; for example, they may include any number of readable, writable, and/or read-writable registers, buffers, and/or caches, implemented using any memory or storage technology, for storing capability information, configuration information, control information, status information, performance information, instructions, data, and any other information usable in the operation of cores210and220, respectively, as well as circuitry usable to access such storage.

Instruction units214and224may include any circuitry, logic, structures, and/or other hardware for fetching, receiving, decoding, interpreting, and/or scheduling instructions to be executed by cores210and220, respectively. Any instruction format may be used within the scope of the present invention; for example, an instruction may include an opcode and one or more operands, where the opcode may be decoded into one or more micro-instructions or micro-operations for execution by execution unit216or226, respectively. Instructions, such as the ECREATE, EADD, EEXTEND, and EINIT instructions, may be leaves of a single opcode, such as a privileged secure enclave opcode (e.g., ENCLS), where the leaf instructions are specified by the value in a processor register (e.g., EAX). Instructions, such as the EGETKEY instruction, may be also be leaves of a single opcode, such as an unprivileged secure enclave opcode (e.g., ENCLU), where the leaf instructions are also specified by the value in a processor register (e.g., EAX). Operands or other parameters may be associated with an instruction implicitly, directly, indirectly, or according to any other approach.

Execution units270and280may include any circuitry, logic, structures, and/or other hardware, such as arithmetic units, logic units, floating point units, shifters, etc., for processing data and executing instructions, micro-instructions, and/or micro-operations. Execution units270and280may include dedicated circuitry, logic, structures, and/or other hardware for measuring data according to embodiments of the present invention or any such measurements may be performed with shared circuitry, logic, structures, and/or other hardware in execution unit270and280and/or elsewhere in processor200. Execution units270and280may include encryption units272and282respectively.

Encryption units272and282may represent any circuitry, logic, structures, and/or other hardware to execute any one or more encryption algorithm, the corresponding decryption algorithms, and/or hashing algorithms. Encryption units272and282may include SHA logic 274 and 284, respectively, to implement a secure hash algorithm such as SHA-256, SHA-512, SHA-3, or SM3, and/or MAC logic 276 and 286, respectively, to generate a method authentication code (MAC), such as an Advanced Encryption Standard Cipher-based MAC (AES-CMAC), and/or any of SHA logic 274, SHA logic 284, MAC logic 276, and MAC logic 286 may represent any dedicated or shared circuitry, logic, structures, and/or other hardware elsewhere in processor200to perform these functions. For calculating MACs, MAC logic 276 and 286 may use key216and226, respectively, each of which may represent any key, such as a processor or platform unique key programmed into processor200in a fuse array, generated during a boot process, and/or otherwise available as a secret key to be used in a MAC algorithm or for any other purpose.

Control units218and228may include any microcode, firmware, circuitry, logic, structures, and/or other hardware to control the operation of the units and other elements of cores210and220, respectively, and the transfer of data within, into, and out of cores210and220. Control units218and228may cause cores210and220and processor200to perform or participate in the performance of method embodiments of the present invention, such as the method embodiments described below, for example, by causing cores210and220to execute instructions received by instruction units214and224and micro-instructions or micro-operations derived from instructions received by instruction units214and224.

Cache unit232may include any number of cache arrays and cache controllers in one or more levels of cache memory in a memory hierarchy of information processing system100, implemented in static random access memory or any other memory technology. Cache unit232may be shared among any number of cores and/or logical processors within processor200according to any approach to caching in information processing systems. Cache unit232may also include one or more memory arrays to be used as enclave page cache (EPC)240as further described below.

Interface unit234may represent any circuitry, logic, structures, and/or other hardware, such as a link unit, a bus unit, or a messaging unit to allow processor200to communicate with other components in a system such as system200through any type of bus, point to point, or other connection, directly or through any other component, such as a bridge, hub, or chipset. Interface unit234may include one or more integrated memory controllers to communicate with a system memory such as system memory130or may communicate with a system memory through one or more memory controllers external to processor200.

Processor reserved memory range registers (PRMRR)250may represent any one or more storage locations in storage units212and222, elsewhere in processor200, and/or copies thereof in uncore230. PRMRR250may be used, for example by configuration firmware such as a basic input/output system, to reserve one or more physically contiguous ranges of memory called processor reserved memory (PRM). Memory access control unit260may represent any circuitry, structures, logic, and/or other hardware anywhere in processor200that may control access to PRM such that EPC240may be created within the system memory space defined as PRM.

In an embodiment, PRM is of a size that is an integer power of two, e.g. 32 MB, 64 MB, or 128 MB, and is aligned to a memory address that is a multiple of that size. PRMRR250may include one or more instances of a read-only PRMMR valid configuration register252to indicate the valid sizes to which PRM may be configured, one or more instances of a PRMMR base register254and a PRMMR mask register256to define one or more base addresses and ranges of PRM.

EPC240is a secure storage area in which software may be protected from attacks by malware operating at any privilege level. One or more secure enclaves may be created such that each enclave may include one or more pages or other regions of EPC240in which to store code, data, or other information in a way that it may only be accessed by software running inside that enclave. For example, a secure enclave may be used by a software application so that only that software application, while running inside that enclave, may access the contents of that enclave. No other software, not even an operating system or a virtual machine monitor, may read the unencrypted contents of that enclave, modify the contents of that enclave, or otherwise tamper with the contents of that enclave while the content is loaded into the EPC (assuming that the enclave is a production enclave, as opposed to, for example, a debug enclave). However, the contents of the enclave may be accessed by software executing from within that enclave on any processor in system100. This protection is accomplished by the memory access control unit260operating according to the secure enclaves architecture.

InFIG. 2, EPC240is shown in cache unit232, where it may be a sequestered portion of a shared cache or a dedicated memory. Within or on the same die as processor200, EPC240may be implemented in static random access memory, embedded dynamic random access memory, or any other memory technology. EPC240may also or additionally be implemented external to processor200, for example within a secure region of system memory130. To protect the content of secure enclaves when it is not stored on-die, encryption units272and/or282may be used to encrypt the content before it is transferred off-die and to decrypt the content transferred back into EPC240on-die. Other protection mechanisms may also be applied to protect the content from replay and other attacks.

FIG. 3illustrates EPC300, an embodiment of which may serve as EPC240inFIG. 2. InFIG. 3, EPC300includes secure enclave control structure (SECS)310, thread control structure (TCS) region320, and data region330. AlthoughFIG. 3shows EPC300divided into three separate regions, EPC300may be divided into any number of chunks, regions, or pages, each of which may be used for any type of content. In one embodiment, it is divided into 4 kilobyte (KB) pages and is aligned to an address in system memory130that is a multiple of 4 KB, SECS310may be any one of the 4 KB pages in EPC300, TCS region320may be any number of contiguous or non-contiguous 4 KB pages, and data region330may be any number of contiguous or non-contiguous 4 KB pages. Furthermore, althoughFIG. 3shows one SECS, one TCS region, and one data region corresponding to one secure enclave, an EPC may include any number of SECS and any number of TCS and data regions, so long as each enclave has one and only one SECS, each valid TCS and valid data region (e.g., page) belongs to one and only one enclave, and all of the SECS, TCS, and data pages fit within the EPC (or may be paged out of and back into the EPC).

An SECS is created by the execution of the ECREATE instruction to contain metadata to be used by hardware, and accessible only by hardware (i.e., not readable, writable, or otherwise accessible by software, whether running inside or outside the enclave), to define, maintain, and protect the enclave. For example, SECS310includes a first measurement register (MRENCLAVE)312, which may be any size field within SECS310; in one embodiment, MRENCLAVE312may be 32 bytes. MRENCLAVE312is to store the build measurement (as described below) of the enclave, which is initialized by the ECREATE instruction, updated by every EADD and EEXTEND instruction associated with the enclave, and locked by the EINIT instruction associated with the enclave. SECS310also includes a second measurement register (MRSIGNER)314to store a measurement of an identifier, such as a public key, of the entity that verified the creation of the enclave, as further described below. In one embodiment, MRSIGNER314may be 32 bytes. Enclave attributes, as described below, may be stored in ATTRIBUTES field316, which in one embodiment may have a size of 16 bytes.

One or more TCSs may also be associated with a secure enclave. A TCS contains metadata used by the hardware to save and restore thread specific information when entering and exiting the enclave.

The security attributes of each page are stored in a micro-architectural data structure called an enclave page cache map (EPCM) that is used by memory access control unit260to enforce the protections provided by the secure enclaves architecture. The EPCM stores one entry for each page in the EPC. Each entry includes an identifier (e.g., a 64 bit field) of the SECS (i.e., the enclave) to which the page belongs. These identifiers may be referred to by secure enclaves instructions (e.g., the address of the SECS may be stored in a register such as RCX, the address of a micro-architectural data structure including the address of the SECS may be stored in a register such as RBX, etc.) such as EADD, EEXTEND, and EINIT, to provide for the SECS to be read by hardware in order to execute the instruction.

FIG. 4illustrates architecture400, an architecture for feature licensing in a secure processing environment according to an embodiment of the present invention. In one embodiment, architecture400includes platform410, independent software vendor (ISV)450, feature licensor460, and license server470.

Platform410may be an embodiment of system100, in which secure enclaves420,430, and440may be created on a processor such as processor110. License enclave420may be a licensing enclave responsible for verifying licenses and granting license tokens (as described below) according to embodiments of the present invention. User enclave430may be a user enclave created by software installer application432running outside of user enclave430. User software application434may run inside user enclave430. Platform services enclave440may be a special purpose enclave responsible for requesting the use of features of platform410outside of processor110, for example, special storage, counters, trusted input/output, and/or other features provided by or available through peripheral control agent120.

ISV450may represent any software developer, content provider, service provider, or any other entity that may provide software, content, or services to be run, consumed, or provided on platform410. Feature licensor460may be a processor vendor, a system vendor, or any other entity that may provide license certificates for security or other features of platform410to be used by software, content consumption, or services on platform410. For example, feature licensor460may represent Intel® Corporation where processor110is in a processor family from Intel® Corporation. License server470may be any system to approve the issuance of a license according to an embodiment of the present invention.

Embodiments of the present invention may provide for platform features to be licensed by software, content, and/or service providers, such that the cost of providing such features may be borne by such providers instead of the purchaser of the platform, and the platform provider may derive income from such providers for the use of the features. Such features may include the ability to protect a software application's code and data from being read, modified, or otherwise tampered with by unauthorized users, even unauthorized users with the highest available privilege level. The use of such features may be desired by providers to protect premium media content, online banking information, enterprise document production, etc.

FIG. 5illustrates method500, a method for licensing features in a secure processing environment according to an embodiment of the present invention. Although method embodiments of the invention are not limited in this respect, reference may be made to elements ofFIGS. 1, 2, 3, and 4to help describe the method embodiment ofFIG. 5. Method500includes the building of a secure enclave using ECREATE, EADD, EEXTEND, and EINIT instructions, and a request for a key using an EGETKEY instruction; however, embodiments of the present invention are not limited to these specifically named instructions.

In box510, ISV450negotiates with feature licensor460for a license certificate to one or more security or other features of platforms including platform410. Having a license certificate for particular platform features gives ISV450the right to license platforms to use those features. According to embodiments of the present invention, particular features of a platform may be enabled for use by an application for which the ISV has obtained a license certificate and disabled otherwise. Each particular feature for which use may be enabled or disabled according to embodiments of the present invention is referred to herein as a licensable feature.

In box512, ISV450obtains a license certificate from feature licensor460for one or more of the licensable features. Each feature for which a license certificate has been obtained is referred to herein as a licensed feature. The license certificate may be a digitally signed digital certificate representing a license agreement between ISV450and feature licensor460, including an indication of which features are licensed.

In box514, ISV450provides software installer application432and user software application434to platform410. Software installer application432includes a measurement (as described below) of user software application434as it is expected to be built in user enclave430(the expected measurement of user enclave430), a measurement of an identifier (such as a public key) of ISV450, a list of platform features to be used by user software application434or the enclave in which it runs (e.g., in an ATTRIBUTES bit array), and a license certificate indicating that that software application434is licensed to use the licensed features. The license certificate may also include the two measurements and/or any other information.

In box520, software installer application432begins to prepare to install user software application434on platform400. In box522, software installer application432requests (e.g., by issuing a license token request call or instruction) a license token from license enclave420(which, as used herein, includes a licensing software application running in license enclave420). The license token may be a micro-architectural data structure (e.g., LICTOKEN) having a unique value for an enclave to be built (e.g., user enclave430). Requesting the license token in box522may include providing (e.g., from the information provided in box514), the expected measurement of user enclave430, the list of platform features requested for user enclave430, and the license certificate.

In box524, license enclave420verifies that the license certificate is authentic, for example by verifying its digital signature. In box526, license enclave420compares the list of platform features that software installer application432is requesting to the list of licensed features in the license certificate. If every requested platform feature is a licensed feature, then method500continues in box528. If not, then method500continues in box590.

In box528, license enclave420requests (e.g., by issuing an EGETKEY instruction) a key (e.g., a processor or platform unique key such as key276) to use in creating the license token. In box530, license enclave420creates the license token, which includes the expected measurement of user enclave430and an ATTRIBUTES bit array, where each bit in the LICTOKEN ATTRIBUTES bit array corresponds to a specific platform feature. If a bit in LICTOKEN ATTRIBUTES bit array is set, it means that the enclave is licensed to use the corresponding feature. In box532, a MAC (e.g., an AES-CMAC) is calculated, for example, using a license key derived from key276, where the MAC is based on the contents of the license token and is included in the license token.

In box534, the license token is provided (e.g., returned from the license token request call or instruction in box522) to software installer application432.

In box540, a build of user enclave430on platform410begins, in order to provide a protected environment in which to run user software application434. In box542, an ECREATE instruction is issued by software installer application432to create user enclave430. In box544, execution of the ECREATE instruction, for example by execution unit270or280, begins. In one embodiment, execution of the ECREATE instruction includes the allocation of a range of addresses for use by user enclave430. In one embodiment, the addresses may be a first type of address, for example a virtual or linear addresses, to be translated to a second type of address, for example a physical address in a system memory such as system memory130.

Execution of the ECREATE instruction may also include, in box546, establishing attributes of the enclave and storing the enclave attributes in an SECS, for example, in ATTRIBUTES field316of SECS310. A micro-architectural data structure (e.g., PAGEINFO), may be associated with the ECREATE instruction (e.g., its address in the RBX register). PAGEINFO may have a field specifying the address of a source SECS to be copied to SECS310. The source SECS may include a source SECS ATTRIBUTES bit array (e.g., as provided by ISV450in box516) to be copied to SECS ATTRIBUTES field316. Each bit in the source SECS ATTRIBUTES bit array and the corresponding bit in SECS ATTRIBUTES field316may correspond to a specific platform feature. If the bit is set in the source SECS ATTRIBUTES bit array, the creator of the enclave (e.g., software installer application432) intends for the corresponding feature to be enabled in the enclave being created (e.g., user enclave430), in other words, intends for the corresponding feature to be available to, usable by, or used for the software application or applications to be run in the enclave (e.g., user software application434). However, the feature is not enabled unless a license to use the feature is verified as described below or according to another embodiment of the present invention.

In box548, software installer application432may add one or more pages (or other regions) to the enclave, for example by issuing one or more EADD instructions, and have them measured, for example by issuing one or more EEXTEND instructions. Adding a page to the enclave may include copying a source page from system memory into the EPC and associating the EPC page with the enclave's SECS. The source page may be a regular page containing unencrypted code, data, or other information for the data region of the enclave, or the source page may be a TCS page containing data for the TCS region. Having them measured may include incrementally calculating or extending a cryptographic hash based on the content, location, and/or other attributes of the page or pages, and storing the hash in MRENCLAVE312. In this embodiment, the added pages may include code, data, stack, heap, etc. for user software application434.

In box550, software installer application issues an EINIT instruction in order to finalize the build of user enclave430and initialize it. In one embodiment, EINIT is the leaf of ENCLS with the value 0x2 in the EAX register. In box552, execution of the EINIT instruction, for example by execution unit270or280, begins.

In one embodiment, execution of the EEINIT instruction may include, in box554, checking a license token to ensure that the corresponding enclave is valid. The license token used in box554may be associated with the EINIT instruction (e.g., its address in the RDX register). In this embodiment, the license token may be the license token provided by license enclave420to software installer application432in box534.

Checking the license token may include, in box556, obtaining the license key that was used in creating the license token (or the key used to derive the license key), and, in box558, using the license key to calculate a MAC based on the contents of the license token. In box560, the MAC calculated in box558is compared to the MAC included in the license token. If they match, then method500continues in box562. If not, method500continues in box590.

The license token may include an ATTRIBUTES bit array, where each bit in the LICTOKEN ATTRIBUTES bit array corresponds to a bit in SECS ATTRIBUTES field316and a specific platform feature, where the SECS may also be associated with the EINIT instruction (e.g., its address in ECX). If a bit in LICTOKEN ATTRIBUTES bit array is set, it means that the enclave is licensed to use the corresponding feature.

Checking the license token also includes, in box562, comparing each bit in the LICTOKEN ATTRIBUTES bit array with the corresponding bit in SECS ATTRIBUTES field316, which holds a copy of the source SECS ATTRIBUTES bit array used to create the enclave. If every bit set in SEC ATTRIBUTES field has a corresponding bit set in the LICTOKEN ATTRIBUTES bit array, then method500continues in box564. If not, then method500continues in box590.

Checking the license token may also include, in box564, comparing the final value in MRENCLAVE312with the expected measurement of the enclave from the license token, where in one embodiment the final value of MRENCLAVE312is a unique SHA-256 digest that identifies, cryptographically, the code and data placed inside the enclave, the position and placement order of the pages inside the enclave, and the security properties of each page. If the value in MRENCLAVE312matches the expected measurement, then method500continues in box566. If not, then method500continues in box590.

In box566, execution of the EINIT instruction continues with the locking of MRENCLAVE312such that its contents remain unchanged, even by the subsequent execution of an EADD or an EEXTEND instruction, and the setting of an attribute indicator in the SECS to prevent any more regions or pages from being added to the enclave. In box568, the build of user enclave430is complete.

In box570, user enclave430may be entered (e.g., by issuing an EENTER instruction) in order to securely execute user software application434. In box572, user software application434may issue an instruction that requires the use of a licensable feature, for example, a request for a key to be used to encrypt, decrypt, seal, or unseal information (or for any other purpose). In box574, the corresponding bit in the SECS ATTRIBUTES field (e.g., ATTRIBUTES field316) is checked. If the bit is set, the feature use is allowed and the instruction may execute (e.g., the key may be returned to user software application434) in box576. If not, method500continues in box590.

In box590, an error condition is raised. For example, a call or instruction may return an error code indicating that an enclave initialization or a request to use a licensable feature failed.

In various embodiments of the present invention, the method illustrated inFIG. 5may be performed in a different order, with illustrated boxes combined or omitted, with additional boxes added, or with a combination of reordered, combined, omitted, or additional boxes.

One example of a possible difference between method500and an alternative embodiment may include license enclave420contacting an external server for approval. In one such embodiment, a license certificate may provide for a limited number of platform licenses to be granted (the license limit). In this embodiment, box524may also include license enclave420connecting with license server470to request a new platform license, license server470keeping a count of licensed platforms (i.e., activations of the feature on platforms), license server approving the granting of a new platform license if the number of licensed platforms is less than license limit, and rejecting the request for a new platform license if the number of licensed platforms is equal to or greater than the license limit.

As another example, a licensable feature may not be able to be controlled (e.g., enabled or disabled) by processor110. For example, the licensable feature (e.g., special storage, counters, or trusted input/output) may be controlled by peripheral control agent120. In this embodiment, platform services enclave440may establish a trusted channel between processor110and peripheral control agent120(e.g., through interface125) and request the special feature. Before establishing the channel and making the request, platform services enclave440may check a special token from license enclave120, to verify its authenticity and that a license has been approved for the requesting software application to use the special feature on platform100. The special token may be created by license enclave420, for example by using an enclave reporting facility (e.g., an EREPORT instruction) that generates a protected data structure (a report) stamped with the identity of the source. The special token may be a report including information regarding user enclave430and its SECS ATTRIBUTES, stamped with the identity of license enclave420. In this embodiment, the SECS ATTRIBUTES field may include platform features in addition to processor-specific features.

Furthermore, method embodiments of the present invention are not limited to method500or variations thereof. Many other method embodiments (as well as apparatus, system, and other embodiments) not described herein are possible within the scope of the present invention.

Embodiments or portions of embodiments of the present invention, as described above, may be stored on any form of a machine-readable medium. For example, all or part of method500may be embodied in software or firmware instructions that are stored on a medium readable by processor110, which when executed by processor110, cause processor110to execute an embodiment of the present invention. Also, aspects of the present invention may be embodied in data stored on a machine-readable medium, where the data represents a design or other information usable to fabricate all or part of processor110.

Thus, embodiments of an invention for feature licensing in a secure processing environment have been described. While certain embodiments have been described, and shown in the accompanying drawings, it is to be understood that such embodiments are merely illustrative and not restrictive of the broad invention, and that this invention not be limited to the specific constructions and arrangements shown and described, since various other modifications may occur to those ordinarily skilled in the art upon studying this disclosure. In an area of technology such as this, where growth is fast and further advancements are not easily foreseen, the disclosed embodiments may be readily modifiable in arrangement and detail as facilitated by enabling technological advancements without departing from the principles of the present disclosure or the scope of the accompanying claims.