Adaptive Acceleration of Transport Layer Security
The SmartNIC system efficiently and securely generates and exchanges keys using a processor core and PKI accelerator with access control and isolation, addressing inefficiencies and vulnerabilities in centralized and distributed key exchange methods.
Patent Information
- Application Number
- JP2024533333
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2021-12-06
- Filing Date
- 2022-11-09
- Publication Date
- 2024-12-03
AI Technical Summary
Existing secure communication systems face inefficiencies and vulnerabilities in key generation and exchange processes, particularly in centralized models that incur additional computing overhead, power consumption, and security risks, while distributed methods using SmartNICs are limited by fixed performance and susceptibility to side-channel attacks.
Implementing a SmartNIC with a processor core, PKI accelerator, and programmable logic to generate and manage public-private key pairs securely, using access control and isolation to prevent unauthorized access and reduce overhead, enabling adaptive performance and secure key exchange.
The solution provides efficient, secure, and adaptive key generation and exchange, reducing power consumption and preventing side-channel attacks, while allowing simultaneous offloading of various compute, storage, and network functions without disrupting other operations.
Smart Images

Figure 2024544688000001_ABST
Abstract
Description
[Technical field]
[0001] Examples of the present disclosure generally relate to implementing transport layer security (TLS) in a Smart Network Interface Controller / Card (SmartNIC). [Background technology]
[0002] Secure client-server communication systems as well as peer-to-peer communication networks typically rely on a two-phase encryption process. In a first phase, which is relatively short in duration compared to the overall communication, the two communicating agents (e.g., client and server) securely exchange a session key. The first phase typically employs asymmetric encryption, using the exchanged information to generate longer-lived master or primary keys used by the client and server, respectively. Asymmetric encryption is more computationally intensive and therefore also suffers from higher latency.
[0003] The first phase is followed by a second phase, which is relatively long in duration compared to the overall communication and involves a secure exchange of information encrypted using the session key exchanged during the first phase. The second phase typically employs symmetric encryption, where the exchanged information is encrypted using a shorter-lived session key. Symmetric encryption is less computationally intensive and also suffers from significantly lower latency.
[0004] Multiple session keys can be employed to service multiple client connections, and a given client connection can continually roll or replenish the session keys used according to a key expiration schedule to increase secure communications. Internet Engineering Task Force (IETF) Transport Layer Security (TLS) 1.3 is an exemplary industry standard that allows for both phases of the encryption process, the first phase being referred to as the handshake protocol and the second phase being referred to as the record protocol. Agents from multiple manufacturers running different software stacks that comply with the standard can seamlessly interoperate to exchange session keys and establish secure communication channels. Summary of the Invention
[0005] Techniques for operating a SmartNIC are described. One example is a SmartNIC that includes a processor core configured to run an operating system (OS), the processor core being assigned an unspoofable physical identifier indicating that the OS is an authorized requesting agent for obtaining a public-private key pair, and an interconnect that includes circuitry coupled to the processor core and defining a trusted path that is at least one of physically and logically separated from untrusted paths in the interconnect, such that the trusted path is access controlled from untrusted agents in the interconnect. The SmartNIC also includes a Public Key Infrastructure (PKI) accelerator that includes circuitry configured to generate the public-private key pair, and access control circuitry coupled between the interconnect and the PKI accelerator and configured to ensure that only authorized requesting agents with the correct unspoofable physical identifier are granted access to the public-private key pair generated by the PKI accelerator.
[0006] One example described herein is a SmartNIC that includes an enhanced processor core configured to execute a first operating system (OS), the processor core being assigned a first unspoofable physical identifier indicating that the first OS is a first authorized requesting agent for obtaining public-private key pairs, a programmable logic (PL) core configured to execute a second OS, the PL core being assigned a second unspoofable physical identifier indicating that the second OS is a second authorized requesting agent for obtaining public-private key pairs, and a public key infrastructure (PKI) accelerator coupled to an interconnect that includes circuitry configured to generate public-private key pairs. The SmartNIC also includes an interconnect configured to facilitate communication between the PKI accelerator and the processor and PL cores, the interconnect including circuitry that ensures that only authorized requesting agents that include the correct unspoofable physical identifier are permitted to obtain the public-private key pairs generated by the PKI accelerator.
[0007] One example described herein is a method that includes using a requesting agent to write operational parameters for generating a public-private key pair to a memory in a SmartNIC, where the requesting agent is one of the hardened processor cores or programmable logic cores in the SmartNIC, and the requesting agent is assigned a non-spoofable physical identifier to indicate that the requesting agent is authorized to obtain the public-private key pair. The method also includes reading the operational parameters using a public key infrastructure (PKI) accelerator, generating the public-private key pair using the PKI accelerator, writing the public-private key pair to the memory using the PKI accelerator, and sending an interrupt to the requesting agent indicating that the public-private key pair is ready. Further, an access control circuit is communicatively coupled between the requesting agent and the memory and the PKI accelerator, and the access control circuit ensures that only authorized requesting agents with the correct non-spoofable physical identifier are allowed to access the public-private key pair stored in the memory. [Brief description of the drawings]
[0008] In a manner in which the above-recited features may be understood in detail, a more particular description briefly summarized above may be made by reference to exemplary implementations, some of which are illustrated in the accompanying drawings. It should be noted, however, that the accompanying drawings illustrate only typical example implementations and therefore should not be considered as limiting the scope thereof. [Figure 1] FIG. 1 is a block diagram of a SmartNIC that performs adaptive TLS acceleration, according to an example. [Diagram 2] 1 is a flowchart for generating a public-private key pair according to an example. [Diagram 3] FIG. 1 is a block diagram of a SmartNIC that performs adaptive TLS acceleration, according to an example. [Figure 4] 1 is a flow chart for validating a server certificate, according to an example. [Diagram 5] 1 is a flow chart for generating handshake keys, according to an example.
[0009] For ease of understanding, wherever possible, identical reference numbers have been used to designate identical elements common to the figures. It is contemplated that elements of one example may be beneficially incorporated in other examples. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0010] Various features are described below with reference to the drawings. It should be noted that the drawings may or may not be drawn to scale, and elements of similar structure or function are represented by similar reference numerals throughout the drawings. It should be noted that the drawings are intended only to facilitate the description of features. They are not intended as an exhaustive description of features or as limitations on the scope of the claims. In addition, the illustrated examples do not necessarily have all aspects or advantages shown. An aspect or advantage described in connection with a particular embodiment is not necessarily limited to that embodiment and can be implemented in any other embodiment, even if not so illustrated or explicitly described.
[0011] The embodiments herein describe offloading encryption activities to a SmartNIC, freeing up the server's computing resources to focus on running customer applications. Unlike smart NICs, typical NICs cannot be used to offload host / server functions. That is, by using a smart NIC (referred to herein as a SmartNIC), functions and processes that need to be run on the host / server can be offloaded and run using the computing resources of the smart NIC.
[0012] In one embodiment, the SmartNIC includes a system on a chip (SoC) implemented on an integrated circuit (IC) that includes an embedded processor. Instead of running the entire TLS stack within the embedded processor, embodiments herein offload certain TLS tasks, such as generating random numbers used to seed the public and private keys, generating public-private key pairs, validating server certificates, and performing Elliptic Curve Diffie-Hellman (ECDH) point multiplication, to a public key infrastructure (PKI) accelerator or the like. Additionally, cryptographic tasks can be scaled by adding processing engines to a programmable logic (PL), assuming the SoC includes a PL fabric.
[0013] As described in more detail below, using a SmartNIC to perform key generation and exchange tasks can reduce overhead compared to centralized key generation and exchange schemes by avoiding the overhead used to wrap and unwrap centrally generated session keys. Furthermore, by offloading tasks to a PKI accelerator within the SmartNIC, embodiments herein do not rely solely on fixed function blocks whose performance is fixed at implementation time in terms of key pair or session key generation rates.
[0014] FIG. 1 is a block diagram of a SmartNIC 100 performing adaptive TLS acceleration, according to an example. SmartNIC 100 can be used as part of a hyper-converged infrastructure (HCI) in a cloud computing environment, providing cloud vendors with an easy way to manage various compute-centric, network-centric, and storage-centric workloads for a single customer or multiple customers. SmartNICs (also referred to as Data Processing Units (DPUs)) excel at accelerating offloads in one component, and also provide cloud vendors with a way to manage virtualization and security for multiple cloud tenants using this common pervasive hyper-converged infrastructure simultaneously. With millions of these components deployed at a hyperscale, power consumption becomes a key metric for SmartNICs, and a 1 watt increase in the power consumption of a component can increase the power consumption of a data center by megawatts. This makes highly efficient offload acceleration in a power-efficient manner a key metric in data centers.
[0015] Another important metric for a SmartNIC is secure communication. Since a SmartNIC can perform tasks for multiple cloud tenants, the SmartNIC may have the means to ensure that a cloud tenant cannot eavesdrop on another cloud tenant's information. Given that there may be millions of SmartNICs facilitating communication between each other, a secure communication network needs to be established for those tenants and their offload acceleration capabilities. Furthermore, even within each cloud tenant (e.g., a company), confidential information such as financial or legal affairs of one division of the company may need to be protected from accidental or malicious eavesdroppers in other parts of the company along with insider information.
[0016] Furthermore, the popularity and increasing reliability of modern public cloud infrastructures has led to a recent trend for government agencies to enter into cloud contracts with public cloud infrastructure providers instead of building their own secure private cloud infrastructure, which adds new requirements for autonomous security of components to ensure that the cloud infrastructure provider itself cannot gain access to the agency's encryption keys used to encrypt and exchange information, as well as to ensure that other cloud tenants cannot access those keys.
[0017] When used in cloud deployments, embodiments herein enable millions of SmartNICs to communicate securely across all cloud networks, encrypting data movement between tens of millions of tenants sharing the cloud network, and using hundreds of millions of session keys in a manner where the key pairs (private and public session keys) are not accessible to either hostile cloud tenants or the cloud infrastructure provider itself. Additionally, these keys are generated and exchanged in a power-efficient manner.
[0018] Instead of using either a centralized model where a pair of communication agents is composed of distributed computing client nodes that use a key container of a central data center vendor to obtain keys, or a peer-to-peer model where a pair of communication agents is composed of peer computing or storage nodes that exchange keys with each other, the embodiments herein rely on distributed tasks within the SmartNIC to reduce power and improve security. For example, a centralized model for key exchange may rely on dedicated security appliances acting on behalf of a central key container of a cloud infrastructure provider. These dedicated security appliances generate and authenticate session keys with millions of distributed computing or storage client nodes. The dedicated security appliances are designed to generate session keys at a very high rate, and these wrapped session keys (using a key encryption key) are distributed to the computing or storage client nodes, which then unwrap and use them for secure communication.
[0019] The drawbacks of the centralized model include additional computing overhead for the secure exchange of keys to pairs of computing or storage client nodes for secure peer-to-peer communication, where both peers receive their own transmit session key and receive session key as a wrapped key from a central key container, so that an adversary cannot use these session keys to access the data of these peers when exchanging information. Also, to increase the secure communication between those peers, more session keys per peer-to-peer connection can be used to continuously roll / replenish session keys. This means that not only must dedicated security equipment generate hundreds of millions of session keys, but the equipment must wrap those session keys through additional cryptographic functions before distributing the wrapped session keys. On the other hand, a distributed computing or storage client node that receives a large number of session keys must add cryptographic engines to unwrap these session keys, thus incurring additional overhead as well.
[0020] Another drawback of the centralized model is that while a dedicated security appliance offloads the generation of key pairs, the centralized session key generation model does not offload the additional power, cost, and complexity of unwrapping millions of ephemeral session keys to distributed computation or storage client nodes.
[0021] Yet another drawback of this model is that a centralized key container for the master or main key gives a malicious attacker a concrete location where, once they gain access, they can steal, manipulate, or destroy information encrypted using the generated valid session keys used by millions of distributed computing or storage client nodes on the cloud network. Additionally, a centralized key container, which typically operates under the control of a cloud administrator, does not provide a level of autonomy to tenants who do not trust that their keys are available to the cloud infrastructure provider.
[0022] The embodiments herein improve or avoid many of the shortcomings of the centralized key generation and exchange model by using native TLS exchange methods in the SmartNIC, and thus, there is no need to incur the additional overhead of wrapping and unwrapping the session key through an additional encryption function before using the session key to encrypt the exchanged data. Additionally, the embodiments herein also rely on built-in encryption and access control methods such that keys generated and stored in the SmartNIC do not need to be wrapped first. Additionally, the embodiments herein can store keys in the SmartNIC such that they are only accessible to the tenant, and not to other tenants or the cloud infrastructure provider.
[0023] Instead of using a centralized model, there are two ways to enable distributed key exchange in a SmartNIC, both of which involve having the key exchange occur as a peer-to-peer operation and therefore do not require a centralized key container to store the primary, secret, or master keys. The first way is for the SmartNIC device to run the entire TLS1.3 stack on multiple embedded processor cores within the SmartNIC. The embedded processor provides offload acceleration for multiple functions and treats the cryptographic steps to run TLS1.3 as just one of many functions to be performed.
[0024] However, there are three drawbacks to relying solely on the embedded processor in the SmartNIC. First, it often takes a large number of clock cycles in the processor to execute types of cryptographic algorithms, such as elliptic-curve cryptography (ECC), which is part of the TLS 1.3 standard. Thus, even if these SmartNIC devices offer a large number of embedded processors, the cryptographic algorithms run at a low rate, thus placing a low upper limit on the rate at which new public-private key pairs or session keys can be generated (thus compromising security). Second, the services of other offload acceleration functions that may run on the embedded processor are stopped or slowed down while the cryptographic algorithms are running. This undermines the very reason that SmartNICs may be used, which can offload various storage, network, and compute functions simultaneously, across multiple tenants. If the processors are essentially running all the time and running the cryptographic algorithms inefficiently, the value of SmartNICs in a data center may be reduced. Third, because many embedded processors simultaneously perform various storage, network, and computation functions along with the cryptographic algorithms, the processor cores running the cryptographic algorithms are vulnerable to side-channel attacks that steal the generated key pairs or session keys.
[0025] A second way to enable distributed key exchange in a SmartNIC is for the SmartNIC device to extend the application specific integrated circuit (ASIC) methodology to create a HardIP block as an accelerator for a number of embedded processors. The processor performs the non-cryptographic steps of the TLS1.3 software stack, while the HardIP block is dedicated to performing the cryptographic steps to implement TLS1.3. The drawbacks of using this approach are threefold. First, since the HardIP block is a fixed-function block, a decision must be made at implementation time (e.g., when the SmartNIC is designed) regarding the key pair or session key generation rate. Even if the SmartNIC has a need for a higher generation rate of either the key pair or the session key, the rate is capped at the capabilities of the fixed-function accelerator. Second, as mentioned above, conventional SmartNIC devices provide offload acceleration for various network, storage, and computation functions. An offload accelerator, such as a deep learning inference accelerator, may wish to use a session key to decrypt received (typically after decompression) data or send data or inference results in an encrypted format (usually after compression) to protect the client's inference data and results. The accelerator must now call the embedded processor to act on its behalf to obtain the session key, thus creating an inefficient level of indirection. This also opens the deep learning accelerator to security vulnerabilities. Third, this approach remains susceptible to the same vulnerability mentioned above of side-channel attacks due to the fact that the TLS 1.3 software stack is running simultaneously with other offload acceleration applications. The resulting key pair and session key are returned to the software routine running on the processor core that called the accelerator.
[0026] However, the described embodiments provide improvements over the centralized key generation and exchange model performed without the use of a SmartNIC and the two distributed methods that use a SmartNIC to generate key pairs or session keys discussed above. Unlike the centralized key generation and exchange model, the embodiments herein can use native TLS exchange methods (e.g., TLS 1.3 secure client / server methods), and therefore there is no need to incur the additional overhead of wrapping and unwrapping a session key through additional cryptographic functions before the session key can be used to encrypt exchanged data. Furthermore, the embodiments herein can rely on built-in encryption and access control methods so that keys generated and stored in the SmartNIC do not need to be wrapped first.
[0027] Unlike the first distributed method using SmartNICs, the embodiments herein do not need to rely on an embedded processor to run the entire TLS stack (although the option is still there if the customer prefers it). Unlike the second distributed method using SmartNICs, the embodiments herein also do not need to rely solely on fixed function blocks whose performance is fixed at implementation time in terms of key pair or session key generation rate. Instead, the embodiments herein allow for adaptive levels of performance such that enhanced crypto acceleration or random number generation for the TLS stack can occur as sized with HardIP or augmented by programmable logic. Furthermore, the agent making the TLS function calls to the PKI accelerator can be either an embedded processor, or a programmable logic core, or a combination of the two if performance requirements increase beyond the capabilities of enhanced crypto acceleration.
[0028] Unlike the distributed approach using SmartNICs, other offload accelerators, such as the deep learning inference accelerator (shown in FIG. 3), do not need to call the embedded processor to act on their behalf. The embodiments herein allow other offload accelerators to directly interface with the PKI accelerator via either the HardIP network-on-chip or the programmable logic interface. Also, during the execution of the encryption algorithm, the service of other offload acceleration functions that may be executed on the set of embedded processors is not stopped or delayed, thus achieving simultaneous offloading of various storage, network, and computing functions simultaneously and across multiple tenants.
[0029] Unlike the techniques discussed above that are vulnerable to side channel and voltage glitch attacks, embodiments herein provide a trusted requesting agent that is physically separated from adjacent untrusted agents. Furthermore, access from a trusted agent to the PKI accelerator 140 can be either via a path that is physically isolated from other agents, or logically isolated from other agents with access control checks of authorized source agents with immutable physical identifiers and encrypted and authenticated firewall rules. The key pairs or session keys generated by the PKI accelerator 140 can then be stored in on-chip or encrypted off-chip memory with access control attributes such that only the trusted requesting agents have access to those results. Embodiments herein encompass accelerator memory that is co-located with the PKI accelerator 140 such that the same access controlled path by which an authorized source agent provides secure metadata in a command descriptor to the PKI accelerator 140 is the path by which the resulting key pairs or session keys generated by the PKI accelerator 140 are subsequently accessed. While all these measures prevent the generated key pairs or session keys from being stolen via side channel attacks, embodiments may also include setting alarms and actions to shut down the system when an adversary violates access controls or attempts a voltage glitch attack against a trusted computing agent to steal a private / master key or a session key.
[0030] 1, SmartNIC 100 includes SoC 105. SoC 105 may be implemented using a single IC. However, in other embodiments, SmartNIC 100 may include multiple SoCs (multiple ICs) communicatively coupled either directly (e.g., a stack of bonded ICs) or through a substrate (e.g., a silicon interposer).
[0031] In this embodiment, SoC 105 includes processor cores 110, interconnect 115, access control 130, main memory 135, and PKI accelerator 140. In one embodiment, all of these components are within a processor within SoC 105. For example, these components may be a processor system (or processor subsystem) within SoC 105. Although not shown, SoC may also include other components, such as a network on a chip (NoC), programmable logic, an array of data processing engines, and I / O interfaces. Some or all of these additional hardware components may be communicatively coupled to the hardware components illustrated in FIG.
[0032] Processor core 110 includes circuitry for executing an embedded operating system (OS), which may include software and firmware that executes within processor core 110. Although one processor core 110 is shown, SoC 105 may have multiple cores 110, each running an embedded OS.
[0033] In one embodiment, processor core 110 represents an embedded HardIP scalar processor capable of executing a TLS (e.g., TLS 1.3) software stack. That is, an OS running on core 110 may execute a TLS software stack. Additionally, core 110 may be executing the TLS stack within a Trusted Execution Environment (TEE). In one embodiment, processor core 110 and its interface to interconnect 115 (e.g., Application Processing Unit (APU) interconnect) are physically isolated from the remaining embedded processor cores (not shown) in SoC 105 that execute untrusted code. Additionally, in one embodiment, processor core 110 has a non-spoofable physical identifier that is used to verify that it is authorized to send / retrieve key pairs or session key information. This prevents other processor cores that execute untrusted code from accessing key pairs or session key information stored in memory (e.g., main memory 135 or accelerator memory 145).
[0034] In one embodiment, processor cores 110 also run their TEE trusted OS in lockstep mode to detect voltage glitch attacks in attempts to steal their keys. For example, at least two processor cores 110 may run their OS in lockstep in the TEE such that a voltage glitch attack on one core 110 can be detected by the other core 110.
[0035] The interconnect 115 represents an on-chip interconnect that facilitates communication between the illustrated components in the SoC 105. The interconnect 115 is constructed such that traffic paths are physically isolated between the components communicating in the TEE and the untrusted components. As shown, the interconnect 115 includes a trusted path 120 used by components in the TEE and an untrusted path 125 used by components not in the TEE. The trusted path 120 is physically separated from the untrusted path 125. As a result, untrusted components (e.g., processing core 110 executing untrusted code not associated with cryptography) cannot physically access the trusted path 120. This makes it impossible for components not in the TEE to access the trusted path 120, and encrypted data (e.g., key pairs and session keys) are transmitted on these paths 120.
[0036] The interconnect 115 also propagates the unspoofable physical identifiers of the processor cores 110 within the TEE to their respective destinations (e.g., access control 130, main memory 135, or PKI accelerator 140). In one embodiment, the interconnect 115 is also constructed to ensure that traversing paths 120, 125 are permitted and physically isolated, with routing attributes of the interconnect 115 determining which traffic comes from which source to which destination.
[0037] Main memory 135 (e.g., random access memory (RAM)) represents a main memory port of on-chip interconnect 115 that can support traffic to these destinations in a cache coherent manner. That is, main memory 135 and memory 145 may be cache coherent with caches in processor cores 110 and caches in interconnect 115. In one embodiment, main memory 135 is where send / retrieve key pairs or session key information is written or stored by PKI accelerator 140 via interconnect 115 for retrieval by a requesting agent (e.g., a TLS software stack executing in processor core 110).
[0038] In one embodiment, main memory 135 is where the requesting agent writes command descriptors including secure metadata, which are then read by PKI accelerator 140 through a port in interconnect 115. These destinations may be supported in a cache coherent manner, so that both the command descriptor including secure metadata and the key pair or session key can be cached in either the processor core 110 cache or the interconnect 115 cache.
[0039] In one embodiment, main memory 135 may include two types of cache coherent main memory destinations: DDR with in-line encryption such that the key pair or session key is not visible off-chip in DRAM, and on-chip memory (OCM).
[0040] The interconnect 115 includes a Memory Mapping I / O (MMIO) port that represents an MMIO or device memory port of the interconnect 115 that can support traffic to the PKI accelerator 140 with strict read / write ordering semantics. In one embodiment, there are two types of device memory destinations: a first destination where the MMIO port sends data to the accelerator memory 145 (also referred to as tightly coupled memory (TCM)), and a second destination where the MIMO port sends data directly to the ECC accelerator 150. The TLS stack or OS in the processing core 110 can write a command descriptor containing secure metadata to either the accelerator memory 145 or the ECC accelerator 150 in order. The PKI accelerator 140 can then write the key pair or session key to the accelerator memory 145 (or main memory 135) for retrieval by the TLS stack or OS.
[0041] PKI accelerator 140 also includes a random number generator (RNG) 155 that is used when a command descriptor requests the generation of a key pair. PKI accelerator 140 can generate the key pair using one of several asymmetric key encryption algorithms that are part of the TLS 1.3 standard (or other past or future TLS standards).
[0042] Access control 130 (e.g., a memory protection unit) includes circuitry that ensures that only authorized requesting agents (e.g., the TEE's OS and core 110) and PKI accelerator 140 via a path labeled direct memory access (DMA), which represents a valid, non-spoofable physical identifier, can access specified memory or configuration register destinations corresponding to main memory 135, accelerator memory 145, and ECC accelerator 150.
[0043] FIG. 2 is a flow chart of a method 200 for generating a public-private key pair, according to an example. At block 205, a requesting agent (e.g., a processing core, or a TLS stack or OS in a processor core) requests a public key from a PKI accelerator. As shown in FIG. 1, the request traverses interconnect 115 and access control 130 before reaching PKI accelerator 140. Because the request originated from a requesting agent in the TEE, the request traverses interconnect 115 using trusted path 120. Additionally, access control 130 can check a non-spoofable physical identifier in the request to ensure that the requesting agent is authorized to send data to PKI accelerator 140. If the request comes from a requesting agent that is not authorized to use PKI accelerator 140 (e.g., a processor core with an OS or application running untrusted code not in the TEE), access control 130 can block the request from reaching accelerator 140.
[0044] In one embodiment, to generate a public key, the requesting agent requests a random number (e.g., a 512-bit random number used to derive the public key) from a RNG in the PKI accelerator. The RNG then returns the random number to the requesting agent using the interconnect.
[0045] At block 210, the requesting agent writes operational parameters to memory for generating a public-private key pair. These operational parameters initiate the PKI operation to generate the key pair. The operational parameters may include the operation type (e.g., ECC Point Multiplication (PM)), the public key (e.g., 512-bit random numbers), the encryption algorithm used to generate the private key, etc. Although embodiments herein describe the use of ECC as the encryption algorithm, embodiments herein are not limited thereto and may be used to perform other types of asymmetric encryption algorithms, such as the Rivest, Shamir and Adelman (RSA) algorithm. Additionally, symmetric encryption techniques such as the Advanced Encryption Standard (AES) and the Secure Hash Algorithm (SHA) may also perform the role of the TLS algorithms as part of the authentication functions (e.g., creating a hash) and attestation functions (e.g., verifying that a hash provided by a peer is authentic).
[0046] In one embodiment, the requesting agent writes the operational parameters to a memory in the PKI accelerator (e.g., accelerator memory 145 in FIG. 1). In this case, the requesting agent programs an ECC accelerator in the PKI accelerator (e.g., ECC accelerator 150) to read the operational parameters from the accelerator memory. Because the accelerator memory and the ECC accelerator are both in the PKI accelerator, the ECC accelerator does not need to use an interconnect to access the operational parameters, but can directly access the accelerator memory.
[0047] In another embodiment, the requesting agent writes the operational parameters to main memory (e.g., main memory 135 in FIG. 1). In this case, the requesting agent programs the ECC accelerator in the PKI accelerator to read the operational parameters from main memory using a DMA port on the interconnect (e.g., interconnect 115 in FIG. 1). In either case, both of these memories are accessible to the ECC accelerator. Once the ECC accelerator is programmed to know where to access the write operation, the PKI operation is initiated in the ECC accelerator and the key pair is generated.
[0048] In block 215, the ECC accelerator reads operating parameters from a secure memory, such as main memory or accelerator memory.
[0049] The ECC accelerator generates a public-private key pair using the operational parameters at block 220. In one embodiment, the ECC accelerator implements ECC384PM, however, as noted above, this is but one suitable encryption algorithm that may be implemented.
[0050] In block 225, the ECC accelerator writes the public-private key pair to memory, which again can be accelerator memory or main memory.
[0051] In block 230, the ECC Accelerator sends an interrupt to the requesting agent (e.g., a processor core, or a TLS stack or OS running within the processor core). The interrupt notifies the requesting agent that it is ready to retrieve the public-private key pair in memory. Advantageously, the requesting agent can perform other tasks while waiting for the ECC Accelerator to generate the key pair. That is, the requesting agent does not pause while waiting for the ECC Accelerator to generate and store the key pair. After writing the operating parameters to memory in block 210, the requesting agent can perform other tasks. These tasks may be other encryption tasks or may be unrelated to encryption, such as various network, storage, and computing functions. After receiving the interrupt, the requesting agent can retrieve the key pair and provide the public key to external devices (e.g., clients and servers) to begin encrypted data communication.
[0052] In one embodiment, public-private key pairs are used to participate in peer-to-peer communications using asymmetric cryptography. Once peer node A has obtained peer node B's public key, it can generate multiple session keys (derived from a random number generator), encrypt them with peer node B's public key, and send them to peer node B. Peer node B is the only one that has a private key pair that corresponds to the public key held by peer node A, and can extract all session keys sent by peer node A.
[0053] FIG. 3 is a block diagram of a SmartNIC 300 performing adaptive TLS acceleration, according to an example. SmartNIC 300 has the same components as SmartNIC 100, labeled in the same manner. In addition, SmartNIC 300 includes PL 305, PL memory 315, and artificial intelligence (AI) engine accelerator 320. PL 305 represents the PL fabric with configurable logic blocks (CLBs) formed, for example, from lookup tables and other programmable circuits. Unlike processor core 110, which is formed from hardened circuits that perform fixed functions, the circuits in PL 305 can be programmed to perform different functions. In this case, PL 305 is programmed to include PL core 310, which can perform many of the same functions as processor core 110. In one embodiment, PL core 310 can use an embedded OS to execute the TLS stack. Thus, PL core 310 can be used to perform the same cryptographic tasks as processor core 110. This provides additional flexibility and scalability to SmartNIC 300. For example, if processor core 110 cannot handle all of the encryption tasks as well as the various network, storage, and computational functions that it is required to perform, PL 305 can be programmed to include PL core 310. Processor core 110 can then hand off some or all of the encryption tasks to PL core 310.
[0054] PL core 310 and its embedded OS can operate within the TEE in the same manner as processor core 110. Additionally, PL core 310 can be assigned an unspoofable physical identifier to use when communicating with interconnect 115 to indicate that it is an entity capable of sending / retrieving key pairs or session key information. Thus, PL core 310 and its OS can be requesting agents that can initiate method 200 to instruct ECC accelerator 150 to generate a key pair. That is, both processor core 110 and PL core 310, when added to the TEE, can generate key pairs using PKI accelerator 140.
[0055] In one embodiment, PL core 310 represents a SoftIP scalar processor capable of executing a TLS software stack. The interface of PL core 310 to interconnect 115 is physically isolated within a secure PL shell.
[0056] The PL memory 315 can be used to store operational parameters used to generate the key pair, and can also store the key pair after it has been generated by the ECC accelerator 150. That is, the PL memory 315 can be part of the TEE, and the access control 130 can ensure that only authorized requesting agents can access the operational parameters or stored key pair. Similar to the main memory 135 and the accelerator memory 145, the PL memory 315 can be cache coherent with caches in the processor core 110, the PL core 310, and the interconnect 115. Thus, the PL memory 315 is another option that a requesting agent can use to store operational parameters and key pairs accessible by the ECC accelerator 150 using the interconnect 115.
[0057] The data processing engine array 320 is an exemplary artificial intelligence (AI) inference accelerator with all the isolation and key firewall functions described above for the processing cores 110 and the key PL cores 310. In one embodiment, the data processing engine array 320 may not be authorized to access the PKI accelerator (e.g., execute untrusted code / tasks), but it can still operate within the same SoC 105 as the authorized / trusted processor cores 110 and PL cores 310. The data processing engine array 320 can communicate with other components in the processor system using untrusted paths 125 in the interconnect 115.
[0058] 3 further illustrates that other offload accelerators, such as the data processing engine array 320, do not need to invoke an embedded processor (e.g., processor core 110) to act on their behalf. If the data processing engine array 320 is part of the TEE and authorized to generate and obtain key pairs, the structure of FIG. 3 allows the array 320 (and other offload accelerators not shown) to directly interface with the PKI accelerator 140 via either a hard IP network-on-chip (NoC) or the interconnect 115 to generate key pairs. Thus, like the processor core 110 and the PL core 310, the data processing engine array 320 may be an authorized requesting agent to execute the method 200.
[0059] 4 is a flow chart of a method 400 for validating a server certificate, according to an example. At block 405, a requesting agent (eg, a processor core or PL core) determines a hash of the server certificate.
[0060] At block 410, the requesting agent writes the hash, the server certificate, and the private key to memory. As mentioned above, the memory may be main memory 135, accelerator memory 145, or PL memory 315. Each of these memories may be protected and accessible to the PKI accelerator. The requesting agent may also program the PKI accelerator to obtain the hash, the server certificate, and the private key.
[0061] In block 415, the PKI accelerator reads the hash, the server certificate, and the private key into memory.
[0062] The hash, the server certificate, and the private key are used to perform an Elliptic Curve Digital Signature Algorithm (ECDSA) verification in block 420. The PKI accelerator can then notify the requesting agent of the results of the verification operation.
[0063] Thus, method 400 illustrates that in addition to generating key pairs, SmartNICs 100 and 300 can be used to verify server certificates in a timely and power efficient manner.
[0064] 5 is a flow chart of a method 500 for generating handshake keys, according to an example. At block 505, the requesting agent (e.g., a processor core or PL core) writes the server public key and the client private key to memory. The memory may be main memory 135, accelerator memory 145, or PL memory 315. Each of these memories may be protected and accessible to the PKI accelerator.
[0065] The requesting agent writes the hash of the server / client Hello packet to memory, block 510. The requesting agent can program the PKI accelerator to retrieve the public key, private key, and hash from memory.
[0066] In block 515, the PKI accelerator reads the public and private keys from memory.
[0067] At block 520, the PKI accelerator performs an ECDH multiplication using the public key, private key, and the hash to generate handshake keys. Thus, method 500 illustrates that in addition to generating key pairs, SmartNICs 100 and 300 may be used to generate handshake keys between a server and a client.
[0068] In general, the embodiments discussed in Figures 1-5 have many advantages over the centralized key generation model and the two methods for enabling distributed key exchange in SmartNICs discussed above. Some non-limiting advantages include: Reduced Computing and Power Overhead: By using a distributed scheme and storing the generated key pairs or session keys in an access-controlled manner, embodiments herein achieve greater power efficiency by not needing to wrap / unwrap keys before securely ensuring their consumption.
[0069] Adaptive high performance key pair and session key generation and exchange: PKI acceleration can be performed in HardIP or PKI acceleration is augmented with PL.
[0070] A flexible agent that makes TLS function calls to the PKI accelerator using either the embedded HardIP core or the SoftIP accelerator function call requester: This provides flexibility within the SmartNIC when performance requirements increase beyond the capabilities of the embedded HardIP core, or when the embedded HardIP core is deployed to other embedded tasks, so that these tasks are not stalled due to the HardIP core running key pair and session key generation and exchange software.
[0071] Secure enclaves, firewalls, and access controls prevent side-channel attacks and enable power-efficient storage of plaintext keys without requiring wrapping / unwrapping of the plaintext key: Access from a trusted agent to a TLS requesting agent can be via a path that is physically isolated from other agents, or logically isolated from other agents via access control checks of authorized source agents with immutable / unspoofable physical identifiers and cryptographically authenticated firewall rules.
[0072] The accelerator memory may be co-located with the PKI accelerator such that the same access-controlled path used by the authorized source agent to provide a command descriptor containing secure metadata to the PKI accelerator is the path by which the resulting key pair or session key generated or signed / verified by the PKI accelerator is subsequently accessed.
[0073] In the foregoing, reference is made to the embodiments presented in this disclosure. However, the scope of the disclosure is not limited to the specific described embodiments. Instead, any combination of the described features and elements, whether related to different embodiments or not, is contemplated for implementing and practicing the contemplated embodiments. Furthermore, the embodiments disclosed herein may achieve other possible solutions or advantages over the prior art, but whether or not a particular advantage is achieved by a given embodiment does not limit the scope of the disclosure. Thus, the above aspects, features, embodiments, and advantages are merely illustrative and are not considered elements or limitations of the appended claims unless expressly recited in the claims.
[0074] As will be appreciated by one of ordinary skill in the art, embodiments disclosed herein may be embodied as a system, method, or computer program product. Accordingly, aspects may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, microcode, etc.), or an embodiment combining software and hardware aspects, all of which may be referred to generally herein as a "circuit," "module," or "system." Furthermore, aspects may take the form of a computer program product embodied in one or more computer-readable medium(s) having computer-readable program code embodied therein.
[0075] Any combination of one or more computer readable media may be utilized. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. The computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (non-exhaustive list) of computer readable storage media include an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this specification, a computer readable storage medium is any tangible medium that can contain or store a program for use by or in connection with an instruction execution system, apparatus, or device.
[0076] A computer-readable signal medium may include a propagated data signal in which computer-readable program code is embodied, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electromagnetic, optical, or any suitable combination thereof. A computer-readable signal medium is not a computer-readable storage medium but may be any computer-readable medium that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.
[0077] The program code embodied on the computer readable medium may be transmitted using any suitable medium, including but not limited to wireless, wireline, fiber optic cable, RF, etc., or any suitable combination of the foregoing.
[0078] Computer program code for carrying out operations of aspects of the present disclosure may be written in any combination of one or more programming languages, including, for example, object-oriented programming languages such as Java, Smalltalk, C++, and conventional procedural programming languages such as the "C" programming language or similar programming languages. The program code may execute completely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer, partially on a remote computer, or completely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet Service Provider).
[0079] Aspects of the present disclosure are described below with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments presented in the present disclosure. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general purpose computer, a special purpose computer, or other programmable data processing apparatus such that the instructions, executed via a processor of the computer or other programmable data processing apparatus, cause a machine to create means for implementing the functions / acts specified in the blocks of the flowchart and / or block diagrams.
[0080] These computer program instructions may also be stored on a computer-readable storage medium, where the instructions stored on the computer-readable storage medium can direct a computer, programmable data processing apparatus, and / or other device to function in a particular manner to produce an article of manufacture including instructions that implement aspects of the functions / acts specified in the flowchart and / or block diagram blocks.
[0081] Computer program instructions may also be loaded into a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be executed on the computer, other programmable apparatus, or other device to generate a computer-implemented process, such that the instructions executing on the computer or other programmable apparatus provide a process for implementing the functions / acts specified in the flowchart and / or block diagram blocks.
[0082] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block of the flowcharts or block diagrams may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions described in the blocks may occur out of the order described in the figures. For example, two blocks shown in succession may in fact be executed substantially simultaneously, or the blocks may be executed in reverse order, depending on the functionality involved. It should also be noted that each block of the block diagrams and / or flowchart illustrations, as well as combinations of blocks in the block diagrams and / or flowchart illustrations, may be executed by a dedicated hardware-based system that performs the specified functions or acts, or executes a combination of dedicated hardware and computer instructions.
[0083] While the above is directed to specific examples, other and further examples may be devised without departing from the basic scope thereof, which is determined by the following claims.
Claims
1. A smart network interface controller (NIC), comprising: a processor core configured to execute a first operating system (OS), the processor core being assigned a non-spoofable physical identifier to indicate that the first OS is an authorized requesting agent for obtaining a public-private key pair; an interconnect coupled to the processor cores, the interconnect including circuitry defining a trusted path, the trusted path being at least one of: physically isolated from untrusted paths in the interconnect; or logically isolated such that the trusted path is access controlled from untrusted agents in the interconnect; a public key infrastructure (PKI) accelerator comprising circuitry configured to generate the public-private key pair; and an access control circuit coupled between the interconnect and the PKI accelerator and configured to ensure that only the authorized requesting agent having a correct unspoofable physical identifier is granted access to the public-private key pair generated by the PKI accelerator.
2. 10. The smart NIC of claim 1, further comprising: a programmable logic (PL) comprising a PL core assigned a second unspoofable physical identifier indicating that the first OS is an authorized requesting agent for obtaining a public-private key pair.
3. The smart NIC of claim 1 , wherein the interconnect forwards the unspoofable physical identifier to the access control circuit.
4. A smart NIC, a hardened processor core configured to execute a first operating system (OS), the hardened processor core being assigned a first unspoofable physical identifier to indicate that the first OS is a first authorized requesting agent for obtaining a public-private key pair; a programmable logic (PL) core configured to execute a second OS, the PL core being assigned a second unspoofable physical identifier indicating that the second OS is a second authorized requesting agent for obtaining a public-private key pair; a public key infrastructure (PKI) accelerator coupled to the interconnect, the PKI accelerator comprising circuitry configured to generate the public-private key pair; A smart NIC comprising: an interconnect configured to facilitate communication between the PKI accelerator and a processor and PL core, the interconnect comprising circuitry to ensure that only authorized requesting agents containing a correct unspoofable physical identifier are allowed to obtain the public-private key pair generated by the PKI accelerator.
5. 5. The smart NIC of claim 4, further comprising an access control circuit coupled between the interconnect and the PKI accelerator and configured to ensure that only the authorized requesting agents having a correct unspoofable physical identifier are granted access to the public-private key pair generated by the PKI accelerator.
6. A main memory; an optional PL memory; and an accelerator memory within the PKI accelerator, wherein the main memory, the optional PL memory, and the accelerator memory are configured to store the public-private key pair generated by the PKI accelerator, the main memory, the PL memory, and the accelerator memory are cache coherent with caches within the processor core, and the access control circuitry is configured to ensure that only the authorized requesting agents having a correct unspoofable physical identifier are allowed to obtain the public-private key pair stored in the main memory, the PL memory, and the accelerator memory.
7. The smart NIC of claim 1 or 4, wherein the processor core, PL, interconnect, PKI accelerator, and access control circuitry are part of a system on chip (SoC).
8. the first OS, or both the first OS and the second OS, are configured to run a Transport Layer Security (TLS) stack; 5. The smart NIC of claim 1 or 4, wherein the first OS, or both the first OS and the second OS, are configured to execute a Transport Layer Security (TLS) stack within the processor core.
9. The PKI accelerator, 5. The smart NIC of claim 1 or 4, further comprising a random number generator (RNG) configured to generate random numbers upon request from the OS used to derive the public-private key pair.
10. 1. A method comprising: writing operational parameters for generating a public-private key pair into a memory in a smart NIC using a requesting agent, the requesting agent being one of an enhanced processor core or a programmable logic core in the smart NIC, the requesting agent being assigned a non-spoofable physical identifier to indicate that the requesting agent is authorized to obtain the public-private key pair; reading the operational parameters using a public key infrastructure (PKI) accelerator; generating the public-private key pair using the PKI accelerator; writing the public-private key pair to the memory using the PKI accelerator; sending an interrupt to the requesting agent indicating that the public-private key pair is ready, wherein an access control circuit is communicatively coupled between the requesting agent and the memory and the PKI accelerator, the access control circuit ensuring that only authorized requesting agents having a correct unspoofable physical identifier are allowed to access the public-private key pair stored in the memory.
11. prior to writing said operating parameters to said memory; requesting, by the requesting agent, a public key from the PKI accelerator; The method of claim 10 , further comprising: using the PKI accelerator to generate random numbers from which the public key is derived.
12. The method of claim 10 , wherein the requesting agent runs an operating system that implements a Transport Layer Security (TLS) stack.
13. the requesting agent writes the operating parameters to a main memory in the smart NIC that is cache coherent with a cache in the requesting agent, and the method further comprises:
11. The method of claim 10, further comprising programming the PKI accelerator to read the operating parameters using direct memory access (DMA) over an interconnect, the interconnect being communicatively coupled between the requesting agent and the PKI accelerator and the main memory.
14. the requesting agent writes the operational parameters to an accelerator memory in the PKI accelerator that is cache coherent with a cache in the requesting agent, and the method further comprises:
11. The method of claim 10, further comprising: programming the PKI accelerator to access the accelerator memory to obtain the operating parameters without using an interconnection coupled between the requesting agent and the PKI accelerator.
15. determining a hash of a server certificate using the requesting agent; writing the hash, the server certificate, and a private key to the memory; reading the hash, the server certificate, and the private key from the memory using the PKI accelerator; 11. The method of claim 10, further comprising: performing an Elliptic Curve Digital Signature Algorithm (ECDSA) verification using the hash, the server certificate, and the private key in the PKI accelerator.
16. writing a server public key and a client private key to the memory using the requesting agent; using said requesting agent to write a hash of a server / client Hello packet to said memory; reading the server's public key, the client's private key, and the hash from the memory using the PKI accelerator; 11. The method of claim 10, further comprising: using the PKI accelerator to perform an Elliptic Curve Diffie-Hellman (ECDH) point multiplication based on the server public key, the client private key, and the hash.
Citation Information
Patent Citations
Method, device and system for offloading algorithms
JP2021501407A
Technologies for dynamic multi-core network packet processing distribution
US20190294570A1
Secure communication with a trusted execution environment
US20200220713A1
