Electronic device, method, and non-transitory computer-readable storage medium for performing electronic signature

Abstract

This electronic device may comprise a memory for storing instructions. The electronic device may be caused to: receive, through a software application executed on the basis of an REE, a user input for an electronic signature for a transaction based on an encryption key; in response to the reception of the user input, acquire, from a root seed managed within a TEE different from the REE, a private key to be used for decrypting the encryption key; acquire a partial key corresponding to the encryption key by decrypting the encryption key using the private key; and perform the electronic signature for the transaction by using the partial key.

Description

Electronic device, method, and non-transitory computer-readable storage medium for performing electronic signature

[0001] The present disclosure relates to an electronic device, a method, and a non-transitory computer-readable storage medium for performing electronic signature.

[0002] An electronic device may include a rich execution environment (REE) and a trusted execution environment (TEE). The electronic device may perform electronic signatures for transactions using a private key. For example, the electronic device may encrypt information using a public key. For example, the electronic device may decrypt encrypted information using the private key.

[0003] The above information may be provided as background art to aid in understanding the present disclosure.

[0004] No claim or determination is made as to whether any of the above is applicable as prior art to the present disclosure.

[0005] An electronic device is described. The electronic device may include a memory storing instructions and including one or more storage media. The electronic device may include at least one processor including a processing circuit. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive user input for electronically signing a transaction based on a cryptographic key through a software application executing based on a rich execution environment (REE). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to, in response to receiving the user input, obtain a private key to be used for decrypting the cryptographic key from a root seed managed within a trusted execution environment (TEE) different from the REE. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to obtain a partial key corresponding to the cryptographic key by decrypting the cryptographic key using the private key. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to perform an electronic signature for the transaction using the partial key.

[0006] A method is provided. The method can be executed within an electronic device. The method can include receiving, through a software application running on a rich execution environment (REE), a user input for electronically signing a transaction based on a cryptographic key. The method can include, in response to receiving the user input, obtaining a private key to be used for decrypting the cryptographic key from a root seed managed within a trusted execution environment (TEE) different from the REE. The method can include obtaining a partial key corresponding to the cryptographic key by decrypting the cryptographic key using the private key. The method can include performing an electronic signature on the transaction using the partial key.

[0007] A non-transitory computer-readable storage medium is provided. The non-transitory computer-readable storage medium may store one or more programs. The one or more programs may include instructions that, when executed by an electronic device, cause the electronic device to receive user input for electronic signing of a transaction based on a cryptographic key through a software application running on a rich execution environment (REE). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to, in response to receiving the user input, obtain a private key to be used for decrypting the cryptographic key from a root seed managed within a trusted execution environment (TEE) different from the REE. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to obtain a partial key corresponding to the cryptographic key by decrypting the cryptographic key using the private key. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to perform an electronic signature for the transaction using the partial key.

[0008] An electronic device is described. The electronic device may include a memory storing instructions and including one or more storage media. The electronic device may include at least one processor including a processing circuit. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive a first user input that causes generation of a partial key to be used for an electronic signature through a software application executing based on a rich execution environment (REE). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to generate the partial key within a trusted execution environment (TEE) different from the REE in response to receiving the first user input. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to obtain an encryption key corresponding to the partial key by encrypting the partial key using a public key included in one of pairs of private keys and public keys derived from a root seed and managed within the TEE. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to store the encryption key in conjunction with the software application executing in the REE. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive, through the software application executing based on the REE, a second user input for electronically signing a transaction based on the encryption key.The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device, in response to receiving the second user input, to obtain a private key to be used for decrypting the cryptographic key from a root seed managed within the TEE. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to obtain the partial key by decrypting the cryptographic key using the private key. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to perform an electronic signature for the transaction using the partial key.

[0009] A method is provided. The method can be executed within an electronic device. The method can include receiving, through a software application running on a rich execution environment (REE), a first user input that causes the generation of a partial key to be used for an electronic signature. The method can include generating, in response to receiving the first user input, the partial key within a trusted execution environment (TEE) different from the REE. The method can include obtaining an encryption key corresponding to the partial key by encrypting the partial key using a public key included in one of pairs of private and public keys derived from a root seed and managed within the TEE. The method can include storing the encryption key in conjunction with the software application running on the REE. The method can include receiving, through the software application running on the REE, a second user input for an electronic signature of a transaction based on the encryption key. The method may include, in response to receiving the second user input, obtaining a private key to be used for decrypting the encryption key from a root seed managed within the TEE. The method may include obtaining the partial key by decrypting the encryption key using the private key. The method may include performing an electronic signature for the transaction using the partial key.

[0010] A non-transitory computer-readable storage medium is provided. The non-transitory computer-readable storage medium may store one or more programs. The one or more programs may include instructions that, when executed by an electronic device, cause the electronic device to receive a first user input, the first user input causing the generation of a partial key to be used for an electronic signature, through a software application running on a rich execution environment (REE). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to generate the partial key within a trusted execution environment (TEE) different from the REE, in response to receiving the first user input. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to obtain an encryption key corresponding to the partial key by encrypting the partial key using a public key included in one of pairs of private and public keys derived from a root seed and managed within the TEE. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to store the encryption key in conjunction with the software application executing on the REE. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to receive, through the software application executing on the REE, a second user input for electronic signature of a transaction based on the encryption key.The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to obtain, from a root seed managed within the TEE, a private key to be used for decrypting the encryption key, in response to receiving the second user input. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to obtain the partial key by decrypting the encryption key using the private key. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to perform an electronic signature for the transaction using the partial key.

[0011] Figure 1 illustrates an example of generating a partial key within an electronic device.

[0012] Figure 2 is a simplified block diagram of an exemplary electronic device.

[0013] Figure 3 is a flowchart illustrating an exemplary method for performing electronic signature.

[0014] Figure 4 illustrates an example of verifying a partial key.

[0015] Figure 5 illustrates an example of generating a partial key within a TEE.

[0016] Figure 6 illustrates an example of obtaining a private key and a public key using a hierarchical deterministic path.

[0017] Figure 7 is a flowchart illustrating an exemplary method for generating a partial key.

[0018] Figure 8 is a flowchart illustrating an exemplary method of using a partial key.

[0019] Figure 9 illustrates an example of performing an electronic signature for a transaction in response to receiving user input.

[0020] FIG. 10 is a block diagram of an electronic device within a network environment according to various embodiments.

[0021] Figure 1 illustrates an example of generating a partial key within an electronic device.

[0022] The electronic device (100) may be used to perform an electronic signature for a transaction. For example, the electronic device (100) may be used to perform a multi-party computation. For example, a multi-party computation technique may be described as a technique for logically dividing a private key for performing an electronic signature for a transaction. For example, a private key logically divided for performing an electronic signature may be described as a partial key. For example, the electronic device (100) may generate or obtain a partial key. For example, the electronic device (100) may include an REE (110) and a TEE (120). For example, the electronic device (100) may generate a partial key within the REE (110). For example, the electronic device (100) may include a partial key generation unit (130) for generating a partial key. For example, the electronic device (100) may include a key storage unit (140) for managing the generated partial key. For example, the key storage (140) may be included within the TEE (120) of the electronic device (100).

[0023] The TEE (120) may be described as a separate area from the REE (110). For example, the TEE (120) may be used for security. For example, the TEE (120) may store biometric information, payment information, or security documents. For example, the electronic device (100) may store biometric information, payment information, and / or security documents within the TEE (120). For example, the electronic device (100) may refrain from or block the transmission of information between the TEE (120) and the REE (110). For example, the REE (110) may be described as an execution environment having a first security level. For example, the TEE (120) may be described as an execution environment having a second security level higher than the first security level. For example, the electronic device (100) may be operated by separating the operating system into the REE (110) and the TEE (120). For example, the TEE (120) can be separated from the REE (110) through hardware constraints. For example, the TEE (120) can operate by being separated from the REE (110) through software. For example, a general operating system (e.g., a non-secure operating system) can run within the REE (110). For example, a secure operating system (OS) can run within the TEE (120). For example, the secure OS can be separated independently from the general OS. For example, the secure OS can be described as an environment that cannot be accessed by unauthorized programs or software applications. For example, a software application running within the TEE (120) can be described as a trusted application.

[0024] Partial keys, which are logically divided into individual keys for performing electronic signatures for transactions, may be stored in each of a plurality of electronic devices (not shown). For example, a multi-party computation technique may be described as a technique for performing a complete electronic signature for a transaction by partially performing an electronic signature for the transaction using each of the individual partial keys. For example, if the number of individual keys that are logically divided into one individual key is 5, each of the electronic devices including each of the individual partial keys may partially perform an electronic signature using each of the individual partial keys, thereby performing a complete electronic signature for the transaction. For example, based on the performance of a complete electronic signature for the transaction, the electronic device (100) may commit a block for the transaction to the blockchain or maintain a connection between the block and another block.

[0025] When the partial key generation unit (130) included in the electronic device (100) is located within the REE (110), the partial key generated by the partial key generation unit (130) may be located within the REE (110). For example, the partial key may be transmitted or snatched by an external electronic device (not shown). For example, the external electronic device may partially perform an electronic signature for a transaction using the transmitted (or snatched) partial key. The electronic device (100) may not recognize the transaction. The electronic signature for the transaction may not be recognized by the electronic device (100). The performance of the electronic signature for the transaction may not be intended by the user of the electronic device (100). In order to prevent the partial key from being snatched by the external electronic device, the electronic device (100) may be required to manage the partial key within the TEE (120). For example, the electronic device (100) can generate a partial key within the TEE (120). For example, the electronic device (100) can encrypt the partial key and store it within the REE (110).

[0026] For example, the electronic device (100) may include hardware components used to perform or execute the above operations. The hardware components are described and exemplified with reference to FIG. 2.

[0027] Figure 2 is a simplified block diagram of an exemplary electronic device.

[0028] Referring to FIG. 2, the electronic device (100) may include at least one processor (207), a communication circuit (205), a display (208), and a memory (206).

