Utilization of storage devices in per-user encryption
By establishing a shared symmetric key in the memory device and encrypting messages, the security problem of communication endpoint authentication of memory device in the service network is solved, and the confidentiality of data transmission and the accuracy of authentication are achieved.
Patent Information
- Application Number
- CN202210214945.8
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Priority Date
- 2021-03-09
- Filing Date
- 2022-03-07
- Publication Date
- 2024-11-05
- Estimated Expiration
- 2042-03-07
AI Technical Summary
In the service network, the communication endpoint authentication of memory devices has difficulties in security and identity verification, and the prior art is difficult to effectively solve this problem.
Encryption and authentication of messages are achieved by establishing a shared symmetric key in the memory device, sharing it with the remote computing device, and generating ciphertext using the symmetric key and payload.
Improve the communication security of the memory device, ensure the confidentiality of data transmission and the accuracy of identity verification, and prevent unauthorized access.
Smart Images

Figure CN115051822B_ABST
Abstract
Description
Technical Field
[0001] At least some embodiments disclosed herein relate generally to authentication, and more particularly, but not limited to, authentication of communication endpoints having secure memory devices in a service network. Background Art
[0002] The memory subsystem may include one or more memory devices that store data. The memory devices may be, for example, non-volatile memory devices and volatile memory devices. In general, the host system may utilize the memory subsystem to store data at the memory devices and retrieve data from the memory devices. Summary of the invention
[0003] One aspect of the present disclosure provides a method, comprising: receiving a request from an application at a memory device to establish a communication session with a remote computing device; establishing a shared symmetric key through the memory device, the shared symmetric key being shared between the memory device and the remote computing device; receiving a message from the application at the memory device, the message including an identifier of the remote computing device and a payload; and generating a ciphertext through the memory device using the symmetric key and the payload.
[0004] Another aspect of the present disclosure provides a device comprising: a host processor configured to execute an application; and a memory device coupled to the host processor, the memory device configured to store data and further configured to: receive a request from the application to establish a communication session with a remote computing device; establish a shared symmetric key, the shared symmetric key shared between the memory device and the remote computing device; receive a message from the application, the message including an identifier of the remote computing device and a payload; and generate a ciphertext using the symmetric key and the payload.
[0005] Another aspect of the present disclosure provides a non-transitory computer-readable storage medium for tangibly storing computer program instructions executable by a computer processor, the computer program instructions defining the following steps: receiving a request from an application to establish a communication session with a remote computing device; establishing a shared symmetric key, the shared symmetric key being shared with the remote computing device, the shared symmetric key comprising a volatile derived key generated from a static symmetric key; receiving a message from the application, the message comprising an identifier of the remote computing device and a payload; and generating a ciphertext using the symmetric key and the payload. BRIEF DESCRIPTION OF THE DRAWINGS
[0006] Embodiments are illustrated by way of example and not limitation in the figures of the accompanying drawings in which like reference numerals indicate similar elements.
[0007] Figure 1 An example computing system having a memory subsystem according to some embodiments of the present disclosure is described.
[0008] Figure 2 An integrated circuit memory device having a security manager according to one embodiment is described.
[0009] Figure 3 The generation of certificates for endpoint authentication according to one embodiment is described.
[0010] Figure 4 The use of certificates for endpoint authentication according to one embodiment is described.
[0011] Figure 5 A flow chart illustrating a method for generating a symmetric key according to some embodiments of the present disclosure.
[0012] Figure 6 A flow chart illustrating a method for encrypting a message according to some embodiments of the present disclosure.
[0013] Figure 7 A flow chart illustrating a method for decrypting a response message according to some embodiments of the present disclosure.
[0014] Figure 8 is a block diagram of an example computer system in which embodiments of the present disclosure may operate. DETAILED DESCRIPTION
[0015] Figure 1 An example computing system 100 is illustrated that includes a memory subsystem 110 according to some embodiments of the present disclosure. Memory subsystem 110 may include media such as one or more volatile memory devices (e.g., memory device 140), one or more non-volatile memory devices (e.g., memory device 130), or a combination of these.
[0016] The memory subsystem 110 may be a storage device, a memory module, or a mixture of storage devices and memory modules. Examples of storage devices include solid-state drives (SSDs), flash drives, universal serial bus (USB) flash drives, embedded multimedia controller (eMMC) drives, universal flash storage (UFS) drives, secure digital (SD) cards, and hard disk drives (HDDs). Examples of memory modules include dual in-line memory modules (DIMMs), small outline DIMMs (SO-DIMMs), and various types of non-volatile dual in-line memory modules (NVDIMMs).
[0017] The computing system 100 may be a computing device, such as a desktop computer, a laptop computer, a network server, a mobile device, a vehicle (e.g., an airplane, a drone, a train, a car, or other transportation), a device with Internet of Things (IoT) capabilities, an embedded computer (e.g., an embedded computer included in a vehicle, industrial equipment, or a networked commercial device), or such a computing device that includes a memory and a processing device.
[0018] Computing system 100 may include a host system 120 coupled to one or more memory subsystems 110 . Figure 1 An example of a host system 120 coupled to a memory subsystem 110 is illustrated. As used herein, "coupled to" or "coupled with" generally refers to a connection between components, which may be an indirect communication connection or a direct communication connection (e.g., without intervening components), whether wired or wireless, including connections such as electrical connections, optical connections, magnetic connections, etc.
[0019] The host system 120 may include a processor chipset (e.g., processing device 118) and a software stack executed by the processor chipset. The processor chipset may include one or more cores, one or more cache memories, a memory controller (e.g., controller 116) (e.g., NVDIMM controller), and a storage protocol controller (e.g., PCIe controller, SATA controller). The host system 120 uses the memory subsystem 110, for example, to write data to the memory subsystem 110 and read data from the memory subsystem 110.
[0020] The host system 120 may be coupled to the memory subsystem 110 via a physical host interface. Examples of the physical host interface include, but are not limited to, a Serial Advanced Technology Attachment (SATA) interface, a Peripheral Component Interconnect Express (PCIe) interface, a Universal Serial Bus (USB) interface, a Fibre Channel, a Serial Attached SCSI (SAS) interface, a Double Data Rate (DDR) memory bus interface, a Small Computer System Interface (SCSI), a Dual In-line Memory Module (DIMM) interface (e.g., a DIMM socket interface supporting Double Data Rate (DDR)), an Open NAND Flash Interface (ONFI), a Double Data Rate (DDR) interface, a Low Power Double Data Rate (LPDDR) interface, or any other interface. The physical host interface may be used to transmit data between the host system 120 and the memory subsystem 110. When the memory subsystem 110 is coupled to the host system 120 through the PCIe interface, the host system 120 may further utilize an NVM Express (NVMe) interface to access components (e.g., the memory device 130). The physical host interface may provide an interface for transferring control, address, data, and other signals between the memory subsystem 110 and the host system 120 . Figure 1 Memory subsystem 110 is illustrated as an example. In general, host system 120 can access multiple memory subsystems via the same communication connection, multiple separate communication connections, and / or a combination of communication connections.
[0021] The processing device 118 of the host system 120 can be, for example, a microprocessor, a central processing unit (CPU), a processing core of a processor, an execution unit, etc. In some cases, the controller 116 may be referred to as a memory controller, a memory management unit, and / or an initiator. In one example, the controller 116 controls communications via a bus coupled between the host system 120 and the memory subsystem 110. In general, the controller 116 can send commands or requests to the memory subsystem 110 that desire to access the memory devices 130, 140. The controller 116 can further include an interface circuit system for communicating with the memory subsystem 110. The interface circuit system can convert responses received from the memory subsystem 110 into information for the host system 120.
[0022] The controller 116 of the host system 120 can communicate with the controller 115 of the memory subsystem 110 to perform operations, such as reading data, writing data, or erasing data at the memory devices 130, 140, and other such operations. In some cases, the controller 116 is integrated into the same package of the processing device 118. In other cases, the controller 116 is separate from the package of the processing device 118. The controller 116 and / or the processing device 118 can include hardware, such as one or more integrated circuits (ICs) and / or discrete components, buffer memory, cache memory, or a combination thereof. The controller 116 and / or the processing device 118 can be a microcontroller, a dedicated logic circuit system (e.g., a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), etc.), or another suitable processor.
[0023] The memory devices 130, 140 may include any combination of different types of non-volatile memory components and / or volatile memory components. Volatile memory devices (e.g., memory device 140) may be, but are not limited to, random access memory (RAM), such as dynamic random access memory (DRAM) and synchronous dynamic random access memory (SDRAM).
[0024] Some examples of non-volatile memory components include NAND (or NOT AND) type flash memory and write-in-place memory, such as three-dimensional cross-point ("3D cross-point") memory. A cross-point array of non-volatile memory can be combined with a stackable cross-grid data access array to perform bit storage based on changes in body resistance. In addition, compared to many flash-based memories, cross-point non-volatile memory can perform write-in-place operations, where non-volatile memory cells can be programmed without pre-erasing the non-volatile memory cells. NAND type flash memory includes, for example, two-dimensional NAND (2D NAND) and three-dimensional NAND (3D NAND).
[0025] Each of the memory devices 130 may include one or more memory cell arrays. One type of memory cell, for example, a single-level cell (SLC) may store one bit per cell. Other types of memory cells, for example, multi-level cells (MLC), three-level cells (TLC), four-level cells (QLC), and five-level cells (PLC) may store multiple bits per cell. In some embodiments, each of the memory devices 130 may include one or more memory cell arrays, for example, SLC, MLC, TLC, QLC, PLC, or any combination of these. In some embodiments, a particular memory device may include an SLC portion, an MLC portion, a TLC portion, a QLC portion, and / or a PLC portion of a memory cell. The memory cells of the memory device 130 may be grouped into pages that may refer to logical units of a memory device for storing data. For some types of memory (e.g., NAND), pages may be grouped to form blocks.
[0026] Although non-volatile memory devices such as 3D cross-point type and NAND type memory (e.g., 2D NAND, 3D NAND) are described, the memory device 130 can be based on any other type of non-volatile memory, such as read-only memory (ROM), phase change memory (PCM), self-selected memory, other chalcogenide-based memory, ferroelectric transistor random access memory (FeTRAM), ferroelectric random access memory (FeRAM), magnetic random access memory (MRAM), spin transfer torque (STT)-MRAM, conductive bridge RAM (CBRAM), resistive random access memory (RRAM), oxide-based RRAM (OxRAM), NOR (NOR) flash memory, and electrically erasable programmable read-only memory (EEPROM).
[0027] The memory subsystem controller 115 (or, for simplicity, the controller 115) can communicate with the memory device 130 to perform operations, such as reading data, writing data, or erasing data and other such operations at the memory device 130 (e.g., in response to commands dispatched by the controller 116 on the command bus). The controller 115 can include hardware, such as one or more integrated circuits (ICs) and / or discrete components, buffer memory, or a combination thereof. The hardware can include digital circuitry with dedicated (i.e., hard-coded) logic to perform the operations described herein. The controller 115 can be a microcontroller, dedicated logic circuitry (e.g., a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), etc.), or another suitable processor.
[0028] The controller 115 may include a processing device 117 (e.g., a processor) configured to execute instructions stored in a local memory 119. In the illustrated example, the local memory 119 of the controller 115 includes an embedded memory configured to store instructions for executing various processes, operations, logic flows, and routines that control the operation of the memory subsystem 110, including handling communications between the memory subsystem 110 and the host system 120.
[0029] In some embodiments, local memory 119 may include memory registers that store memory pointers, fetched data, etc. Local memory 119 may also include read-only memory (ROM) for storing microcode. Figure 1 The example memory subsystem 110 in has been described as including a controller 115, but in another embodiment of the present disclosure, the memory subsystem 110 does not include a controller 115 and may instead rely on external control (e.g., provided by an external host or by a processor or controller separate from the memory subsystem).
[0030] In general, the controller 115 may receive commands or operations from the host system 120 and may convert the commands or operations into instructions or appropriate commands to achieve the desired access to the memory device 130. The controller 115 may be responsible for other operations, such as wear leveling operations, garbage collection operations, error detection and error correction code (ECC) operations, encryption operations, cache operations, and address translation between logical addresses (e.g., logical block addresses (LBA), name spaces) and physical addresses (e.g., physical block addresses) associated with the memory device 130. The controller 115 may further include a host interface circuit system to communicate with the host system 120 via a physical host interface. The host interface circuit system may convert commands received from the host system into command instructions to access the memory device 130, and convert responses associated with the memory device 130 into information for the host system 120.
[0031] The memory subsystem 110 may also include additional circuitry or components not illustrated. In some embodiments, the memory subsystem 110 may include a cache memory or buffer (e.g., DRAM) and address circuitry (e.g., row decoder and column decoder) that may receive an address from the controller 115 and decode the address to access the memory device 130.
[0032] In some embodiments, the memory device 130 includes a local media controller 150 that operates with the memory subsystem controller 115 to perform operations on one or more memory cells of the memory device 130. An external controller (e.g., the memory subsystem controller 115) can manage the memory device 130 externally (e.g., perform media management operations on the memory device 130). In some embodiments, the memory device 130 is a managed memory device, which is a raw memory device combined with a local controller (e.g., the local media controller 150) for media management within the same memory device package. An example of a managed memory device is a managed NAND (MNAND) device.
[0033] The controller 115 and / or the memory device 130 may include a security manager 113 configured to generate a certificate that may be used to authenticate the computing system 100 as an endpoint in a computer network having a particular combination of the memory device 130 and one or more other components. In some embodiments, the controller 115 and / or the local media controller 150 in the memory subsystem 110 may include at least a portion of the security manager 113. In other embodiments, or in combination, the controller 116 and / or the processing device 118 in the host system 120 may include at least a portion of the security manager 113. For example, the controller 115, the controller 116, and / or the processing device 118 may include logic circuitry that implements the security manager 113. For example, the controller 115 or the processing device 118 (e.g., a processor) of the host system 120 may be configured to execute instructions stored in a memory for performing the operations of the security manager 113 described herein. In some embodiments, the security manager 113 is implemented in an integrated circuit chip included in the memory subsystem 110. In other embodiments, the security manager 113 may be part of the firmware of the memory subsystem 110, the operating system of the host system 120, a device driver or application, or any combination thereof.
[0034] For example, the security manager 113 may determine a cryptographic hash value of a set of instructions to be executed during boot time of the computing system 100. The security manager 113 may check the integrity of the instruction set by comparing the hash value calculated at boot time with a pre-calculated hash value. If the hash values are consistent with each other, the instruction set may be deemed to have not been tampered with and / or damaged. Therefore, the instruction set may be executed in the computing system 100 to further implement security operations of the security manager 113 and / or boot operations of the computing system 100. Optionally, the verification of the hash value may be part of the authentication of the computing system 100 as an endpoint using a certificate generated by executing at least a portion of the instruction set during boot time of the computing system 100.
[0035] For example, the identifier of the memory device 130 may be generated based at least in part on the hash value of the instruction set. Therefore, when the identifier of the memory device 130 is authenticated by the verification of the certificate, the hash value of the instruction set may be considered to have been verified to be correct; and the instruction set used to generate the certificate and boot the computing system 100 has not been tampered with and / or damaged.
[0036] Execution of the set of instructions in computing system 100 causes computing system 100 to determine the identities of other components of computing system 100, such as an identifier of processing device 118, an identifier of controller 116, an identifier of memory subsystem controller 115, an identifier of memory device 140, and / or an identifier of a software program (e.g., an operating system, a device driver, an application, etc.). A set of identifiers of components in computing system 100 with memory device 130, including an identifier of memory device 130, may be combined to generate a cryptographic key for signing a certificate. The certificate may include a monotonically increasing counter value that is incremented each time computing system 100 is booted and / or each time memory device 130 performs a security operation.
[0037] The certificate can be transmitted over a computer network by a remote computer for authentication. In some embodiments, the host device can further confirm the identity of the memory device via a challenge-response protocol. In these embodiments, the host device generates and issues a challenge to the memory device (e.g., a random or pseudo-random value). The memory device signs the challenge with its private key and returns the signed value. The host device can then use the corresponding public key of the memory device to confirm the signature. If the signature matches, the host device can confirm the identity of the memory device. When the certificate is authenticated and the identity of the memory device is confirmed, it can be concluded that the integrity of the instruction set used to generate the certificate is intact, and the computing system 100 has a combination of a memory device 130 and a set of components represented by an identifier for generating an encryption key for signing the certificate. In addition, the monotonic counter value contained in the certificate allows its recipient to verify whether it is recently generated, and therefore it can be trusted.
[0038] Figure 2 An integrated circuit memory device having a security manager according to one embodiment is described. For example, Figure 1 The memory device 130 in the memory subsystem 110 may use Figure 2 The integrated circuit memory device 130 is implemented.
[0039] The integrated circuit memory device 130 may be enclosed in a single integrated circuit package. The integrated circuit memory device 130 includes a plurality of memory regions 131, ..., 133 which may be formed in one or more integrated circuit dies. A typical memory cell in the memory regions 131, ..., 133 may be programmed to store one or more bits of data.
[0040] The local media controller 150 may include at least a portion of the security manager 113 configured to control access to at least one of the memory areas 131 , . . . , 133 .
[0041] For example, the security manager 113 may control access to the memory area 131 based on an encryption key generated based on the confidentiality of the integrated circuit memory device 130 and / or an encryption key representing the owner or authorized user of the memory device 130. When a request to write data to the memory area 131 is received in the integrated circuit memory device 130, the security manager 113 may verify whether the request can be granted based on whether the requester possesses the encryption key. For example, the requester may digitally sign the request or challenge message using the encryption key to indicate that the requester has permission to write data to the memory area 131.
[0042] The integrated circuit memory device 130 has a communication interface 147 to receive a command with an address 135 from the controller 115 of the memory subsystem 110. In response to the address 135 identifying the memory region 131 requiring access control, the security manager 113 performs a cryptographic operation to verify that the request is from a requestor having an encryption key authorized to access the memory region 131, and then uses the address decoder 141 to provide memory data retrieved from the memory region 131. The address decoder 141 of the integrated circuit memory device 130 converts the address 135 into a control signal to select a group of memory cells in the integrated circuit memory device 130; and the local media controller 150 of the integrated circuit memory device 130 performs an operation to determine the memory data stored in the memory cell at the address 135.
[0043] For example, memory area 131 may store boot loader 171. At boot time, security manager 113 may measure boot loader 171 by calculating a cryptographic hash value of boot loader 171. The cryptographic hash value of boot loader 171 may be used to generate device identifier 151 for integrated circuit memory device 130. Boot loader 171 (and / or an operating system or device driver, or a security application) may include instructions to implement a portion of security manager 113. During boot time, the instructions may determine the configuration of computing system 100, of which integrated circuit memory device 130 is a component.
[0044] For example, Figure 1 The configuration of the computing system 100 may include the main software / firmware components of the memory subsystem 110. The software / firmware may be stored in other memory devices (e.g., 140), or in the memory device 130 in the memory area 133. For example, the instructions 173 in the memory area 133 in the integrated circuit memory device 130 may include an operating system of the computing system 100, a device driver, firmware, and / or a software application. Some of the main software / firmware components of the memory subsystem 110 may be stored outside the memory area and / or outside the integrated circuit memory device 130 under the access control of the security manager 113. The identifier of the software / firmware component may include a component identification, a version number, a serial number, and / or a cryptographic hash value of the software / firmware component.
[0045] Figure 1 The configuration of the computing system 100 may include major hardware components of the memory subsystem 110, such as a processing device 118 and / or a controller 116. The host system 120 may further include peripheral devices, such as a network interface card, a communication device, another memory subsystem, etc. The identifier of the hardware component may include a serial number, an address, an identification number, etc.
[0046] Configuration information of computing system 100 including device identifier 151 may be used to generate a cryptographic key to sign a certificate generated using at least a value from monotonic counter 153. Security manager 113 is configured to increment monotonic counter 153 for each use of boot loader 171 to boot computing system 100 with memory device 130 configured therein.
[0047] Figure 3 The generation of a certificate for endpoint authentication according to one embodiment is described. For example, Figure 1 The security manager 113 described in and / or 2 may be used at the boot time of the computing system 100 Figure 3 The technology produces the certificate.
[0048] exist Figure 3 , computing system 100 has a set of components 181, 183, ..., 185. Components 181, 183, ..., 185 may include software components and / or hardware components. Components 181 to 185 may have corresponding identifiers 191, 193, ..., 195. For example, component S 183 may be a software component with identifier S 193, and component T 185 may be a hardware component with a separate identifier T 195.
[0049] The identifier of a component identifies at least some unique aspects of the component. In some cases, the identifier may uniquely identify the component among similar components having the same or similar functionality. For example, the identifier of a software component may include or be based on a cryptographic hash value of the software component and / or a serial number of the software component. For example, the identifier of a hardware component may be based on the type, description, serial number, and / or address of the hardware component.
[0050] The operation of key generation 155 is performed to obtain a first pair of device ID private key 160 and device ID public key 162 and a second pair of alias private key 161 and alias public key 163. In one embodiment, a physical unclonable function (PUF) can be used to generate a symmetric key on the device. This PUF may include an SRAM PUF, a delay PUF, or any other PUF technology implemented on the device. The PUF generally generates a digital fingerprint that gives a set of physical characteristics of the semiconductor device. Therefore, the digital fingerprint is uniquely associated with each circuit used to generate the PUF. When implemented in a memory device, the PUF generates a unique identifier for the memory device based on the presence of the circuit in the memory device. Using this symmetric key, the device can generate a symmetric key using a symmetric key algorithm. In one embodiment, the symmetric key algorithm takes the digital fingerprint as input and outputs a symmetric key. Because the PUF is associated with the circuit system that generates the value, the PUF can be regenerated at any time and does not have to be stored in a volatile memory. It can therefore be concluded that the symmetric key can be continuously regenerated at any time and does not need to be stored.
[0051] The symmetric key can then be used to generate an asymmetric key pair. Similar to symmetric key generation, an asymmetric key is generated using a large random number as input. In the illustrated embodiment, a symmetric key is used as this input and is therefore used to generate an asymmetric key pair. Because digital fingerprints and symmetric keys can be generated arbitrarily, continuously and repeatedly, it can be concluded that an asymmetric key pair can be generated in the same manner. Using asymmetric encryption, ciphertext generated using the alias private key 161 can be decrypted using the alias public key 163, and ciphertext generated using the alias public key 163 can be decrypted using the alias private key 161. Because it is very difficult to determine the alias private key 161 from the alias public key 163, revealing the alias public key 163 will not compromise the security of the alias private key 161.
[0052] In some embodiments, the memory device 130 may additionally include program logic and / or hardware for performing other cryptographic operations. In one embodiment, this program logic and / or hardware may be implemented as a cryptographic coprocessor 199 in the memory device 130. In some embodiments, the cryptographic coprocessor 199 may be implemented in the memory subsystem 110, alternatively or additionally to being implemented in the memory device 130. In one embodiment, these operations include the generation of symmetric keys as described above. Alternatively, or in combination with the foregoing, the memory device 130 may additionally include program logic and / or circuitry to perform a Diffie-Hellman (DH) key exchange (e.g., elliptic curve DH, ECDH exchange) with another device. In one embodiment, the other device may include the host system 120. In another embodiment, the other device may include the server 201. In some embodiments, the memory device 130 may exchange keys with two devices. In some embodiments, the memory device 130 and / or the subsystem 110 include circuitry (e.g., a network transceiver) for communicating with a remote computing device. Alternatively, the memory device 130 and / or the subsystem 110 may utilize an external network interface via, for example, an intermediary device, such as the host system 120 .
[0053] In one embodiment, the ECDH key exchange may use key pairs 160, 162 or key pairs 161, 163. The remote device (e.g., 120 or 201) may contain its own public-private key pair. In some embodiments, one or both of the devices may generate a new public / private key pair (referred to as public_key and private_key) for use in the ECDH exchange. The derivation of these keys based on PUF is described above and is not repeated herein. The server or host system may utilize any public / private key pair as desired.
[0054] In an ECDH key exchange, both devices generate a random key pair using the private key of the key pair and an ECC elliptic curve with a generator point G. Specifically, [public_random, private_random] = private_key*G. The devices can then exchange the public_random key over an unsecured network (and, for example, via an intermediate device such as the host system 120). Each device independently generates a shared key based on the public_random key and the device's private_key: shared_key = public_random*private_key. In some embodiments, this shared key can be used as a shared key or as an input into another cryptographic primitive (e.g., a hash function) to generate a derived key. In this way, the memory subsystem 110 and the remote endpoint can share a confidential key without exposing confidential data to an intermediate device, such as the host system 120.
[0055] The operation of certificate generation 157 is performed to generate a certificate 165 containing a digital signature 169 signed using the device ID private key 160. The certificate 165 contains the data to be signed, including the alias public key 163 and the current monotonic counter value 168. A side effect of certificate generation 157 is that the value 168 of the monotonic counter 153 is incremented.
[0056] Optionally, credentials 165 may include a user ID 167, such as a name, email address, registered user name, or another identifier of the owner or authorized user of the computing system 100 in which credentials 165 are formed.
[0057] Optionally, certificate 165 may contain some of identifiers 191 to 195 and / or the value of monotonic counter 153 .
[0058] Optionally, some of the information provided via the certificate may be in encrypted form. For example, the information may be encrypted using a public key of a server authorized to access encrypted information, such as a server configured to authenticate digital signature 169.
[0059] The security manager 113 is configured to generate a certificate 165 during each instance of booting the computing system 100 using the boot loader 171 secure in the memory device 130. A certificate 165 generated based on a higher value of the monotonic counter 153 invalidates a certificate that generated a lower value of the monotonic counter 153. The remote host will reject any certificate with a lower monotonic counter value than the one used for the last successful connection.
[0060] Preferably, after generating certificate 165, device ID private key 160 is cleared from computing system 100 and memory device 130. A set of instructions protected by security manager 113 can be executed to authenticate computing system 100 as an endpoint in a computer network using certificate 165 generated at boot time. A remote server with device ID public key 162 can verify digital signature 169 and the configuration of computing system 100 as identified by identifiers 191-195 used in key generation 155.
[0061] Figure 4 The use of certificates for endpoint authentication according to one embodiment is described. For example, Figure 4 The endpoint 205 may be a Figure 2 The security manager 113 in the integrated circuit memory device 130 Figure 1 The computing system 100 of FIG. Authentication may be performed using a certificate 165, which is a certificate that is used Figure 3 Produced by technology.
[0062] exist Figure 4 , the endpoint 205 includes a memory device 130 having a unique device secret 175. The device identifier 151 of the memory device 130 may be generated using the unique device secret 175 and a cryptographic measure of the boot loader 171. For example, the cryptographic measure of the boot loader 171 may be obtained by reading the boot loader 171 before it is executed and applying a cryptographic hash function to the boot loader 171 to obtain a cryptographic hash value of the boot loader 171 to be executed.
[0063] Endpoint 205 has an additional component 187 having identification data 197. The combination of device identifier 151 and identification data 197 can be used to identify the device 151 as follows: Figure 3 Generate certificate 165 in the manner described in .
[0064] Server 201 connected to endpoint 205 via computer network 203 is provided with device ID public key 162 corresponding to device ID private key 160 used to sign certificate 165. Server 201 can determine whether certificate 165 is valid by decrypting digital signature 169 using device ID public key 162.
[0065] For example, when initially using memory device 130 in endpoint 205 to boot up endpoint 205, endpoint 205 may register its identity with server 201 by providing device ID public key 162. The registration operation may include storage of device ID public key 162 to indicate that endpoint 205, having a certificate verifiable via device ID public key 162, is an authorized user. Device ID public key 162 may be associated with an identification of an owner of endpoint 205 and / or an authorized user.
[0066] The certificate 165 contains the value 168 of the monotonic counter 153 when the endpoint 205 was started.
[0067] Alternatively, the certificate 165 may contain some of the identifiers 191 to 195 used to generate the alias private key 161 , the alias public key 163 , the device ID private key 160 , and the device ID public key 162 .
[0068] In some embodiments, server 201 has a copy of unique device secret 175. For example, memory device 130 may be registered in a manufacturing facility of memory device 130 so that device identifier 151 may be independently regenerated in secure server (e.g., 201). When server 201 receives additional identifiers (e.g., 193 to 195, such as identification data 197) from endpoint 205, secure server (e.g., 201) may independently calculate public key 163 for authentication of digital signature 169. Optionally, certificate 165 may include additional identifiers (e.g., 193 to 195, such as identification data 197). Thus, when some of components 187 have been replaced, server 201 may determine whether to accept the change of endpoint 205 or whether further verification is needed that endpoint 205 is legitimate and / or associated with a known owner or authorized user.
[0069] For example, the instruction set secured via the memory device 130 may be executed in the endpoint 205 to transmit the certificate 165 from the endpoint 205 to the server 201 for authentication. The certificate 165 of the endpoint 205 is generated at the startup of the endpoint 205 to represent the configuration of the endpoint 205 via the set of identifiers 191 to 195. After verifying that the certificate 165 is generated using the device ID private key 160 representing the identifiers 191 to 195, the server 201 may determine whether the endpoint 205 with the configuration is permitted to operate and / or receiver services. In some cases, the server 201 may allow the endpoint 205 to replace certain components and / or have a replacement frequency below a threshold to transmit authentication. Based on the response, the endpoint 205 may prompt the user to register the display ownership or authorization for use, or close.
[0070] Alternatively, the server 201 may track the highest value of the monotonic counter 153 of the endpoint 205 as seen in the certificate from the endpoint 205 and / or the memory device 130. Certificates generated based on counter values equal to or lower than the most recent counter value used in a successful connection of an endpoint 205 to the server 201 may be described as invalid. An endpoint 205 presenting an invalid certificate will not be granted access to the server 201.
[0071] In some embodiments, the server 201 has a copy of the alias public key 163. When establishing a connection with the endpoint 205, and after verifying that the certificate 165 has a valid digital signature 169 and a non-invalidated monotonic counter value 168, the server 201 can verify the alias public key 163 portion of the certificate. If the alias public key 163 stored in the server 201 and the alias public key 163 contained in the certificate 165 do not match, then the connection with the endpoint 205 may not be allowed. This check can be used to prevent attacks in which a malicious actor is able to steal the alias private key 161 from a valid device and use it on the device through a compromised identifier (e.g., one of the device identifiers 151, 191, 193, ..., 195). If the keys match, then the alias private key 161 available at runtime on the endpoint 205 can be used to sign content that can be verified by the server 201.
[0072] For example, as part of the connection establishment procedure, server 201 may issue a challenge to endpoint 205, which signs the response with alias private key 161 and sends it back to server 201. Server 201 may then use its copy of alias public key 163 and verify that the challenge was signed by a valid endpoint 205.
[0073] Figure 5 A flowchart illustrating a method for generating a symmetric key according to some embodiments of the present disclosure. In one embodiment, the combination of Figure 5 The method described.
[0074] In block 502, the method receives a request to establish a communication session. In one embodiment, the request is received from an application running on a host system and identifies a remote computing device to connect to, such as server 201. In some embodiments, the remote computing device is identified by an identifier (e.g., a uniform resource locator or an Internet Protocol address).
[0075] In the illustrated embodiment, the host system 120 can issue commands to the memory device 130 via the bus and interface. In one embodiment, the device supports commands that instruct the memory device 130 to communicate with a remote device. In one embodiment, the memory device 130 is equipped with a network interface to communicate with the remote device. In another embodiment, the memory device 130 includes firmware or software to issue network requests via an external network interface.
[0076] In one embodiment, the request includes an identifier of the remote computing device. In one embodiment, this identifier may include a network address of the remote computing device. Examples of network addresses include an Internet Protocol (IP) address, a Media Access Control (MAC) address, a Uniform Resource Locator (URL), or a Uniform Resource Identifier (URI). Other types of network addresses may also be used. In some embodiments, the identifier may include an identifier of an internal component of the computer system. In this embodiment, the component includes a component capable of generating a symmetric key (e.g., a peripheral device including an encryption processor). In this embodiment, the method described herein may be used to securely communicate with a computing device or system and with an external device. For example, the method may be used to encrypt communications between a computing device and a printer.
[0077] In some embodiments, the request may also include a storage location. In this embodiment, the request is a request for data from a remote computing device and also specifies where the returned data is to be stored. For example, the request may request a block of data from a remote computing device and specify where to begin writing such data. In one embodiment, this address may include a logical block address (LBA) of a NAND flash array.
[0078] In another embodiment, the request may specify a code segment to execute the returned data. In this embodiment, because the memory device may include a non-volatile storage device, the request may indicate a portion of the executable code executed on the data. In this embodiment, the memory device can perform in-memory processing on remote data without the application processing the data. For example, the application may issue a request including a remote identifier (e.g., URL) and a program address (e.g., 0x0AF0BC3) of the first instruction of the processing routine to execute after receiving the response data. In this way, the memory device can request data (as will be discussed) and then begin processing the data starting at the address. In some embodiments, the memory device includes a dynamic random access memory (DRAM) to load program code and execute program code on the returned data. In one embodiment, the method may return the processed data (unencrypted) to the application. In another embodiment, in combination with the foregoing, the method may alternatively write the data to its storage array and return the location of the data to the application.
[0079] Thus, in block 502 , the host application initiates a remote data session not directly with the remote computing device, but via the memory device 130 .
[0080] In block 504, the method establishes a shared symmetric key with a remote computing device.
[0081] In the illustrated embodiment, a shared symmetric key will ultimately be shared between the memory device and the remote computing device.In one embodiment, the method establishes a shared symmetric key via an ECDH key exchange.
[0082] In one embodiment, the ECDH key exchange may use a static key pair, such as a shared symmetric key (e.g., a symmetric key generated based on a PUF). The remote device (e.g., 120 or 201) may contain its own public-private key pair. In some embodiments, one or both of the devices may generate a new public / private key pair (referred to as public_key and private_key) for use in the ECDH exchange. The derivation of these keys based on the PUF is described above and is not repeated herein. The server or host system may utilize any public / private key pair as desired.
[0083] In an ECDH key exchange, both devices generate a random key pair using the private key of the key pair and an ECC elliptic curve with a generator point G. Specifically, [public_random, private_random] = private_key*G. The devices can then exchange the public_random key over an unsecured network (and, for example, via an intermediate device such as the host system 120). Each device independently generates a shared key based on the public_random key and the device's private_key: shared_key = public_random*private_key. In some embodiments, this shared key can be used as a shared key or can be input into another cryptographic primitive (e.g., a hash function) to generate an alias or derived key. In this way, the memory subsystem 110 and the remote endpoint can share a confidential key without exposing confidential data to an intermediate device, such as the host system 120.
[0084] Thus, in the illustrated embodiment, the memory device can generate a shared symmetric key for encryption and signing operations. Notably, the memory device can establish this shared key without allowing access to the shared key to the application or host processor.
[0085] Alternatively, in some embodiments, key exchange may utilize volatile or alias keys derived from static symmetric keys. In these embodiments, the method generates a derived volatile key from a shared (e.g., non-volatile or reproducible) symmetric key. In this embodiment, the static symmetric key is used infrequently, thereby reducing its ability to be attacked. In contrast, the derived volatile key is the actual key used in practice and it can be frequently changed. For example, the method may generate a derived volatile key at each power-on or on demand by a host processor. By using a derived key, the method may reduce the effectiveness of a side-channel attack to discover a key. In addition, when the key changes more frequently than the time required for the attack to succeed, such an attack will fail.
[0086] In some embodiments, the memory device may support an additional command that allows a host application to request a shared key. In this embodiment, the host application issues the command with its own private key, and the memory device may verify the command with a corresponding public key stored in the memory device. Thus, the memory device may be configured to provide the shared key only to authorized host applications.
[0087] At block 506, the method stores the shared key.
[0088] In one embodiment, the method may store the shared keys in a secure storage element such as a trusted execution environment (TEE) or similar secure processing environment. As discussed, in some embodiments, the method does not allow access to the shared keys to other devices. However, in alternative embodiments, the method may support providing the shared keys to authorized devices after verifying the integrity of the request for such shared keys.
[0089] Figure 6 A flow chart illustrating a method for encrypting a message according to some embodiments of the present disclosure.
[0090] In block 602, the method receives a message from an application, the message comprising an identifier of a remote computation. In some embodiments, the message additionally comprises a payload.
[0091] In the illustrated embodiment, the identifier may include an IP address, a MAC address, a URL, a URI, or a similar identifier as discussed. In one embodiment, the payload may include any data necessary to satisfy the request. For example, in one embodiment, the identifier may include a domain and a protocol (e.g., "https: / / example.com"). The payload may include a Hypertext Transfer Protocol (HTTP) method (e.g., "GET") and a path (e.g., " / secureResource.txt"). Thus, in some embodiments, the memory device will process the payload and the identifier to generate a network request (e.g., "GET https: / / example.com / secureResource.txt"). Of course, other parameters may be included in the payload (e.g., HTTP header fields, POST body parameters). Furthermore, in some embodiments, the method may generate its own fields for inclusion in the network request.
[0092] In block 604, the method identifies the associated shared key and generates a ciphertext.
[0093] In one embodiment, the method maintains a secure table mapping remote computing device identifiers to shared keys. In one embodiment, this table is stored in a TEE or similar secure environment that is not accessible by external devices. In this block, the method determines whether a shared key has been generated for the remote endpoint.
[0094] In one embodiment, if no shared key is found, the method may return an error to the application. However, in other embodiments, the method may perform Figure 5 The method generates a shared key "on the fly" in response to a message, thereby ensuring that all requests to a valid endpoint are processed upon receipt despite the lack of a pre-generated shared key.
[0095] After identifying the shared key, the method uses the shared key to encrypt the message payload. In one embodiment, a symmetric encryption algorithm can be used to generate the encrypted ciphertext. The specific symmetric encryption algorithm used is not restrictive.
[0096] In block 606, the method returns the ciphertext to the application.
[0097] In one embodiment, the method returns the encrypted ciphertext to the application for forwarding to the remote computing device. In another embodiment, the memory device may not return the ciphertext and may instead transmit the ciphertext message to the remote computing device. In some embodiments, the memory device performs this transmission via its own network interface. In other embodiments, the memory device may utilize an external network interface.
[0098] Figure 7 A flow chart illustrating a method for decrypting a response message according to some embodiments of the present disclosure.
[0099] In block 702, the method receives ciphertext from a memory device.
[0100] In one embodiment, after the memory device encrypts the message, the memory device returns a ciphertext including the encrypted message. In one embodiment, the application receives this ciphertext from the memory device. In one embodiment, Figure 6 In step 602, the ciphertext receives a command response to the command issued in the memory device and received by the memory device.
[0101] In some embodiments, step 702 may be optional and steps 704, 706 and 708 may be performed entirely in the memory device. In this embodiment, the memory device is equipped with a network interface or otherwise accessible external interface and can therefore transmit data to a remote computing device independently of the host system and application.
[0102] In block 704, the method transmits the ciphertext to a remote computing device.
[0103] In one embodiment, the method uses an identifier of the remote computing device and any necessary parameters to generate a network endpoint. The method then includes the ciphertext as a payload of the message and transmits the payload to the network endpoint.
[0104] For example, in one embodiment, the payload may include a user identifier (e.g., "username") and a password (e.g., "password"). The memory device encrypts the payload to produce ciphertext (e.g., "f6b71f1ec062312698ccc9dd862f9408" and "1c7ac320d4fe7009d759f7d74966f538"). The identifier may include an HTTP action ("POST http: / / example.com / login"). Thus, the method may set the POST body of the HTTP action to the ciphertext and produce a complete HTTP request message:
[0105] POST / login HTTP / 1.1
[0106] Host:example.com
[0107] Content-Type:application / x-www-form-urlencoded
[0108] Content-Length:83
[0109] username=f6b71f1ec062312698ccc9dd862f9408&password=1c7ac320d4fe7009d759f7
[0110] d74966f538
[0111] As discussed, some of the above header fields may be included in the received message in step 602 (e.g., "POST", " / login", "example.com", payload keys "username" and "password"). Some fields may be automatically generated by the memory device (e.g., "Content-Type") or may be specified by the application. Finally, some fields may have to be generated by the memory device including the ciphertext, the final payload, and the length of the payload. It should be noted that in this example, an unsecure channel is used, thus allowing, for example, an encrypted password to be transmitted over such a channel without the use of a secure transport layer. Of course, a security layer may be used and may be reasonable.
[0112] At block 706 , the method receives an encrypted response from the remote computing device.
[0113] In one embodiment, the encrypted response may be transmitted according to the method used to transmit the request. For example, an HTTP response may be returned in response to the HTTP request. In one embodiment, the encrypted response includes a response body of the response. That is, the encrypted response may include the payload of the response (excluding header data). For example, the response body may include a JavaScript Object Notation (JSON) object of ({"status":"success"}), which may be encrypted as "39cc8455ca2a21188fdc6e633c886b70a7478a597eb8c05a6588c28a0a5ecaf8".
[0114] In block 708, the method transmits the encrypted response to a memory device.
[0115] In some embodiments, the encrypted response includes a ciphertext generated by the remote computing device. In one embodiment, the method transmits a message to a memory device including the ciphertext. In some embodiments, this message may further include an identity of the remote computing device.
[0116] In some embodiments, block 708 may be optional. In these embodiments, the memory device directly receives the encrypted response from the remote computing device. In the illustrated embodiment, however, the application is responsible for receiving the response from the remote computing device. In this context, the method extracts the encrypted response body and transmits the encrypted response ciphertext to the memory device. In some embodiments, the application will include the remote computing device identifier together with the encrypted response so that the memory device can identify the appropriate shared symmetric key. In some embodiments, if the application obtains the symmetric key (as described), then the subsequent block 710 may be executed by the application and block 712 may be omitted. In an embodiment where the application publishes a message to the memory device to decrypt the response, the application may need to sign the message with a private key corresponding to the public key stored on the memory device. This ensures that only authorized applications can request the decryption of the message.
[0117] In the illustrated embodiment, blocks 702, 704, 706, and 708 may be performed by the host system 120. Additionally, blocks 710 and 712 may be performed by the memory subsystem 110 or the memory device 130.
[0118] In block 710, the method decrypts the encrypted response using the shared symmetric key.
[0119] In one embodiment, the method identifies a shared symmetric key based on an identifier contained in a message, the message containing the encrypted response. The method then decrypts the encrypted response using the shared symmetric key.
[0120] In one embodiment, the memory device uses the identifier to search a table of shared symmetric keys. After identifying the shared symmetric key associated with the remote computing device (identified by the identifier), the method decrypts the encrypted response using the identified key, thereby producing a plaintext response. In some embodiments, the memory device will verify the message containing the encrypted message by verifying the digital signature signed by the application using the public key stored on the memory device, thereby ensuring that only authorized devices can request decryption and receive the plaintext response.
[0121] In block 712, the method returns the decrypted response to the application. In the illustrated embodiment, the method returns the decrypted ciphertext to the application in response to the message containing the encrypted response. As discussed, in some embodiments, block 710 may be performed by a host processor and thus block 712 may be optional.
[0122] Figure 8An example machine of a computer system 400 is illustrated, within which a set of instructions for causing the machine to perform any one or more of the methodologies discussed herein may be executed. In some embodiments, the computer system 400 may correspond to a host system (e.g., Figure 1 ) that includes, is coupled to, or utilizes a memory subsystem (e.g., Figure 1 10) or can be used to perform operations of the security manager 113 (e.g., to execute instructions to perform operations corresponding to the reference Figures 1 to 8 In some embodiments, the machine may be connected (e.g., using a network) to other machines in a LAN, an intranet, an extranet, and / or the Internet. The machine may operate in the capacity of a server or a client machine in a client-server network environment, or in the capacity of a server or a client machine in a peer-to-peer (or distributed) network environment.
[0123] The machine may be a personal computer (PC), a tablet PC, a set-top box (STB), a personal digital assistant (PDA), a cellular phone, a network appliance, a server, a network router, a switch or a bridge, or any machine capable of executing (sequentially or otherwise) a set of instructions that specify actions to be taken by the machine. Further, while a single machine is described, the term "machine" should also be construed to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.
[0124] The example computer system 400 includes a processing device 402, a main memory 404 (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM) or Rambus DRAM (RDRAM), static random access memory (SRAM), etc.), and a data storage system 418 that communicates with each other via a bus 430 (which may include multiple buses).
[0125] Processing device 402 represents one or more general purpose processing devices, such as a microprocessor, a central processing unit, or the like. More specifically, the processing device may be a complex instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction word (VLIW) microprocessor, or a processor implementing other instruction sets, or a processor implementing a combination of instruction sets. Processing device 402 may also be one or more special purpose processing devices, such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), a network processor, or the like. Processing device 402 is configured to execute instructions 426 for performing the operations and steps discussed herein. Computer system 400 may further include a network interface device 408 to communicate over a network 420.
[0126] The data storage system 418 may include a machine-readable medium 424 (also referred to as a computer-readable medium) on which is stored one or more sets of instructions 426 or software embodying any one or more of the methods or functions described herein. The instructions 426 may also reside completely or at least partially within the main memory 404 and / or within the processing device 402 during execution thereof by the computer system 400, with the main memory 404 and the processing device 402 also constituting machine-readable storage media. The machine-readable medium 424, the data storage system 418, and / or the main memory 404 may correspond to Figure 1 Memory subsystem 110.
[0127] In one embodiment, instructions 426 include instructions for implementing functionality corresponding to security manager 113 (e.g., security manager 113 described with reference to the previous figures). Although machine-readable storage medium 424 is shown as a single medium in the example embodiment, the term "machine-readable storage medium" should be considered to include a single medium or multiple media storing one or more sets of instructions. The term "machine-readable storage medium" should also be considered to include any medium capable of storing or encoding a set of instructions for execution by a machine and causing the machine to perform any one or more of the methods of the present disclosure. The term "machine-readable storage medium" should therefore be considered to include, but not be limited to, solid-state memory, optical media, and magnetic media.
[0128] Some portions of the previous detailed description have been presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means by which those skilled in the art of data processing most effectively communicate the substance of their work to other skilled in the art. An algorithm is here and generally considered to be a self-consistent sequence of operations that result in a desired result. An operation is an operation that requires physical manipulation of physical quantities. These quantities are typically, but not necessarily, in the form of electrical or magnetic signals that can be stored, combined, compared, and otherwise manipulated. It has proven convenient at times, primarily for general reasons, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.
[0129] It should be borne in mind, however, that all of these and similar terms should be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. The present disclosure may refer to the actions and processes of a computer system or similar electronic computing device that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system's memories or registers or other such information storage systems.
[0130] The present disclosure also relates to an apparatus for performing the operations described herein. This apparatus may be specially constructed for the intended purpose, or it may comprise a general purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer-readable storage medium, such as, but not limited to, any type of disk, including floppy disks, optical disks, CD-ROMs and magnetic optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, or any type of medium suitable for storing electronic instructions, each coupled to a computer system bus.
[0131] The algorithms and displays presented herein are essentially independent of any particular computer or other device. Various general purpose systems may be used with programs according to the teachings herein, or it may prove convenient to construct more specialized equipment for performing the methods. The structures of various such systems will be presented as set forth in the description below. In addition, the present disclosure is described without reference to any particular programming language. It will be appreciated that the teachings of the present disclosure as described herein may be implemented using a variety of programming languages.
[0132] The present disclosure may be provided as a computer program product or software, which may include a machine-readable medium having stored thereon instructions that can be used to program a computer system (or other electronic device) to perform a process according to the present disclosure. A machine-readable medium includes any mechanism for storing information in a machine (e.g., computer) readable form. In some embodiments, a machine-readable (e.g., computer-readable) medium includes a machine (e.g., computer) readable storage medium, such as a read-only memory ("ROM"), a random access memory ("RAM"), a magnetic disk storage medium, an optical storage medium, a flash memory component, etc.
[0133] In this description, in order to simplify the description, various functions and operations may be described as being performed or caused by computer instructions. However, those skilled in the art will recognize that the intention of such expressions is that the functions are derived from the execution of computer instructions by one or more controllers or processors (such as microprocessors). Alternatively or in combination, the functions and operations can be implemented using a dedicated circuit system with or without software instructions, such as using an application specific integrated circuit (ASIC) or a field programmable gate array (FPGA). The embodiments can be implemented using a hard-wired circuit system without software instructions or in combination with software instructions. Therefore, the technology is neither limited to any specific combination of hardware circuit systems and software, nor to any specific source of instructions executed by a data processing system.
[0134] In the foregoing description, embodiments of the present disclosure have been described with reference to specific example embodiments of the present disclosure. It will be apparent that various modifications may be made to the present disclosure without departing from the broader spirit and scope of the embodiments of the present disclosure as set forth in the appended claims. Therefore, the description and drawings should be viewed in an illustrative sense rather than a restrictive sense.
Claims
1. A method comprising: receiving, via a memory controller of a memory device of a computing device, a first command from an application executing on a processor of the computing device to establish a communication session with a remote computing device communicatively connected to the computing device via a network; generating, by the memory controller, a shared symmetric key, the shared symmetric key being shared between the memory device and the remote computing device; storing, by the memory controller, the shared symmetric key in a secure area of the memory device that is inaccessible to the processor of the computing device; receiving, at the memory controller, from the application, a second command including a network identifier of the remote computing device and a payload for transmission to the remote computing device; as well as The payload is encrypted by the memory controller using the shared symmetric key to generate a ciphertext. 2 . The method of claim 1 , wherein receiving the first command to establish the communication session comprises receiving the network identifier of the remote computing device. 3 . The method of claim 2 , wherein receiving the network identifier of the remote computing device comprises receiving a network address of the remote computing device.
4. The method of claim 3, wherein receiving a network address of the remote computing device comprises receiving an address selected from the group consisting of: an Internet Protocol (IP) address, a Media Access Control (MAC) address, a Uniform Resource Locator (URL), or a Uniform Resource Identifier (URI).
5. The method of claim 1 , wherein establishing the shared symmetric key comprises establishing the shared symmetric key via a Diffie-Hellman key exchange protocol, and wherein the shared symmetric key is searched by the memory controller from a mapping table in the secure area based on the network identifier.
6. The method according to claim 1, further comprising: receiving, by the memory controller, from the application a third command including an encrypted response generated by the remote computing device in response to the ciphertext; searching, by the memory controller, for the shared symmetric key from a mapping table in the secure area based on the network identifier; decrypting, by the memory controller, the encrypted response using the shared symmetric key to obtain a decrypted response; as well as The decrypted response is returned to the application by the memory controller in response to the third command.
7. The method of claim 1, wherein the first command comprises a command for accessing a network supported by firmware of the memory controller, and wherein the processor and the memory device are communicatively coupled via a memory bus.
8. The method of claim 1, further comprising returning the ciphertext to the application through the memory controller, causing the processor to forward the ciphertext to the remote computing device.
9. The method of claim 1, further comprising transmitting the shared symmetric key to the application through the memory device in response to a signed key request message.
10. The method of claim 1, wherein establishing the shared symmetric key comprises communicating with the remote computing device via the application through the memory device.
11. The method of claim 1, wherein establishing the shared symmetric key comprises generating a volatile derived key from a static symmetric key.
12. An apparatus comprising: a host processor configured to execute an application program; as well as A memory device coupled to the host processor via a local memory bus, the memory device comprising a storage area and a memory controller, the storage area being configured to store data, the memory controller being configured to: receiving a first command from the application to establish a communication session with a remote computing device communicatively connected to the device via a network; generating a shared symmetric key that is shared between the memory device and the remote computing device, storing the shared symmetric key in a secure area of the memory area that is inaccessible to the host processor, receiving a second command from the application, the second command comprising a network identifier of the remote computing device and a payload for transmission to the remote computing device, and The payload is encrypted using the shared symmetric key to produce a ciphertext.
13. The device of claim 12, wherein receiving the first command to establish the communication session comprises receiving the network identifier of the remote computing device.
14. The device of claim 12, wherein establishing the shared symmetric key comprises establishing the shared symmetric key via a Diffie-Hellman key exchange protocol, and wherein the shared symmetric key is searched by the memory controller from a mapping table in the secure area based on the network identifier.
15. The device of claim 12, wherein the memory device is further configured to: receiving, from the application, a third command comprising an encrypted response generated by the remote computing device in response to the ciphertext; searching the shared symmetric key from a mapping table in the secure area based on the network identifier; decrypting the encrypted response using the shared symmetric key to obtain a decrypted response; as well as The decrypted response is returned to the application in response to the third command.
16. The apparatus of claim 12, wherein the first command comprises a command for accessing a network supported by firmware of the memory controller.
17. The device of claim 12, wherein the memory controller is further configured to return the ciphertext to the application, causing the host processor to forward the ciphertext to the remote computing device.
18. The device of claim 12, wherein the memory controller is further configured to transmit the shared symmetric key to the application in response to a signed key request message.
19. The device of claim 12, wherein establishing the shared symmetric key comprises communicating with the remote computing device via the application through the memory device.
20. The apparatus of claim 12, wherein establishing the shared symmetric key comprises generating a volatile derived key from a static symmetric key.
21. A non-transitory computer readable storage medium for tangibly storing computer program instructions executable by a computer processor, the computer program instructions defining the steps of: receiving, via a memory controller of a memory device communicatively coupled to the computer processor via a local memory bus, a first command from an application executed by the computer processor to establish a communication session with a remote computing device communicatively connected to the computer processor via a network; generating, by the memory controller, a shared symmetric key, the shared symmetric key being shared with the remote computing device, the shared symmetric key comprising a volatile derived key generated from a static symmetric key; storing, by the memory controller, the shared symmetric key in a secure area of the memory device that is inaccessible to the computer processor; receiving, by the memory controller from the application, a second command including a network identifier of the remote computing device and a payload for transmission to the remote computing device; and The payload is encrypted by the memory controller using the shared symmetric key to generate a ciphertext.
22. The non-transitory computer-readable storage medium of claim 21, wherein the first command comprises a command for accessing a network supported by firmware of the memory controller, and wherein the shared symmetric key is searched by the memory controller from a mapping table in the secure area based on the network identifier.
23. The non-transitory computer-readable storage medium of claim 21, wherein the steps further comprise: The ciphertext is returned to the application program through the memory controller, causing the computer processor to forward the ciphertext to the remote computing device.
24. The non-transitory computer-readable storage medium of claim 21, wherein the steps further comprise: receiving, by the memory controller, from the application a third command including an encrypted response generated by the remote computing device in response to the ciphertext; searching, by the memory controller, for the shared symmetric key from a mapping table in the secure area based on the network identifier; decrypting, by the memory controller, the encrypted response using the shared symmetric key to obtain a decrypted response; as well as The decrypted response is returned to the application by the memory controller in response to the third command.
Citation Information
Patent Citations
Shared key encryption using long keypads
CN101278516A
Remote Authentication And Transaction Signatures
CN101765996A
Systems and methods for secure data sharing
CN103609059A
Method of operating a computing device, computing device and computer program
CN104137466A
Safety transfer method, device and system for card application data
CN106507331A