[0029] At least one processor (207) may include a hardware component for processing data using instructions stored in the memory (206). The hardware component for processing data may include a central processing unit (CPU) (e.g., including processing circuitry). The hardware component for processing data may include a graphics processing unit (GPU) (e.g., including processing circuitry).

[0030] At least one processor (207) may include one or more cores. For example, at least one processor (207) may have a multi-core processor structure such as a dual core, a quad core, or a hexa core.

[0031] The memory (206) may include hardware components for storing data and / or instructions input to and / or output from at least one processor (207). The memory (206) may include, for example, volatile memory such as random-access memory (RAM) and / or non-volatile memory such as read-only memory (ROM). The volatile memory may include, for example, at least one of dynamic RAM (DRAM), static RAM (SRAM), cache RAM, and pseudo SRAM (PSRAM). The non-volatile memory may include, for example, at least one of programmable ROM (PROM), erasable PROM (EPROM), electrically erasable PROM (EEPROM), flash memory, hard disk, compact disc, and embedded multimedia card (EMMC).

[0032] The communication circuit (205) may include hardware components for supporting transmission and / or reception of signals between the electronic device (100) and an external electronic device. The communication circuit (205) may include, for example, at least one of a modem, an antenna, and an optical / electronic (O / E) converter. The communication circuit (205) may support transmission and / or reception of signals based on various types of protocols, such as Ethernet, a local area network (LAN), a wide area network (WAN), wireless fidelity (WiFi), Bluetooth, Bluetooth low energy (BLE), zigbee, long term evolution (LTE), and 5G new radio (NR).

[0033] The display (208) can output visualized information. For example, the display (208) can output visualized information to the user under the control of at least one processor (207). The display (208) can include hardware components of the electronic device (100) used to display a screen. For example, the display (208) can include light-emitting elements and circuits (e.g., transistors) that control the light-emitting elements to emit light. For example, each of the light-emitting elements can include an organic light emitting diode (OLED) or a micro LED. However, the present invention is not limited thereto. For example, the display (208) can include a liquid crystal display (LCD).

[0034] At least one processor (207) may receive, via a software application running on the REE (110), a first user input that causes the generation of a partial key to be used for an electronic signature. For example, in response to receiving the first user input, the at least one processor (207) may generate the partial key within the TEE (120). For example, the at least one processor (207) may derive a private key and a public key from a root seed (e.g., the root seed (610) of FIG. 6). For example, the at least one processor (207) may obtain an encryption key by encrypting the partial key using the public key. For example, the at least one processor (207) may store the encryption key within the REE (110). For example, the at least one processor (207) may receive a second user input for an electronic signature of a transaction. For example, the at least one processor (207) may obtain a private key from the root seed. For example, at least one processor (207) can obtain a partial key by decrypting the encryption key using the private key. A key storage (e.g., key storage (526) of FIG. 5) can receive backup data generated at the time of generating the encryption key from the partial key from a multi-party computation software application (e.g., multi-party computation software application (516) of FIG. 5) via the communication circuit (205). For example, the communication circuit (205) can be used to transfer data between the multi-party computation software application (516) and the key storage (526). For example, at least one processor (207) can perform an electronic signature for a transaction using the partial key. The performance of the electronic signature is described and exemplified in more detail with reference to FIG. 3.

[0035] FIG. 3 is a flowchart illustrating an exemplary method for performing an electronic signature. This method may be executed by the electronic device (100) illustrated in FIG. 3 or by at least one processor (207) of the electronic device (100).

[0036] Referring to FIG. 3, at operation 310, at least one processor (207) may receive a first user input that causes generation of a partial key to be used for an electronic signature through a first software application (e.g., the first software application (510) of FIG. 5) running on the basis of the REE (110). The first user input may include user authentication. For example, the user authentication may include authentication using a fingerprint. For example, the user authentication may include authentication using a face. For example, the user authentication may include authentication using an iris. For example, the user authentication may include authentication using a password. For example, the user authentication may include authentication using a personal identification number (PIN). For example, the user authentication may include authentication using a photoplethysmography (PPG) sensor. Although examples of the user authentication are described above, embodiments of the present disclosure are not limited thereto.

[0037] For example, the first user input may include a user input for logging into a server (not shown) corresponding to the first software application. For example, the electronic device (100) may log into or access the server through the first software application. For example, by logging into (or accessing) the server, the electronic device (100) may manage partial keys and encryption keys or perform electronic signatures for transactions.

[0038] In operation 320, at least one processor (207) may generate a partial key within a TEE (120) different from the REE (110) in response to receiving the first user input. For example, at least one processor (207) may generate the partial key within the TEE (120) using a multi-party computation software application (e.g., the multi-party computation software application (516) of FIG. 5). The partial key may be used in a multi-party computation technique. For example, the partial key may be used to perform a partial electronic signature for performing a complete electronic signature of a transaction.

[0039] In operation 330, at least one processor (207) may obtain an encryption key corresponding to a partial key by encrypting the partial key using a public key included in any one of pairs of a private key (e.g., the first private key (460) of FIG. 4) and a public key (e.g., the first public key (465) of FIG. 4) derived from a root seed (e.g., the root seed (610) of FIG. 6) managed within the TEE (120). For example, the at least one processor (207) may derive, generate, or obtain the private key and the public key from the root seed located within the TEE (120). For example, the at least one processor (207) may obtain the private key and the public key corresponding to the hierarchical deterministic path from the root seed using the hierarchical deterministic path. For example, a hierarchical deterministic path can be described as a path for deriving a pair of private keys and public keys from a root seed (e.g., the root seed (610) of FIG. 6). For example, a first private key (e.g., the first private key (460) of FIG. 4) and a first public key paired with the first private key (e.g., the first public key (465) of FIG. 4) can depend on the hierarchical deterministic path. For example, the first private key and the first public key can correspond to the hierarchical deterministic path.

[0040] For example, a hierarchical deterministic path can be determined using an identifier of a multi-party computation software application (e.g., a multi-party computation software application (516) of FIG. 5) corresponding to a partial key. For example, there may be multiple partial keys used in the multi-party computation technique. For example, there may be multiple multi-party computation software applications corresponding to each of the partial keys. For example, at least one processor (207) can label an identifier for each of the multi-party computation software applications. For example, at least one processor (207) can determine or identify a hierarchical deterministic path using the labeled identifier for each of the multi-party computation software applications. For example, at least one processor (207) can generate, obtain, or identify a hierarchical deterministic path using the number of the multi-party computation software applications. For example, at least one processor (207) can generate a hierarchical deterministic path using the labeled identifier and the number of the multi-party computation software applications. For example, at least one processor (207) may obtain a private key and a public key pair corresponding to the hierarchical deterministic path from the root seed. However, the present invention is not limited thereto. At least one processor (207) may generate a hierarchical deterministic path using information that can distinguish each of the multi-party computation software applications (e.g., the first multi-party computation software application (516-1) to the Nth multi-party computation software application (516-N) of FIG. 5). For example, at least one processor (207) may use identification data for the electronic device (100).

[0041] At least one processor (207) can verify a public key used to encrypt a partial key. For example, at least one processor (207) can obtain identification information indicating a hierarchical deterministic path used to derive the public key from the root seed. At least one processor (207) can verify the public key based on whether the identification information matches the hierarchical deterministic path. For example, at least one processor (207) can wrap the public key derived from the root seed. For example, at least one processor (207) can obtain identification information by unwrapping the wrapped public key. For example, the identification information can include information regarding the hierarchical deterministic path for deriving the public key from the root seed. For example, the identification information can indicate the hierarchical deterministic path. For example, at least one processor (207) can determine whether the identification information matches the hierarchical deterministic path used when deriving the public key from the root seed.

[0042] In operation 340, at least one processor (207) may store the encryption key by linking with a first software application running in the REE (110) (e.g., the first software application (510) of FIG. 5). For example, at least one processor (207) may store the encryption key that links with the first software application running in the REE (110). For example, at least one processor (207) may store the encryption key within the REE (110). The encryption key may be described as a partial key encrypted using a public key. The electronic device (100) may enhance security by storing the encryption key within the REE (110). For example, the security of the electronic device (100) may be enhanced by storing the encryption key within the REE (110). For example, if an external electronic device steals the encryption key, it may be impossible for the external electronic device to perform an electronic signature for a transaction using the encryption key. For example, since the external electronic device does not store the private key, it may be impossible to decrypt the encryption key. For example, since the private key for decrypting the encryption key is located within the TEE (120), the private key can be securely managed within the TEE (120). For example, the electronic device (100) can prevent the private key from being stored within the REE (110) by generating or using the private key for decrypting the encryption key within the TEE (120).

[0043] In operation 350, at least one processor (207) may receive a second user input for an electronic signature of a transaction based on the encryption key through the first software application running on the basis of the REE (110). For example, the electronic device (100) may request the reception of the second user input to perform an electronic signature for the transaction. For example, the second user input may be requested to perform an electronic signature for the transaction. For example, the second user input may include user authentication. For example, the second user input may include a user authentication different from the user authentication included in the first user input. For example, the electronic device (100) may perform an electronic signature for the transaction by receiving the second user input after receiving the first user input. For example, the authentication method corresponding to the first user input and the authentication method corresponding to the second user input may be the same method. However, the present invention is not limited thereto. The authentication method corresponding to the first user input and the authentication method corresponding to the second user input may be different methods.

[0044] In operation 360, at least one processor (207) may, in response to receiving a second user input, obtain a private key (e.g., the first private key (460) of FIG. 6) to be used for decrypting the encryption key from a root seed (e.g., the root seed (610) of FIG. 6) managed within the TEE (120). For example, at least one processor (207) may obtain or derive the private key from the root seed using a hierarchical deterministic path. The private key may be a pair with a public key used for encryption of the partial key in operation 330. For example, the hierarchical deterministic path of the private key and the hierarchical deterministic path of the public key may be common. For example, the hierarchical deterministic path of the private key and the hierarchical deterministic path of the public key may be the same. For example, at least one processor (207) may obtain a pair of a public key and a private key from the root seed according to the hierarchical deterministic path. For example, at least one processor (207) can obtain or derive a pair of private keys and public keys by computing a function from the root seed based on a hierarchical deterministic path.

[0045] In operation 370, at least one processor (207) can obtain a partial key by decrypting the encryption key using the private key. For example, at least one processor (207) can decrypt an encryption key encrypted by a public key using a private key corresponding to the public key. For example, a key storage (e.g., key storage (526) of FIG. 5) within the electronic device (100) can obtain a partial key by decrypting the encryption key using the private key. At least one processor (207) can transmit a request for decryption of an encryption key from a multi-party computation software application (e.g., multi-party computation software application (516) of FIG. 5) to the key storage via the communication circuit (205).

[0046] For example, at least one processor (207) may identify the partial key used at the time of generating the encryption key from the partial key, from backup data generated at the time of generating the encryption key. For example, at least one processor (207) may verify the partial key obtained by decrypting the encryption key using the backup data. The verification of the partial key is described and illustrated in more detail with reference to FIG. 4.

[0047] Figure 4 illustrates an example of verifying a partial key.

[0048] Referring to FIG. 4, the state (410) can be described as a state in which backup data (470) is obtained by encrypting the partial key (440) using the first public key (465). At least one processor (207) can identify the partial key (440) used at the time of generating the encryption key (450) from the partial key (440), from the backup data (470) generated at the time of generating the encryption key (450) from the partial key (440). For example, at least one processor (207) can verify the partial key (440) obtained by decrypting the encryption key (450) using the backup data (470). For example, in operation 330, at least one processor (207) can generate backup data (470) for the partial key (440) while obtaining the encryption key (450) corresponding to the partial key (440) by encrypting the partial key (440) using the public key. The backup data (470) may include data regarding the partial key (440). For example, at least one processor (207) may use the backup data (470) to identify the partial key (440) corresponding to the backup data (470).

[0049] State (420) can be described as a state in which a partial key (440) is obtained by decrypting an encryption key (450) using a first private key (460). State (430) can be described as a state in which the obtained partial key (440) is verified using backup data (470). For example, at least one processor (207) can verify the partial key (440) obtained by decrypting the encryption key (450) by comparing the partial key (440) obtained by decrypting the encryption key (450) with the partial key (440) identified from the backup data (470). For example, since the partial key (440) generated in operation 320 is required to be identical to the partial key (440) obtained in operation 370, at least one processor (207) may be required to perform an operation of comparing the partial key (440) obtained by decrypting the backup data (470) and the encryption key (450) for verification. For example, the electronic device (100) can improve the security quality by comparing the partial key (440) obtained by decrypting the backup data (470) and the encryption key (450). For example, the electronic device (100) can prevent the partial key (440) from being forged or stolen based on the comparison.

[0050] Referring back to FIG. 3 , at operation 380, at least one processor (207) may perform an electronic signature for a transaction using the partial key (440). For example, at least one processor (207) may partially perform an electronic signature to perform a complete electronic signature for the transaction using the partial key (440). For example, the partial key (440) may be used in a multi-party computation technique. For example, the partial key (440) may be generated by logically dividing a key for performing an electronic signature for the transaction. For example, a complete electronic signature for the transaction may be performed when the number of partial electronic signatures by each of the partial keys (440) stored in each of the external electronic devices exceeds a threshold number. For example, at least one processor (207) may transmit a signal to another electronic device (not shown) via the communication circuit (205) indicating that an electronic signature for the transaction is performed using the partial key (440).

[0051] At least one processor (207) can generate a partial key (440) within the TEE (120). At least one processor (207) can store an encryption key (450) encrypted by a public key within the REE (110). The generation of the partial key (440) and the storage of the encryption key (450) are described and exemplified in more detail with reference to FIG. 5.

[0052] Figure 5 illustrates an example of generating a partial key within a TEE.

[0053] Referring to FIG. 5, an electronic device (100) may include an REE (110) and a TEE (120). The electronic device (100) may execute a first software application (510) within the REE (110). For example, the first software application (510) may be referred to as a wallet app or a wallet software application. For example, the first software application (510) may include a software application for providing a payment function. For example, the first software application (510) may include a software application that provides a function for performing an electronic signature for a transaction. For example, the electronic device (100) may execute a second software application (520) within the REE (110).

[0054] The first software application (510) may be connected to a multi-party operation software development kit (SDK) (e.g., the first multi-party operation SDK (512-1) to the Nth multi-party operation SDK (512-N)) (N is a natural number greater than or equal to 2). For example, the multi-party operation SDK (512) may be used to connect the first software application (510) running in the REE (110) and the multi-party operation software application (516) running in the TEE (120) (e.g., the Nth multi-party operation software application (516-N)). For example, the SDK may be described as a set of software development tools for creating software applications for a specific platform of the electronic device (100). For example, the SDK may include source code, development tools, an emulator, and a library for creating a software application for a specific platform. For example, the multiparty operation SDK (512) may include a software application created by the SDK to perform a multiparty operation technique. For example, the multiparty operation SDK (512) may include a multiparty operation engine interface (e.g., an N-th multiparty operation engine interface (514-N)) (514). For example, the first multiparty operation engine interface (514-1) may be executed within the first multiparty operation SDK (512-1). For example, the N-th multiparty operation engine interface (514-N) may be executed within the N-th multiparty operation SDK (512-N). For example, the first multiparty operation SDK (512-1) may correspond to the first multiparty operation software application (516-1). For example, the N-th multiparty operation SDK (512-N) may correspond to the N-th multiparty operation software application (516-N). For example, the multi-party operation SDK (512) may send a request to the multi-party operation software application (516) to generate a partial key (440).For example, a multi-party computation software application (516) may generate a partial key (440) within the TEE (120) based on receiving the request.

[0055] For example, a multi-party computation software application (516) running within a TEE (120) may be described as a trusted application (TA). For example, a trusted application may include one or more applications that may perform functions such as digital rights management (DRM), security, payment, or biometric authentication. For example, at least one processor (207) may generate a partial key (440) using the multi-party computation software application (516). For example, at least one processor (207) may generate a partial key (440) by logically dividing a key to perform an electronic signature for a transaction using a first multi-party computation software application (516-1). For example, at least one processor (207) may generate a partial key different from the partial key (440) corresponding to the first multi-party computation software application (516-1) by logically dividing a key to perform an electronic signature for a transaction using an Nth multi-party computation software application (516-N). For example, the algorithm for generating a partial key (440) corresponding to the first multi-party computation software application (516-1) and the algorithm for generating another partial key corresponding to the Nth multi-party computation software application (516-N) may be different algorithms. However, the present invention is not limited thereto. For example, the algorithm for generating a partial key (440) corresponding to the first multi-party computation software application (516-1) and the algorithm for generating another partial key corresponding to the Nth multi-party computation software application (516-N) may be the same algorithm. For example, the first multi-party computation software application (516-1) may include a multi-party computation engine wrapper (MPC engine wrapper) (518-1).For example, the first multi-party computation software application (516-1) may include a multi-party computation engine (MPC engine) (519-1). For example, the Nth multi-party computation software application (516-N) may include a multi-party computation engine wrapper (MPC engine wrapper) (518-N). For example, the Nth multi-party computation software application (516-1) may include a multi-party computation engine (MPC engine) (519-N). For example, the multi-party computation engine wrapper (518-1) may be described as a software application for configuring the multi-party computation engine (519-1) to run. For example, at least one processor (207) may generate a partial key (440) by logically dividing a key to perform an electronic signature for a transaction using the multi-party computation engine (519-1).

[0056] At least one processor (207) may execute a second software application (520) within the REE (110). The second software application (520) may be referred to as a blockchain app or a blockchain software application. Referring to FIG. 5 , the first software application (510) and the second software application (520) are illustrated as being distinct, but the present disclosure is not limited thereto. For example, the first software application (510) and the second software application (520) may be the same software application. For example, the first software application (510) and the second software application (520) may be included in a single software application. For example, the first software application (510) may include the second software application (520).

[0057] The second software application (520) may include a platform SDK (522). For example, the second software application (520) may include a key store SDK (524). For example, the platform SDK (522) may include a software application created by the SDK to connect the second software application (520) and the key store SDK (524). For example, the key store SDK (524) may include a software application created by the SDK to connect the second software application (520) and the key store (526). For example, at least one processor (207) may use the key store SDK (524) to transmit a request to the key store (526) to derive a public key and a private key from a root seed (e.g., the root seed (610) of FIG. 6) via the communication circuit (205). For example, at least one processor (207) may derive a public key and a private key from the root seed based on receiving the request using the key store (526).

[0058] The derivation of private and public keys from the above root seed is described and illustrated in more detail with reference to FIG. 6.

[0059] Figure 6 illustrates an example of obtaining a private key and a public key using a hierarchical deterministic path.

[0060] Referring to FIG. 6, the electronic device (100) may include a root seed (610). For example, the electronic device (100) may manage the root seed (610) within the TEE (120). For example, the root seed (610) may be used to derive a private key and a public key. For example, the root seed (610) may be used to derive the private key and the public key based on a hierarchical deterministic path. For example, at least one processor (207) may derive the private key and the public key using the root seed (610) and the hierarchical deterministic path. For example, the root seed (610) may be described as a bit string of a specified length (e.g., 512 bits). For example, the root seed (610) may be obtained through an operation based on a specified number of mnemonics and / or user codes (e.g., 12). For example, the root seed (610) can be generated by inputting a mnemonic symbol and / or a user code into a key stretching function (e.g., PBKDF2 (password-based key derivation function version 2)). For example, the root seed (610) can be generated by inputting a hash value of the mnemonic symbol and / or the user code into a key stretching function. For example, the root seed (610) can be generated by inputting a result value of repeating a hash algorithm (e.g., HMAC (hash-based message authentication code)-SHA (secure hash algorithm)-512) for the mnemonic symbol and / or the user code a specified number of times into the key stretching function.

[0061] A hierarchical deterministic path may be described as a path for deriving a private key and a public key from a root seed (610). For example, the root seed (610) may derive each of its child keys (not shown) based on each of its parent keys (not shown) derived from the root seed (610). For example, the parent key may be identified by inputting the root seed (610) into a designated function (e.g., child key derivation function (CKD), HMAC-SHA-512). For example, a hierarchical deterministic path may be described as a path for identifying one of the parent keys derived from the root seed (610) and then identifying a child key derived from the identified parent key. For example, a first hierarchical deterministic path may be determined using an identifier of a first multi-party computation software application (516-1). For example, an Nth hierarchical deterministic path may be determined using an identifier of an Nth multi-party computation software application (516-N). For example, the first layer deterministic path can be determined using the number of multi-party computation software applications (516) within the electronic device (100). For example, the Nth layer deterministic path can be determined using the number of multi-party computation software applications (516) within the electronic device (100). For example, the layer deterministic path can be determined using the identifier of the multi-party computation software application (516) and the number of multi-party computation software applications (516).

[0062] At least one processor (207) can obtain or derive a private key and a public key through a key store (526) within the TEE (120). For example, at least one processor (207) can obtain a first private key (460) and a first public key (465) using a first layer deterministic path. For example, at least one processor (207) can obtain a second private key (630) and a first public key (465) using a second layer deterministic path that is different from the first layer deterministic path. For example, the first private key (460) and the first public key (465) can correspond to the first layer deterministic path. For example, the second private key (630) and the second public key (635) can correspond to the second layer deterministic path. For example, at least one processor (207) can obtain or derive a first private key (460) and a second private key (630) different from the first private key (460) from one root seed (610) based on the difference between the first layer deterministic path and the second layer deterministic path.

[0063] For example, the first public key (465) can be identified based on the first private key (460). For example, at least one processor (207) can identify the first public key (465) by applying elliptic curve cryptography (ECC) to the first private key (460). Since the first public key (465) and the first private key (460) are paired, they can be used in an asymmetric encryption technique.

[0064] At least one processor (207) can encrypt a partial key (440) generated using a first public key (465). Encryption using the public key is described and exemplified in more detail with reference to FIG. 7.

[0065] FIG. 7 is a flowchart illustrating an exemplary method for generating a partial key. This method may be executed by the electronic device (100) illustrated in FIG. 3 or by at least one processor (207) of the electronic device (100).

[0066] Referring to FIG. 7, at operation 710, at least one processor (207) may transmit a request for provision of a first public key (465) from a first software application (510) to a second software application (520) based on user input that causes generation of a partial key (440).

[0067] At operation 712, at least one processor (207) may forward the request from the second software application (520) to the platform SDK (522).

[0068] At operation 720, at least one processor (207) may generate a first layer deterministic path for deriving a first public key (465) via the platform SDK (522). For example, the platform SDK (522) may generate the first layer deterministic path using a number of multi-party computation software applications including the first multi-party computation software application (516-1) stored in the electronic device (100) and / or an identifier for the first multi-party computation software application (516-1). For example, the at least one processor (207) may generate the first layer deterministic path in the platform SDK (522) based on a request to derive the first public key (465) using the first layer deterministic path identified based on the first software application (510).

[0069] At operation 722, at least one processor (207) may transmit a request from the platform SDK (522) to the key storage SDK (524) to derive a first public key (465) using a first layer deterministic path.

[0070] At operation 724, at least one processor (207) may transmit a request from the key store SDK (524) to the key store (526) to derive a first public key (465) using a first layer deterministic path.

[0071] At operation 730, at least one processor (207) may derive a key pair comprising a first public key (465) and a first private key (460) from a root seed (610) located within the TEE (120) using a first layer deterministic path. For example, at least one processor (207) may derive a key pair comprising a first public key (465) and a first private key (460) from a key store (526) based on a request to derive the first public key (465) using a first layer deterministic path identified based on the platform SDK (522).

[0072] In operation 740, at least one processor (207) may wrap a first public key (465) in a key storage (526). By wrapping the first public key (465), the at least one processor (207) may obtain a wrapped first public key (465). For example, the at least one processor (207) may identify a first layer deterministic path using the wrapped first public key (465).

[0073] At operation 742, at least one processor (207) may transfer the wrapped first public key (465) from the key store (526) to the key store SDK (742).

[0074] At operation 744, at least one processor (207) may transfer the wrapped first public key (465) from the key storage SDK (524) to the platform SDK (522).

[0075] At operation 746, at least one processor (207) may transmit the wrapped first public key (465) from the platform SDK (522) to the second software application (520).

[0076] At operation 748, at least one processor (207) may transmit the wrapped first public key (465) from the second software application (520) to the first software application (510).

[0077] At operation 750, at least one processor (207) may transmit a request to generate a partial key (440) from a first software application (510) to a multi-party operation SDK (512).

[0078] At operation 752, at least one processor (207) may forward the request from the multi-party operation SDK (512) to the multi-party operation software application (516).

[0079] At operation 760, at least one processor (207) can identify a source of the wrapped first public key (465). For example, the at least one processor (207) can identify a first layer deterministic path used to derive the first public key (465) from the root seed (610) using the wrapped first public key (465). For example, the at least one processor (207) can obtain identification information indicating the first layer deterministic path used to derive the first public key (465) from the root seed (610) by unwrapping the wrapped first public key (465). The at least one processor (207) can verify the first public key (465) by comparing the identification information with the first layer deterministic path.

[0080] At operation 770, at least one processor (207) may generate a partial key (440) via a multi-party computation software application (516) within the TEE (120). For example, the at least one processor (207) may generate the partial key (440) by logically partitioning a key. For example, the at least one processor (207) may generate the partial key (440) by mathematically partitioning a key for an electronic signature. For example, the at least one processor (207) may generate the partial key (440) in the multi-party computation software application (516) based on a request to generate the identified partial key (440) based on the first software application (510).

[0081] In operation 780, at least one processor (207) may generate an encryption key (450) by encrypting the generated partial key (440) using the first public key (465) within the TEE (120). For example, at least one processor (207) may generate the encryption key (450) through a multi-party computation software application (516) within the TEE (120). For example, while generating the encryption key (450), at least one processor (207) may generate backup data (470) for the partial key (440). For example, the backup data (470) may be used to verify the partial key (440). For example, the encryption key (450) may be described as a partial key (440) encrypted by a public key.

[0082] At operation 782, at least one processor (207) may transmit an encryption key (450) from a multi-party computation software application (516) to a multi-party computation SDK (512).

[0083] At operation 784, at least one processor (207) may transmit an encryption key (450) from a multi-party operation SDK (512) to a first software application (510).

[0084] At operation 790, at least one processor (207) may store an encryption key (450) within the REE (110). For example, at least one processor (207) may manage the encryption key (450) via a first software application (510).

[0085] At least one processor (207) may decrypt the encryption key (450) into a partial key (440) for performing electronic signature of the transaction. The decryption of the encryption key (450) and the use of the partial key (440) are described and exemplified in more detail with reference to FIG. 8.

[0086] FIG. 8 is a flowchart illustrating an exemplary method using a partial key. This method may be executed by the electronic device (100) illustrated in FIG. 3 or by at least one processor (207) of the electronic device (100).

[0087] Referring to FIG. 8, at operation 810, at least one processor (207) may transmit a request from a first software application (510) to a multi-party operation SDK (512) to perform an electronic signature for a transaction using an encryption key (450).

[0088] At operation 812, at least one processor (207) may forward the request from the multi-party operation SDK to the multi-party operation software application (516).

[0089] At operation 820, at least one processor (207) may transmit a request from a first software application (510) to a second software application (520) to prepare decryption of an encryption key (450).

[0090] At operation 822, at least one processor (207) may forward the request from the second software application (520) to the platform SDK (522).

[0091] At operation 830, at least one processor (207) may generate or obtain a hierarchical deterministic path. For example, operation 830 may correspond to operation 720. For example, at least one processor (207) may generate or obtain a hierarchical deterministic path from the platform SDK (522) based on a request to prepare decryption of an identified encryption key (450) based on the first software application (510).

[0092] At operation 832, at least one processor (207) may transmit a request from the platform SDK (522) to the key storage SDK (524) to prepare decryption of an encryption key (450) using a hierarchical deterministic path.

[0093] At operation 834, at least one processor (207) may transmit a request from the key store SDK (524) to the key store (526) to prepare decryption of the encryption key (450) using a hierarchical deterministic path.

[0094] At operation 840, at least one processor (207) may derive or obtain a key pair of a private key (e.g., a first private key (460)) and a public key (e.g., a first public key (465)) from a root seed (610) via a key store (526). For example, operation 840 may correspond to operation 730. For example, at least one processor (207) may derive or generate a key pair including a private key and a public key from a key store (526) based on a request to prepare decryption of an encryption key (450) using a hierarchical deterministic path identified based on the platform SDK (522).

[0095] At operation 842, at least one processor (207) may transmit a request to decrypt an encryption key (450) from a multi-party computing software application (516) to a key store (526). For example, at least one processor (207) may transmit the request from the multi-party computing software application (516) to the key store (526) via the communication circuit (205). For example, a first trusted application within the TEE (120) may utilize the communication circuit (205) to communicate signals, information, or data with a second trusted application within the TEE (120).

[0096] At operation 850, at least one processor (207) may obtain a partial key (440) by decrypting an encryption key (450) using a private key. For example, at least one processor (207) may obtain a partial key (440) from a key storage (526) by decrypting an encryption key (450) using the private key based on a request to decrypt an identified encryption key (450) based on a multi-party computation software application (516). For example, at least one processor (207) may verify the partial key (440) using backup data (470). For example, at least one processor (207) may identify a partial key (440) that was used at the time of generating the backup data (470) from the backup data (470). For example, at least one processor (207) can verify the obtained partial key (440) by decrypting the encryption key (450) by comparing the obtained partial key (440) with the identified partial key (440) from the backup data (470). However, this is not limited thereto. At least one processor (207) can skip or bypass verifying the obtained partial key (440) by decrypting the encryption key (450) using the backup data (470).

[0097] At operation 852, at least one processor (207) may communicate the partial key (440) from the key store (526) to the multi-party computation software application (516). For example, the at least one processor (207) may communicate the partial key (440) from the key store (526) within the TEE (120) to the multi-party computation software application (516). For example, the at least one processor (207) may communicate the partial key (440) from the key store (526) to the multi-party computation software application (516) via the communication circuit (205). For example, since the key store (526) and the multi-party computation software application (516) are located within the TEE (120), the at least one processor (207) may utilize the communication circuit (205) to communicate the partial key (440).

[0098] At operation 860, at least one processor (207) may perform an electronic signature for a transaction using the partial key (440). For example, based on a request to perform an electronic signature for a transaction using the partial key (440) identified based on the first software application (510), the at least one processor (207) may perform an electronic signature for the transaction in a multi-party computation software application (516). For example, since the partial key (440) is used in a multi-party computation technique, the at least one processor (207) may partially perform an electronic signature for the transaction using the partial key (440). For example, the electronic signature for the transaction may be completely performed based on the electronic signature for the transaction being partially performed from each of a plurality of electronic devices in which each of the partial keys (440) for electronic signature for the transaction is stored. For example, based on the completely performed electronic signature, the block including the transaction may be connected to another block or committed to the blockchain.

[0099] At least one processor (207) may display a screen for receiving user input on a display (208) of the electronic device (100). At least one processor (207) may receive user input while displaying the screen on the display (208). The reception of the user input is described and illustrated in more detail with reference to FIG. 9.

[0100] Figure 9 illustrates an example of performing an electronic signature for a transaction in response to receiving user input.

[0101] Referring to FIG. 9, at least one processor (207) may display a screen (910) for logging into a first software application (510) (or electronic device (100)) on the display (208). For example, the screen (910) may include an area (915) for receiving user input. For example, the at least one processor (207) may receive user input through the area (915) to identify whether the user of the electronic device (100) is authorized. For example, the area (915) may be described as an area for touching a user's fingerprint. For example, the at least one processor (207) may authenticate a user using the area (915).

[0102] At least one processor (207) may display a screen (e.g., screen (920), screen (930)) for performing an electronic signature for a transaction based on user authentication from screen (910) on the display (208). For example, screen (920) may be described as a screen for performing an electronic signature for a first transaction. For example, screen (930) may be described as a screen for performing an electronic signature for a second transaction different from the first transaction. For example, screen (920) may include an area (925) for receiving a user input. For example, screen (930) may include an area (935) for receiving a user input. For example, at least one processor (207) may perform an electronic signature using a partial key (440) corresponding to the first transaction by receiving a user input from area (925). For example, at least one processor (207) may perform an electronic signature using a partial key (440) corresponding to a second transaction by receiving a user input from the area (935). The first partial key (e.g., partial key (440)) for performing an electronic signature for the first transaction may be different from the second partial key for performing an electronic signature for the second transaction.

[0103] The electronic device (100) can manage the partial key (440) by encrypting or decrypting the partial key (440) using the private key and the public key derived from the root seed (610). For example, the electronic device (100) can manage the first partial key (440) corresponding to the first multi-party computation software application (516-1) and the N-th partial key (440) corresponding to the N-th multi-party computation software application (516-N) using the first software application (510) and the second software application (520). For example, after receiving a user input to log in to a server corresponding to the first multi-party computation software application (516-1), the electronic device (100) can skip receiving another user input to log in to another server corresponding to the N-th multi-party computation software application (516-N). For example, the electronic device (100) can improve user convenience by reducing the number of times it receives user input. For example, since the root seed (610) is used by at least two of the first multi-party operation software application (516-1) to the Nth multi-party operation software application (516-N), the number of user inputs required to perform two or more electronic signatures can be reduced. For example, the security quality of the electronic device (100) can be improved by generating or using a partial key (440) for performing an electronic signature for a transaction within the TEE (120).

[0104] FIG. 10 is a block diagram of an electronic device within a network environment according to various embodiments.

[0105] FIG. 10 is a block diagram of an electronic device (1001) within a network environment (1000) according to various embodiments. Referring to FIG. 10, in the network environment (1000), the electronic device (1001) may communicate with the electronic device (1002) via a first network (1098) (e.g., a short-range wireless communication network), or may communicate with at least one of the electronic device (1004) or the server (1008) via a second network (1099) (e.g., a long-range wireless communication network). According to one embodiment, the electronic device (1001) may communicate with the electronic device (1004) via the server (1008). According to one embodiment, the electronic device (1001) may include a processor (1020), a memory (1030), an input module (1050), an audio output module (1055), a display module (1060), an audio module (1070), a sensor module (1076), an interface (1077), a connection terminal (1078), a haptic module (1079), a camera module (1080), a power management module (1088), a battery (1089), a communication module (1090), a subscriber identification module (1096), or an antenna module (1097). In some embodiments, the electronic device (1001) may omit at least one of these components (e.g., the connection terminal (1078)), or may have one or more other components added. In some embodiments, some of these components (e.g., sensor module (1076), camera module (1080), or antenna module (1097)) may be integrated into a single component (e.g., display module (1060)).

[0106] The processor (1020) may, for example, execute software (e.g., a program (1040)) to control at least one other component (e.g., a hardware or software component) of the electronic device (1001) connected to the processor (1020) and perform various data processing or operations. According to one embodiment, as at least a part of the data processing or operations, the processor (1020) may store commands or data received from other components (e.g., a sensor module (1076) or a communication module (1090)) in a volatile memory (1032), process the commands or data stored in the volatile memory (1032), and store result data in a non-volatile memory (1034). According to one embodiment, the processor (1020) may include a main processor (1021) (e.g., a central processing unit or an application processor) or an auxiliary processor (1023) (e.g., a graphics processing unit, a neural processing unit (NPU), an image signal processor, a sensor hub processor, or a communication processor) that can operate independently or together with the main processor (1021). For example, when the electronic device (1001) includes the main processor (1021) and the auxiliary processor (1023), the auxiliary processor (1023) may be configured to use less power than the main processor (1021) or to be specialized for a given function. The auxiliary processor (1023) may be implemented separately from the main processor (1021) or as a part thereof.

[0107] The auxiliary processor (1023) may control at least a portion of functions or states associated with at least one component (e.g., the display module (1060), the sensor module (1076), or the communication module (1090)) of the electronic device (1001), for example, on behalf of the main processor (1021) while the main processor (1021) is in an inactive (e.g., sleep) state, or together with the main processor (1021) while the main processor (1021) is in an active (e.g., application execution) state. In one embodiment, the auxiliary processor (1023) (e.g., an image signal processor or a communication processor) may be implemented as a part of another functionally related component (e.g., a camera module (1080) or a communication module (1090)). In one embodiment, the auxiliary processor (1023) (e.g., a neural network processing unit) may include a hardware structure specialized for processing artificial intelligence models. The artificial intelligence models may be generated through machine learning. This learning can be performed, for example, on the electronic device (1001) itself where the artificial intelligence model is executed, or can be performed through a separate server (e.g., server (1008)). The learning algorithm can include, for example, supervised learning, unsupervised learning, semi-supervised learning, or reinforcement learning, but is not limited to the examples described above. The artificial intelligence model can include multiple artificial neural network layers.The artificial neural network may be one of a deep neural network (DNN), a convolutional neural network (CNN), a recurrent neural network (RNN), a restricted Boltzmann machine (RBM), a deep belief network (DBN), a bidirectional recurrent deep neural network (BRDNN), a deep Q-network, or a combination of two or more of the above, but is not limited to the examples described above. In addition to, or alternatively to, a hardware structure, an artificial intelligence model may include a software structure.

[0108] The memory (1030) can store various data used by at least one component (e.g., the processor (1020) or the sensor module (1076)) of the electronic device (1001). The data can include, for example, software (e.g., the program (1040)) and input data or output data for commands related thereto. The memory (1030) can include volatile memory (1032) or non-volatile memory (1034).

[0109] The program (1040) may be stored as software in memory (1030) and may include, for example, an operating system (1042), middleware (1044), or an application (1046).

[0110] The input module (1050) can receive commands or data to be used in a component of the electronic device (1001) (e.g., a processor (1020)) from an external source (e.g., a user) of the electronic device (1001). The input module (1050) can include, for example, a microphone, a mouse, a keyboard, a key (e.g., a button), or a digital pen (e.g., a stylus pen).

[0111] The audio output module (1055) can output audio signals to the outside of the electronic device (1001). The audio output module (1055) can include, for example, a speaker or a receiver. The speaker can be used for general purposes, such as multimedia playback or recording playback. The receiver can be used to receive incoming calls. In one embodiment, the receiver can be implemented separately from the speaker or as part of the speaker.

[0112] The display module (1060) can visually provide information to an external party (e.g., a user) of the electronic device (1001). The display module (1060) may include, for example, a display, a holographic device, or a projector, and a control circuit for controlling the device. In one embodiment, the display module (1060) may include a touch sensor configured to detect a touch, or a pressure sensor configured to measure the intensity of a force generated by the touch.

[0113] The audio module (1070) can convert sound into an electrical signal, or vice versa, convert an electrical signal into sound. According to one embodiment, the audio module (1070) can acquire sound through the input module (1050), output sound through the sound output module (1055), or an external electronic device (e.g., electronic device (1002)) (e.g., speaker or headphone) directly or wirelessly connected to the electronic device (1001).

[0114] The sensor module (1076) can detect the operating status (e.g., power or temperature) of the electronic device (1001) or the external environmental status (e.g., user status) and generate an electrical signal or data value corresponding to the detected status. According to one embodiment, the sensor module (1076) can include, for example, a gesture sensor, a gyro sensor, a barometric pressure sensor, a magnetic sensor, an acceleration sensor, a grip sensor, a proximity sensor, a color sensor, an IR (infrared) sensor, a biometric sensor, a temperature sensor, a humidity sensor, or an illuminance sensor.

[0115] The interface (1077) may support one or more designated protocols that may be used to directly or wirelessly connect the electronic device (1001) to an external electronic device (e.g., the electronic device (1002)). In one embodiment, the interface (1077) may include, for example, a high definition multimedia interface (HDMI), a universal serial bus (USB) interface, an SD card interface, or an audio interface.

[0116] The connection terminal (1078) may include a connector through which the electronic device (1001) may be physically connected to an external electronic device (e.g., the electronic device (1002)). In one embodiment, the connection terminal (1078) may include, for example, an HDMI connector, a USB connector, an SD card connector, or an audio connector (e.g., a headphone connector).

[0117] The haptic module (1079) can convert electrical signals into mechanical stimuli (e.g., vibration or movement) or electrical stimuli that a user can perceive through tactile or kinesthetic sensations. In one embodiment, the haptic module (1079) can include, for example, a motor, a piezoelectric element, or an electrical stimulation device.

[0118] The camera module (1080) can capture still images and videos. In one embodiment, the camera module (1080) may include one or more lenses, image sensors, image signal processors, or flashes.

[0119] The power management module (1088) can manage power supplied to the electronic device (1001). According to one embodiment, the power management module (1088) can be implemented as, for example, at least a part of a power management integrated circuit (PMIC).

[0120] A battery (1089) may power at least one component of the electronic device (1001). In one embodiment, the battery (1089) may include, for example, a non-rechargeable primary battery, a rechargeable secondary battery, or a fuel cell.

[0121] The communication module (1090) may support the establishment of a direct (e.g., wired) communication channel or a wireless communication channel between the electronic device (1001) and an external electronic device (e.g., electronic device (1002), electronic device (1004), or server (1008)), and the performance of communication through the established communication channel. The communication module (1090) may operate independently from the processor (1020) (e.g., application processor) and may include one or more communication processors that support direct (e.g., wired) communication or wireless communication. According to one embodiment, the communication module (1090) may include a wireless communication module (1092) (e.g., a cellular communication module, a short-range wireless communication module, or a global navigation satellite system (GNSS) communication module) or a wired communication module (1094) (e.g., a local area network (LAN) communication module, or a power line communication module). Among these communication modules, a corresponding communication module can communicate with an external electronic device (1004) via a first network (1098) (e.g., a short-range communication network such as Bluetooth, wireless fidelity (WiFi) direct, or infrared data association (IrDA)) or a second network (1099) (e.g., a long-range communication network such as a legacy cellular network, a 5G network, a next-generation communication network, the Internet, or a computer network (e.g., a LAN or WAN)). These various types of communication modules can be integrated into a single component (e.g., a single chip) or implemented as multiple separate components (e.g., multiple chips). The wireless communication module (1092) can verify or authenticate the electronic device (1001) within a communication network such as the first network (1098) or the second network (1099) by using subscriber information (e.g., an international mobile subscriber identity (IMSI)) stored in the subscriber identification module (1096).

[0122] The wireless communication module (1092) can support 5G networks and next-generation communication technologies following the 4G network, such as NR access technology (new radio access technology). NR access technology can support high-speed transmission of high-capacity data (eMBB (enhanced mobile broadband)), minimizing terminal power and connecting multiple terminals (mMTC (massive machine type communications)), or high reliability and low latency (URLLC (ultra-reliable and low-latency communications)). The wireless communication module (1092) can support, for example, a high-frequency band (e.g., mmWave band) to achieve a high data transmission rate. The wireless communication module (1092) may support various technologies for securing performance in a high-frequency band, such as beamforming, massive multiple-input and multiple-output (MIMO), full dimensional MIMO (FD-MIMO), array antenna, analog beam-forming, or large scale antenna. The wireless communication module (1092) may support various requirements specified in the electronic device (1001), an external electronic device (e.g., the electronic device (1004)), or a network system (e.g., the second network (1099)). According to one embodiment, the wireless communication module (1092) may support a peak data rate (e.g., 20 Gbps or more) for eMBB realization, a loss coverage (e.g., 164 dB or less) for mMTC realization, or a U-plane latency (e.g., 0.5 ms or less for downlink (DL) and uplink (UL), or 1 ms or less for round trip) for URLLC realization.

[0123] The antenna module (1097) can transmit or receive signals or power to or from an external device (e.g., an external electronic device). In one embodiment, the antenna module (1097) may include an antenna including a radiator formed of a conductor or a conductive pattern formed on a substrate (e.g., a PCB). In one embodiment, the antenna module (1097) may include a plurality of antennas (e.g., an array antenna). In this case, at least one antenna suitable for a communication method used in a communication network, such as the first network (1098) or the second network (1099), may be selected from the plurality of antennas by, for example, the communication module (1090). A signal or power may be transmitted or received between the communication module (1090) and an external electronic device via the at least one selected antenna. In some embodiments, in addition to the radiator, another component (e.g., a radio frequency integrated circuit (RFIC)) may be additionally formed as a part of the antenna module (1097).

[0124] According to various embodiments, the antenna module (1097) may form a mmWave antenna module. In one embodiment, the mmWave antenna module may include a printed circuit board, an RFIC disposed on or adjacent a first side (e.g., a bottom side) of the printed circuit board and capable of supporting a designated high frequency band (e.g., a mmWave band), and a plurality of antennas (e.g., an array antenna) disposed on or adjacent a second side (e.g., a top side or a side side) of the printed circuit board and capable of transmitting or receiving signals in the designated high frequency band.

[0125] At least some of the above components can be interconnected and exchange signals (e.g., commands or data) with each other via a communication method between peripheral devices (e.g., a bus, GPIO (general purpose input and output), SPI (serial peripheral interface), or MIPI (mobile industry processor interface)).

[0126] According to one embodiment, commands or data may be transmitted or received between the electronic device (1001) and an external electronic device (1004) via a server (1008) connected to a second network (1099). Each of the external electronic devices (1002 or 1004) may be the same or a different type of device as the electronic device (1001). According to one embodiment, all or part of the operations executed in the electronic device (1001) may be executed in one or more of the external electronic devices (1002, 1004, or 1008). For example, when the electronic device (1001) is to perform a certain function or service automatically or in response to a request from a user or another device, the electronic device (1001) may, instead of or in addition to executing the function or service itself, request one or more external electronic devices to perform the function or at least a part of the service. One or more external electronic devices that receive the request may execute at least a portion of the requested function or service, or an additional function or service related to the request, and transmit the result of the execution to the electronic device (1001). The electronic device (1001) may process the result as is or additionally and provide it as at least a portion of a response to the request. For this purpose, cloud computing, distributed computing, mobile edge computing (MEC), or client-server computing technology may be used, for example. The electronic device (1001) may provide an ultra-low latency service by using distributed computing or mobile edge computing, for example. In another embodiment, the external electronic device (1004) may include an Internet of Things (IoT) device. The server (1008) may be an intelligent server utilizing machine learning and / or a neural network.According to one embodiment, an external electronic device (1004) or server (1008) may be included within the second network (1099). The electronic device (1001) may be applied to intelligent services (e.g., smart homes, smart cities, smart cars, or healthcare) based on 5G communication technology and IoT-related technology.

[0127] An electronic device as described above may include a memory (206) storing instructions. The electronic device may include at least one processor (207). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive user input for electronic signature of a transaction based on an encryption key (450) via a software application (510) executing on the basis of the REE (110). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to, in response to receiving the user input, obtain a private key (460) to be used for decrypting the encryption key (450) from a root seed (610) managed within a TEE (120) (trusted execution environment) different from the REE (110). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to obtain a partial key (440) corresponding to the encryption key (450) by decrypting the encryption key (450) using the private key (460). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to perform an electronic signature for the transaction using the partial key (440).

[0128] In one embodiment, the user input may include a first user input. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive a second user input, which causes the software application (510) executing based on the REE (110) and managing cryptographic keys (450) to generate the partial key (440) to be used for electronic signature. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to generate the partial key (440) within the TEE (120) in response to receiving the second user input. The above instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to obtain the encryption key (450) corresponding to the partial key (440) by encrypting the partial key (440) using a public key (465) included in one of the pairs of a private key (460) and a public key (465) derived from the root seed (610) and managed within the TEE (120).

[0129] According to one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to store the obtained encryption key (450) within the REE (110).

[0130] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to obtain identification information indicative of a hierarchical deterministic path used to derive the public key (465) from the root seed (610). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to verify the public key (465) based on whether the identification information and the hierarchical deterministic path match.

[0131] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to identify, from backup data (470) generated at the time of generating the encryption key (450) from the partial key (440), the partial key (440) that was used at that time. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to verify the partial key (440) obtained by decrypting the encryption key (450) by comparing the partial key (440) obtained by decrypting the encryption key (450) with the partial key (440) identified from the backup data (470).

[0132] In one embodiment, the private key (460) may be obtained from the root seed (610) within the TEE (120) using a hierarchical deterministic path determined using an identifier of another software application (510) (516) corresponding to the partial key (440).

[0133] According to one embodiment, the partial key (440) is generated by logically dividing the private key (460) for a complete electronic signature for the transaction to perform multi-party computation, and can be used to perform a partial electronic signature for the transaction.

[0134] As described above, the method performed by the electronic device (100) may include an operation of receiving, through a software application (510) running on the basis of the REE (110), a user input for an electronic signature of a transaction based on an encryption key (450). The method may include an operation of, in response to receiving the user input, obtaining a private key (460) to be used for decrypting the encryption key (450) from a root seed (610) managed within a TEE (120) (trusted execution environment) different from the REE (110). The method may include an operation of decrypting the encryption key (450) using the private key (460) to obtain a partial key (440) corresponding to the encryption key (450). The method may include an operation of performing an electronic signature for the transaction using the partial key (440).

[0135] In one embodiment, the user input may include a first user input. The method may include receiving, through the software application (510) that is executed based on the REE (110) and manages encryption keys (450), a second user input that causes generation of the partial key (440) to be used for electronic signature. The method may include generating, within the TEE (120), the partial key (440) in response to receiving the second user input. The method may include obtaining the encryption key (450) corresponding to the partial key (440) by encrypting the partial key (440) using a public key (465) included in one of pairs of a private key (460) and a public key (465) derived from the root seed (610) and managed within the TEE (120).

[0136] According to one embodiment, the method may include an operation of storing the obtained encryption key (450) within the REE (110).

[0137] In one embodiment, the method may include obtaining identification information indicating a hierarchical deterministic path used to derive the public key (465) from the root seed (610). The method may include verifying the public key (465) based on whether the identification information and the hierarchical deterministic path match.

[0138] According to one embodiment, the method may include an operation of identifying the partial key (440) used at the time of generating the encryption key (450) from the partial key (440), from backup data (470) generated at the time of generating the encryption key (450). The method may include an operation of verifying the partial key (440) obtained by decrypting the encryption key (450) by comparing the partial key (440) obtained by decrypting the encryption key (450) and the partial key (440) identified from the backup data (470).

[0139] In one embodiment, the private key (460) may be obtained from the root seed (610) within the TEE (120) using a hierarchical deterministic path determined using an identifier of another software application (510) (516) corresponding to the partial key (440).

[0140] According to one embodiment, the partial key (440) is generated by logically dividing the private key (460) for a complete electronic signature for the transaction to perform multi-party computation, and can be used to perform a partial electronic signature for the transaction.

[0141] In a computer-readable storage medium having one or more programs stored thereon, as described above, the one or more programs may include instructions that, when executed by the electronic device (100), cause the electronic device to receive, through a software application (510) executed based on the REE (110), a user input for electronic signature of a transaction based on an encryption key (450). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to, in response to receiving the user input, obtain, from a root seed (610) managed within a TEE (120) (trusted execution environment) different from the REE (110), a private key (460) to be used for decrypting the encryption key (450). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to obtain a partial key (440) corresponding to the encryption key (450) by decrypting the encryption key (450) using the private key (460). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to perform an electronic signature for the transaction using the partial key (440).

[0142] In one embodiment, the user input may include a first user input. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to receive a second user input that causes the software application (510) that runs based on the REE (110) and manages cryptographic keys (450) to generate the partial key (440) to be used for electronic signature. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to generate the partial key (440) within the TEE (120) in response to receiving the second user input. The one or more programs, when executed by the electronic device, may include instructions that cause the electronic device to obtain the encryption key (450) corresponding to the partial key (440) by encrypting the partial key (440) using a public key (465) included in one of the pairs of a private key (460) and a public key (465) derived from the root seed (610), and managed within the TEE (120).

[0143] According to one embodiment, the one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to store the acquired encryption key (450) within the REE (110).

[0144] According to one embodiment, the one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to obtain identification information indicating a hierarchical deterministic path used to derive the public key (465) from the root seed (610). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to verify the public key (465) based on whether the identification information and the hierarchical deterministic path match.

[0145] According to one embodiment, the one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to identify, from backup data (470) generated at the time of generating the encryption key (450) from the partial key (440), the partial key (440) used at that time. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to verify the partial key (440) obtained by decrypting the encryption key (450) by comparing the partial key (440) obtained by decrypting the encryption key (450) with the partial key (440) identified from the backup data (470).

[0146] In one embodiment, the private key (460) may be obtained from the root seed (610) within the TEE (120) using a hierarchical deterministic path determined using an identifier of another software application (510) (516) corresponding to the partial key (440).

[0147] According to one embodiment, the partial key (440) is generated by logically dividing the private key (460) for a complete electronic signature for the transaction to perform multi-party computation, and can be used to perform a partial electronic signature for the transaction.

[0148] An electronic device as described above may include a memory (206) storing instructions. The electronic device may include at least one processor (207). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive a first user input that causes generation of a partial key (440) to be used for electronic signature via a software application (510) executing based on a rich execution environment (REE) (110). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to generate the partial key (440) within a trusted execution environment (TEE) (120) different from the REE (110), in response to receiving the first user input. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to obtain an encryption key (450) corresponding to the partial key (440) by encrypting the partial key (440) using a public key (465) included in one of pairs of a private key (460) and a public key (465) derived from a root seed (610) and managed within the TEE (120). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to store the encryption key (450) that is linked to the software application (510) executing in the REE (110).The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive, through the software application (510) executing based on the REE (110), a second user input for electronic signature of a transaction based on the encryption key (450). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device, in response to receiving the second user input, to obtain, from the root seed (610) managed within the TEE (120), a private key (460) to be used for decrypting the encryption key (450). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to obtain the partial key (440) by decrypting the encryption key (450) using the private key (460). The above instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to perform an electronic signature for the transaction using the partial key (440).

[0149] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to obtain identification information indicative of a hierarchical deterministic path used to derive the public key (465) from the root seed (610). The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to verify the public key (465) based on whether the identification information and the hierarchical deterministic path match.

[0150] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to identify, from backup data (470) generated at the time of generating the encryption key (450) from the partial key (440), the partial key (440) that was used at that time. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to verify the partial key (440) obtained by decrypting the encryption key (450) by comparing the partial key (440) obtained by decrypting the encryption key (450) with the partial key (440) identified from the backup data (470).

[0151] In one embodiment, the private key (460) may be obtained from the root seed (610) within the TEE (120) using a hierarchical deterministic path determined using an identifier of another software application (510) (516) corresponding to the partial key (440).

[0152] According to one embodiment, the partial key (440) is generated by logically dividing the private key (460) for a complete electronic signature for the transaction to perform multi-party computation, and can be used to perform a partial electronic signature for the transaction.

[0153] The method performed by the electronic device (100), as described above, may include receiving, through a software application (510) running on the basis of a rich execution environment (REE) (110), a first user input that causes generation of a partial key (440) to be used for an electronic signature. The method may include generating, in response to receiving the first user input, the partial key (440) within a trusted execution environment (TEE) (120) different from the REE (110). The method may include obtaining an encryption key (450) corresponding to the partial key (440) by encrypting the partial key (440) using a public key (465) included in one of pairs of a private key (460) and a public key (465) derived from a root seed (610) and managed within the TEE (120). The method may include an operation of storing the encryption key (450) that is linked to the software application (510) running on the REE (110). The method may include an operation of receiving, through the software application (510) running on the basis of the REE (110), a second user input for an electronic signature of a transaction based on the encryption key (450). The method may include an operation of obtaining, in response to receiving the second user input, a private key (460) to be used for decrypting the encryption key (450) from the root seed (610) managed within the TEE (120). The method may include an operation of obtaining the partial key (440) by decrypting the encryption key (450) using the private key (460). The method may include an operation of performing an electronic signature for the transaction using the partial key (440).

[0154] In one embodiment, the method may include obtaining identification information indicating a hierarchical deterministic path used to derive the public key (465) from the root seed (610). The method may include verifying the public key (465) based on whether the identification information and the hierarchical deterministic path match.

[0155] According to one embodiment, the method may include an operation of identifying the partial key (440) used at the time of generating the encryption key (450) from the partial key (440), from backup data (470) generated at the time of generating the encryption key (450). The method may include an operation of verifying the partial key (440) obtained by decrypting the encryption key (450) by comparing the partial key (440) obtained by decrypting the encryption key (450) and the partial key (440) identified from the backup data (470).

[0156] In one embodiment, the private key (460) may be obtained from the root seed (610) within the TEE (120) using a hierarchical deterministic path determined using an identifier of another software application (510) (516) corresponding to the partial key (440).

[0157] According to one embodiment, the partial key (440) is generated by logically dividing the private key (460) for a complete electronic signature for the transaction to perform multi-party computation, and can be used to perform a partial electronic signature for the transaction.

[0158] In a computer-readable storage medium having one or more programs stored thereon, as described above, the one or more programs may include instructions that, when executed by an electronic device (100), cause the electronic device to receive a first user input that causes generation of a partial key (440) to be used for an electronic signature through a software application (510) that is executed based on a rich execution environment (REE) (110). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to generate the partial key (440) within a trusted execution environment (TEE) (120) that is different from the REE (110), in response to receiving the first user input. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to obtain an encryption key (450) corresponding to the partial key (440) by encrypting the partial key (440) using a public key (465) included in one of pairs of a private key (460) and a public key (465) derived from a root seed (610) and managed within the TEE (120). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to store the encryption key (450) that is linked to the software application (510) executed in the REE (110). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to receive a second user input for electronic signature of a transaction based on the encryption key (450) via the software application (510) executing based on the REE (110).The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to obtain, from the root seed (610) managed within the TEE (120), a private key (460) to be used for decrypting the encryption key (450), in response to receiving the second user input. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to obtain the partial key (440) by decrypting the encryption key (450) using the private key (460). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to perform an electronic signature for the transaction using the partial key (440).

[0159] According to one embodiment, the one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to obtain identification information indicating a hierarchical deterministic path used to derive the public key (465) from the root seed (610). The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to verify the public key (465) based on whether the identification information and the hierarchical deterministic path match.

[0160] According to one embodiment, the one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to identify, from backup data (470) generated at the time of generating the encryption key (450) from the partial key (440), the partial key (440) used at that time. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to verify the partial key (440) obtained by decrypting the encryption key (450) by comparing the partial key (440) obtained by decrypting the encryption key (450) with the partial key (440) identified from the backup data (470).

[0161] In one embodiment, the private key (460) may be obtained from the root seed (610) within the TEE (120) using a hierarchical deterministic path determined using an identifier of another software application (510) (516) corresponding to the partial key (440).

[0162] According to one embodiment, the partial key (440) is generated by logically dividing the private key (460) for a complete electronic signature for the transaction to perform multi-party computation, and can be used to perform a partial electronic signature for the transaction.

[0163] The devices described above may be implemented as hardware components, software components, and / or a combination of hardware components and software components. For example, the devices and components described in the embodiments may be implemented using one or more general-purpose computers or special-purpose computers, such as a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA), a programmable logic unit (PLU), a microprocessor, or any other device capable of executing instructions and responding to them. The processing device may execute an operating system (OS) and one or more software applications running on the operating system. The processing device may also access, store, manipulate, process, and generate data in response to the execution of the software. For ease of understanding, the processing device is sometimes described as being used alone; however, one of ordinary skill in the art will recognize that the processing device may include multiple processing elements and / or multiple types of processing elements. For example, a processing unit may include multiple processors, or a processor and a controller. Other processing configurations, such as parallel processors, are also possible.

[0164] Software may include a computer program, code, instructions, or a combination of one or more of these, which may configure a processing device to perform a desired operation or may independently or collectively command the processing device. The software and / or data may be embodied in any type of machine, component, physical device, computer storage medium, or device for interpretation by the processing device or for providing instructions or data to the processing device. The software may also be distributed over networked computer systems and stored or executed in a distributed manner. The software and data may be stored on one or more computer-readable recording media.

[0165] The method according to the embodiment may be implemented in the form of program commands that can be executed through various computer means and recorded on a computer-readable medium. In this case, the medium may be one that continuously stores a computer-executable program or one that temporarily stores it for execution or download. In addition, the medium may be various recording or storage means in the form of a single or multiple hardware combinations, and is not limited to a medium directly connected to a computer system, but may also be distributed over a network. Examples of the medium may include magnetic media such as hard disks, floppy disks, and magnetic tapes, optical recording media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, and those configured to store program commands, including ROM, RAM, and flash memory. In addition, examples of other media may include recording or storage media managed by app stores that distribute applications, sites that supply or distribute various software, servers, etc.

[0166] Although the embodiments described above have been described by way of limited examples and drawings, those skilled in the art will appreciate that various modifications and variations can be made based on the above teachings. For example, appropriate results can still be achieved even if the described techniques are performed in a different order than described, and / or components of the described systems, structures, devices, circuits, etc. are combined or combined in a different manner than described, or are replaced or substituted with other components or equivalents.

[0167] Therefore, other implementations, other embodiments, and equivalents of the claims are also within the scope of the claims described below. According to one embodiment, the method according to the various embodiments disclosed in the present document may be provided as included in a computer program product. The computer program product may be traded as a commodity between a seller and a buyer. The computer program product may be distributed in the form of a machine-readable storage medium (e.g., compact disc read only memory (CD-ROM)), or may be distributed online (e.g., downloaded or uploaded) via an application store (e.g., Play Store™) or directly between two user devices (e.g., smart phones). In the case of online distribution, at least a portion of the computer program product may be at least temporarily stored or temporarily generated in a machine-readable storage medium, such as the memory of a manufacturer's server, an application store's server, or a relay server.

[0168] According to various embodiments, each component (e.g., a module or a program) of the above-described components may include one or more entities, and some of the entities may be separated and placed in other components. According to various embodiments, one or more components or operations of the aforementioned components may be omitted, or one or more other components or operations may be added. Alternatively or additionally, a plurality of components (e.g., a module or a program) may be integrated into a single component. In such a case, the integrated component may perform one or more functions of each of the plurality of components identically or similarly to those performed by the corresponding component among the plurality of components prior to the integration. According to various embodiments, the operations performed by a module, program, or other component may be executed sequentially, in parallel, iteratively, or heuristically, or one or more of the operations may be executed in a different order, omitted, or one or more other operations may be added.

Claims

1. In an electronic device (100), A memory storing instructions and including one or more storage media; and At least one processor comprising processing circuitry, The above instructions, when individually or collectively executed by the at least one processor, Receiving user input for electronic signature of a transaction based on an encryption key (450) through a software application (510) running on the basis of a rich execution environment (REE) (110), In response to receiving the user input, a private key (460) to be used for decrypting the encryption key (450) is obtained from a root seed (610) managed within a TEE (120) (trusted execution environment) other than the REE (110), By decrypting the encryption key (450) using the private key (460), a partial key (440) corresponding to the encryption key (450) is obtained, and To perform an electronic signature for the transaction using the above partial key (440), causing the above electronic device (100), Electronic device (100).

2. In claim 1, the user input is: The first user input is, The above instructions, when individually or collectively executed by the at least one processor, Receiving a second user input that causes the generation of the partial key (440) to be used for electronic signature through the software application (510) that runs based on the REE (110) and manages the encryption keys (450), In response to receiving the second user input, generating the partial key (440) within the TEE (120), and By encrypting the partial key (440) using a public key (465) included in one of the pairs of a private key (460) and a public key (465) derived from the root seed (610) and managed within the TEE (120), the encryption key (450) corresponding to the partial key (440) is obtained. Further causing the above electronic device (100), Electronic device (100).

3. In claim 2, The above instructions, when individually or collectively executed by the at least one processor, To store the obtained encryption key (450) within the REE (110), causing the above electronic device (100), Electronic device (100).

4. In claim 2, The above instructions, when individually or collectively executed by the at least one processor, Obtaining identification information indicating a hierarchical deterministic path used to derive the public key (465) from the root seed (610), and To verify the public key (465) based on whether the above identification information and the hierarchical deterministic path match, causing the above electronic device (100), Electronic device (100).

5. In claim 1, The above instructions, when individually or collectively executed by the at least one processor, From the backup data (470) generated at the time of generating the encryption key (450) from the above partial key (440), the partial key (440) used at the time is identified, and By comparing the partial key (440) obtained by decrypting the encryption key (450) and the partial key (440) identified from the backup data (470), the partial key (440) obtained by decrypting the encryption key (450) is verified. causing the above electronic device (100), Electronic device (100).

6. In claim 1, the private key (460) is Obtained using a hierarchical deterministic path determined using the identifier of another software application (516) corresponding to the partial key (440) from the root seed (610) within the TEE (120). Electronic device (100).

7. In claim 1, the partial key (440) is A private key (460) is generated by logically dividing the private key (460) for a complete electronic signature for the transaction to perform multi-party computation, and is used to perform a partial electronic signature for the transaction. Electronic device (100).

8. In an electronic device (100), A memory storing instructions and including one or more storage media; and At least one processor comprising processing circuitry, The above instructions, when individually or collectively executed by the at least one processor, Receiving a first user input that causes the generation of a partial key (440) to be used for electronic signature through a software application (510) running on the basis of REE (110) (rich execution environment), In response to receiving the first user input, the partial key (440) is generated within a TEE (120) (trusted execution environment) different from the REE (110), By encrypting the partial key (440) using a public key (465) included in one of the pairs of a private key (460) and a public key (465) derived from a root seed (610) and managed within the TEE (120), an encryption key (450) corresponding to the partial key (440) is obtained, Store the encryption key (450) linked to the software application (510) running in the above REE (110), Through the software application (510) running on the basis of the above REE (110), a second user input for electronic signature of a transaction based on the encryption key (450) is received, In response to receiving the second user input, a private key (460) to be used for decrypting the encryption key (450) is obtained from the root seed (610) managed within the TEE (120), By decrypting the encryption key (450) using the private key (460), the partial key (440) is obtained, and To perform an electronic signature for the transaction using the above partial key (440), causing the above electronic device (100), Electronic device (100).

9. In claim 8, The above instructions, when individually or collectively executed by the at least one processor, Obtaining identification information indicating a hierarchical deterministic path used to derive the public key (465) from the root seed (610), and To verify the public key (465) based on whether the above identification information and the hierarchical deterministic path match, causing the above electronic device (100), Electronic device (100).

10. In claim 8, The above instructions, when individually or collectively executed by the at least one processor, From the backup data (470) generated at the time of generating the encryption key (450) from the above partial key (440), the partial key (440) used at the time is identified, and By comparing the partial key (440) obtained by decrypting the encryption key (450) and the partial key (440) identified from the backup data (470), the partial key (440) obtained by decrypting the encryption key (450) is verified. causing the above electronic device (100), Electronic device (100).

11. In claim 8, the private key (460) is Obtained using a hierarchical deterministic path determined using the identifier of another software application (516) corresponding to the partial key (440) from the root seed (610) within the TEE (120). Electronic device (100).

12. In claim 8, the partial key (440) is A private key (460) is generated by logically dividing the private key (460) for a complete electronic signature for the transaction to perform multi-party computation, and is used to perform a partial electronic signature for the transaction. Electronic device (100).

13. In a non-transitory computer-readable storage medium storing one or more programs, the one or more programs are: When executed by an electronic device (100), Receiving user input for electronic signature of a transaction based on an encryption key (450) through a software application (510) running on the basis of REE (110), In response to receiving the user input, a private key (460) to be used for decrypting the encryption key (450) is obtained from a root seed (610) managed within a TEE (120) (trusted execution environment) other than the REE (110), By decrypting the encryption key (450) using the private key (460), a partial key (440) corresponding to the encryption key (450) is obtained, and To perform an electronic signature for the transaction using the above partial key (440), Including instructions that cause the above electronic device (100), Non-transitory computer-readable storage medium.

14. In claim 13, the user input is: The first user input is, The above one or more programs, when executed by the electronic device (100), Receiving a second user input that causes the generation of the partial key (440) to be used for electronic signature, through a software application (510) that runs based on the above REE (110) and manages the encryption keys (450), In response to receiving the second user input, generating the partial key (440) within the TEE (120), and By encrypting the partial key (440) using a public key (465) included in one of the pairs of a private key (460) and a public key (465) derived from the root seed (610) and managed within the TEE (120), the encryption key (450) corresponding to the partial key (440) is obtained. Including instructions that cause the above electronic device (100), Non-transitory computer-readable storage medium.

15. In claim 14, The above one or more programs, when executed by the electronic device (100), To store the obtained encryption key (450) within the REE (110), Including instructions that cause the above electronic device (100), Non-transitory computer-readable storage medium.

Images