High-security method for negotiating temporary session key based on national secret algorithm

Abstract

The invention relates to the technical field of commercial password detection methods, and discloses a high-security method for negotiating a temporary session key based on a national secret algorithm, and the commercial password detection method comprises the following steps: initialization and identity authentication: two communication parties generate an SM2 public and private key pair, and the identity is verified through a digital certificate and an SM2 signature; temporary key negotiation: generating a shared key point based on an SM2 key exchange protocol; session key derivation: generating a temporary session key by using an SM3 hash algorithm; key confirmation and encrypted communication: verifying the key through an SM4 algorithm and encrypting communication data; according to the high-security method for negotiating the temporary session key based on the national secret algorithm, efficient key negotiation of both communication parties in an unsecure channel is realized through an SM2 key exchange protocol, an SM3 hash algorithm and an SM4 symmetric encryption algorithm. The method combines digital certificate authentication, dynamic random numbers and timestamps, has forward security, replay attack resistance and man-in-the-middle attack resistance, and is suitable for high-security scenes such as finance and government affairs.

Description

Technical Field

[0001] The present invention relates to the field of commercial password detection methods, and in particular to a high-security method for negotiating temporary session keys based on a national cryptographic algorithm. Background Art

[0002] With the widespread adoption of network communications, data transmission security has become a core issue in information security. Traditional key agreement protocols, such as Diffie-Hellman (DH) and Elliptic Curve Diffie-Hellman (ECDH), may be at risk of quantum computing attacks in certain scenarios. Furthermore, the application of international cryptographic algorithms is restricted in certain countries and regions. However, China's national cryptographic algorithms (such as SM2, SM3, and SM4) are widely used in sensitive areas such as finance and government affairs due to their independent controllability and high security.

[0003] Existing key agreement schemes based on national secret algorithms usually rely on the SM2 public key encryption algorithm for key exchange, but have the following problems: 1. The negotiation process is complex and computationally expensive, making it difficult to meet the needs of low-power devices. 2. Lack of comprehensive defense mechanisms against man-in-the-middle attacks and replay attacks; 3. The generation of temporary session keys lacks dynamism and forward security, and long-term use may lead to the risk of key leakage. Therefore, an efficient, dynamic, and highly secure temporary session key negotiation method based on national encryption algorithms is urgently needed to meet the security requirements of modern network communications. Summary of the Invention

[0004] In view of the deficiencies of the existing technology, the present invention provides a high-security method for negotiating temporary session keys based on the national encryption algorithm, which solves the existing problems.

[0005] The present invention provides the following technical solution: a highly secure method for negotiating temporary session keys based on a national cryptographic algorithm, applicable to two communicating parties (hereinafter referred to as initiator A and responder B) negotiating temporary session keys in an insecure channel. The following are the specific steps of the method: Step 1: Initialization and identity authentication; 1. Parameter initialization: The communicating parties A and B each generate a public-private key pair based on the SM2 algorithm: Initiator A: private key (dA), public key (PA = dA cdot G) (G is the base point of the SM2 elliptic curve); Responder B: Private key (dB), public key (PB = dB cdot G); both parties obtain each other's public key and digital certificate through a trusted third party (such as a CA) to ensure identity trust; The system predefines SM2 curve parameters, SM3 hash function and SM4 encryption algorithm parameters; 2. Identity authentication: A generates a random number (rA) and the current timestamp (TA), and uses the private key (dA) to perform SM2 signature on ({rA || TA}) to obtain the signature (SigA); A sends ({rA, TA, SigA, CertA}) (where (CertA) is A's digital certificate) to B. After receiving it, B: uses the public key (PA) in (CertA) to verify the legitimacy of (SigA); checks whether (TA) is within the valid time window (to prevent replay attacks); verifies the randomness of (rA) (to prevent forgery). B generates (rB), (TB), (SigB), (CertB) in a similar way and sends them to A. A performs the same verification. Step 2: Temporary key negotiation 1. Temporary key generation: A generates a random number (kA) and calculates a temporary public key (RA = kA cdot G); B generates a random number (kB) and calculates a temporary public key (RB = kB cdot G); A sends (RA) to B, and B sends (RB) to A; 2. Shared key calculation: A calculates the shared key point according to the SM2 key exchange protocol: K{AB} = kA cdot (hcdot PB + RB), where (h) is the SM2 curve cofactor; B is similarly calculated: K{BA} = kB cdot (h cdot PA + RA). Due to the mathematical properties of the SM2 algorithm, ( K{AB} = K{BA} ), both parties obtain the same shared key point ( K ). The bit string ( K{raw} ) is extracted from the x- and y-coordinates of ( K ). 3. Session key derivation: A and B use the SM3 hash algorithm to hash (K{raw}), (rA), (rB), (TA), (TB): Ks = SM3(K{raw} || rA || rB || TA || TB), (Ks) is the final temporary session key; Step 3: Key confirmation and encrypted communication: 1. Key confirmation: A uses the SM4 algorithm to encrypt a predefined message (such as "KeyConfirmed") with (Ks), obtains the ciphertext (CA), and sends it to B; B uses (Ks) to decrypt (CA) and verify the correctness of the message; if correct, B sends the ciphertext (CB) to A in a similar manner; A decrypts (CB) to verify the correctness of the message and confirm that the key negotiation is successful; 2. Encrypted communication: Both parties use (Ks) as the symmetric key of SM4 to encrypt and decrypt subsequent communication data. After each session ends, (Ks) is automatically destroyed and a new key is renegotiated for the next session. Step 4: Security Enhancement Mechanism: 1. Forward security: Temporary keys (kA) and (kB) are destroyed immediately after the session ends. Even if the long-term private key (dA) or (dB) is leaked, the historical session key cannot be traced back. 2. Anti-replay attack: Timestamp (TA), (TB) and random numbers (rA), (rB) ensure the uniqueness of the message and prevent replay attacks; 3. Anti-man-in-the-middle attack: Digital certificates and SM2 signature verification ensure the identity of both parties in communication is credible and prevent forgery; 4. Dynamic key update: The key validity period can be set according to communication needs, and new key negotiation can be triggered regularly or on demand.

[0006] Preferably, the commercial password detection method comprises the following steps: Step 1: Initialization and identity authentication: The communicating parties generate an SM2 public-private key pair and verify their identities through digital certificates and SM2 signatures. Step 2: Temporary key negotiation: Generate a shared key point based on the SM2 key exchange protocol; Step 3: Session key derivation: Generate a temporary session key using the SM3 hash algorithm. Step 4: Key confirmation and encrypted communication: Use the SM4 algorithm to verify the key and encrypt the communication data.

[0007] Preferably, a random number and a timestamp are introduced into the identity authentication step to prevent replay attacks.

[0008] Preferably, the temporary key negotiation uses a one-time random number to ensure forward security.

[0009] Preferably, the session key is derived from the shared key point and the dynamic parameters using an SM3 hash algorithm.

[0010] Preferably, it is suitable for resource-constrained devices, supporting efficient computing and low-power operation.

[0011] Compared to existing technologies, this invention offers the following advantages: A highly secure method for negotiating temporary session keys based on a national cryptographic algorithm: This method utilizes the SM2 key exchange protocol, the SM3 hash algorithm, and the SM4 symmetric encryption algorithm to achieve efficient key negotiation between communicating parties over an insecure channel. This method, combined with digital certificate authentication, dynamic random numbers, and timestamps, offers forward security, resistance to replay attacks, and man-in-the-middle attacks, making it suitable for high-security scenarios such as finance and government affairs. DETAILED DESCRIPTION

[0012] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the embodiments of the present invention. Obviously, the embodiments described are only part of the embodiments of the present invention, not all of the embodiments. Some components may be omitted, enlarged or reduced, and do not represent the dimensions of the actual product. It is understandable to those skilled in the art that some well-known structures, components and their descriptions may be omitted. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0013] In the description of the present invention, it should also be noted that, unless otherwise clearly specified and limited, the terms "setting" and "connection" should be understood in a broad sense. For example, it can be a fixed connection, a movable connection, a detachable connection, or an integral connection. It can be a mechanical connection or an electrical connection. It can be directly connected or indirectly connected through an intermediate medium. It can be internal communication between two components. For ordinary technicians in this field, the specific meanings of the above terms in the present invention can be understood according to specific circumstances. The following will refer to the detailed description of the present application in conjunction with the embodiments.

[0014] A highly secure method for negotiating temporary session keys based on a national cryptographic algorithm is applicable to two communicating parties (hereinafter referred to as initiator A and responder B) negotiating temporary session keys over an insecure channel. The following are the specific steps of this method: Step 1: Initialization and identity authentication; 1. Parameter initialization: The communicating parties A and B each generate a public-private key pair based on the SM2 algorithm: Initiator A: private key (dA), public key (PA = dA cdot G) (G is the base point of the SM2 elliptic curve); Responder B: Private key (dB), public key (PB = dB cdot G); both parties obtain each other's public key and digital certificate through a trusted third party (such as a CA) to ensure identity trust; The system predefines SM2 curve parameters, SM3 hash function and SM4 encryption algorithm parameters; 2. Identity authentication: A generates a random number (rA) and the current timestamp (TA), and uses the private key (dA) to perform SM2 signature on ({rA || TA}) to obtain the signature (SigA); A sends ({rA, TA, SigA, CertA}) (where (CertA) is A's digital certificate) to B. After receiving it, B: uses the public key (PA) in (CertA) to verify the legitimacy of (SigA); checks whether (TA) is within the valid time window (to prevent replay attacks); verifies the randomness of (rA) (to prevent forgery). B generates (rB), (TB), (SigB), (CertB) in a similar way and sends them to A. A performs the same verification. Step 2: Temporary key negotiation 1. Temporary key generation: A generates a random number (kA) and calculates a temporary public key (RA = kA cdot G); B generates a random number (kB) and calculates a temporary public key (RB = kB cdot G); A sends (RA) to B, and B sends (RB) to A; 2. Shared key calculation: A calculates the shared key point according to the SM2 key exchange protocol: K{AB} = kA cdot (hcdot PB + RB), where (h) is the SM2 curve cofactor; B is similarly calculated: K{BA} = kB cdot (h cdot PA + RA). Due to the mathematical properties of the SM2 algorithm, ( K{AB} = K{BA} ), both parties obtain the same shared key point ( K ). The bit string ( K{raw} ) is extracted from the x- and y-coordinates of ( K ). 3. Session key derivation: A and B use the SM3 hash algorithm to hash (K{raw}), (rA), (rB), (TA), (TB): Ks = SM3(K{raw} || rA || rB || TA || TB), (Ks) is the final temporary session key; Step 3: Key confirmation and encrypted communication: 1. Key confirmation: A uses the SM4 algorithm to encrypt a predefined message (such as "KeyConfirmed") with (Ks), obtains the ciphertext (CA), and sends it to B; B uses (Ks) to decrypt (CA) and verify the correctness of the message; if correct, B sends the ciphertext (CB) to A in a similar manner; A decrypts (CB) to verify the correctness of the message and confirm that the key negotiation is successful; 2. Encrypted communication: Both parties use (Ks) as the symmetric key of SM4 to encrypt and decrypt subsequent communication data. After each session ends, (Ks) is automatically destroyed and a new key is renegotiated for the next session. Step 4: Security Enhancement Mechanism: 1. Forward security: Temporary keys (kA) and (kB) are destroyed immediately after the session ends. Even if the long-term private key (dA) or (dB) is leaked, the historical session key cannot be traced back. 2. Anti-replay attack: Timestamp (TA), (TB) and random numbers (rA), (rB) ensure the uniqueness of the message and prevent replay attacks; 3. Anti-man-in-the-middle attack: Digital certificates and SM2 signature verification ensure the identity of both parties in communication is credible and prevent forgery; 4. Dynamic key update: The key validity period can be set according to communication needs, and new key negotiation can be triggered regularly or on demand.

[0015] Preferably, the commercial password detection method comprises the following steps: Step 1: Initialization and identity authentication: The communicating parties generate an SM2 public-private key pair and verify their identities through digital certificates and SM2 signatures. Step 2: Temporary key negotiation: Generate a shared key point based on the SM2 key exchange protocol; Step 3: Session key derivation: Generate a temporary session key using the SM3 hash algorithm. Step 4: Key confirmation and encrypted communication: Use the SM4 algorithm to verify the key and encrypt the communication data.

[0016] Among them, random numbers and timestamps are introduced in the identity authentication step to prevent replay attacks.

[0017] Among them, temporary key negotiation uses a one-time random number to ensure forward security.

[0018] The session key is derived from the shared key point and dynamic parameters using the SM3 hash algorithm.

[0019] Among them, it is suitable for resource-constrained devices and supports efficient computing and low-power operation. Example

[0020] Taking the financial payment system as an application scenario, this paper describes in detail how to use this method between the client (initiator A) and the server (responder B) to negotiate temporary session keys and protect payment data transmission. In financial payment systems, a client (such as a user's mobile payment app, referred to as Initiator A) needs to securely communicate with a bank server (referred to as Responder B) over the internet to complete payment transactions. To ensure the confidentiality, integrity, and attack resistance of payment data, both parties adopt the highly secure method described in this paper for negotiating temporary session keys based on national cryptographic algorithms. These algorithms use the SM2, SM3, and SM4 algorithms to negotiate temporary session keys, which are then used to encrypt payment data.

[0021] Hardware and software environment 1. Client (A): Device: Smartphone with Android 12 operating system, 4GB RAM and octa-core processor.

[0022] Software: Payment application, integrated with national cryptographic algorithm library (supports SM2, SM3, and SM4), and obtains digital certificates through a trusted third party (such as CA).

[0023] 2. Server (B): Equipment: High-performance server running Linux system, equipped with 16-core CPU and 32GB RAM.

[0024] Software: Bank back-end service program, integrated national encryption algorithm module, storage server SM2 public and private key pairs and digital certificates.

[0025] 3. Communication environment: Network: Public internet access via 4G / 5G or WiFi presents potential risks of eavesdropping, man-in-the-middle attacks, and replay attacks.

[0026] 4. Algorithm parameters: SM2 elliptic curve parameters: Use the 256-bit curve recommended by the State Cryptography Administration.

[0027] SM3 hash function: outputs a 256-bit hash value.

[0028] SM4 symmetric encryption: 128-bit key length, CBC mode.

[0029] Implementation steps The following are the specific steps for client A and server B to negotiate a temporary session key and complete a payment transaction using the method of the present invention: Step 1: Initialization and Authentication 1. Client initialization: The payment application generates an SM2 public-private key pair: private key (dA), public key (PA = dA cdot G) (G is the base point of the SM2 curve).

[0030] The application obtains a digital certificate (CertA) from the CA, which contains (PA) and identity information.

[0031] The application generates a 64-bit random number (rA) (via a hardware random number generator) and the current timestamp (TA) (accurate to milliseconds).

[0032] Use (dA) to perform SM2 signature on (rA || TA) to generate signature (SigA).

[0033] The client sends the message ({rA, TA, SigA, CertA}) to the server via HTTPS.

[0034] 2. Server Verification: The server receives the message and verifies the legitimacy of (CertA) (checking the CA signature and certificate validity period).

[0035] Use (PA) in (CertA) to verify (SigA) and confirm that (rA || TA) has not been tampered with.

[0036] Check if (TA) is within the 5-second time window (to prevent replay attacks).

[0037] If the verification is successful, the server generates a random number (rB), timestamp (TB), signature (SigB) and certificate (CertB), and sends ({rB, TB, SigB, CertB}) to the client.

[0038] 3. Client verification: The client verifies (CertB), (SigB), and (TB) to confirm that the server's identity is trustworthy.

[0039] If both parties pass the verification, the key negotiation phase begins; otherwise, the payment application prompts "Authentication failed" and terminates.

[0040] Step 2: Temporary key negotiation 1. Temporary key generation: The client generates a random number (kA) (256 bits), calculates a temporary public key (RA = kA cdot G), and sends (RA) to the server through an encrypted channel.

[0041] The server generates a random number (kB), calculates a temporary public key (RB = kB cdot G), and sends (RB) to the client.

[0042] 2. Shared key calculation: The client calculates the shared key point according to the SM2 key exchange protocol: [K{AB} = kA cdot (h cdot PB + RB)] Where (h) is the SM2 curve cofactor, and (PB) is obtained from (CertB).

[0043] Similar calculations for servers: [K{BA} = kB cdot (h cdot PA + RA) ] Both parties extract the bit string (K{raw}) from the x and y coordinates of (K{AB} = K{BA}).

[0044] 3. Session key derivation: Both parties use the SM3 hash algorithm to calculate a temporary session key: [ Ks = SM3(K{raw} || rA || rB || TA || TB) ] (Ks) is a 128-bit key used for subsequent SM4 encryption.

[0045] Step 3: Key confirmation and encrypted communication 1. Key confirmation: The client encrypts the predefined message "KeyConfirmed" using SM4 (CBC mode, with (Ks) as the key), generates the ciphertext (CA), and sends it to the server.

[0046] The server uses (Ks) to decrypt (CA) and verify the correctness of the message; if correct, the server generates the ciphertext (CB) in the same way and sends it to the client.

[0047] The client decrypts (CB), verifies the message correctness, and confirms (Ks) consistency.

[0048] 2. Payment data encryption: The client constructs payment data (such as account ID, amount, transaction time), encrypts it using SM4 with (Ks), generates ciphertext (C{data}), and sends it to the server.

[0049] The server decrypts (C{data}), verifies the data integrity, processes the transaction and returns an encrypted transaction confirmation message.

[0050] 3. Key destruction: After the transaction is completed, the client and server destroy (Ks), (kA), (kB), and (K{raw}) to ensure that the temporary key is not reused. The next time you make a payment, repeat the above steps to renegotiate a new key.

[0051] Effect analysis 1. Security: Identity authentication: SM2 signatures and digital certificates prevent man-in-the-middle attacks and ensure the trustworthiness of client and server identities.

[0052] Forward security: Temporary keys (kA) and (kB) are one-time use. Even if the long-term private key is leaked, the historical session key cannot be recovered.

[0053] Anti-replay attack: Random numbers (rA), (rB) and timestamps (TA), (TB) ensure message uniqueness.

[0054] Data protection: SM4 encryption ensures the confidentiality and integrity of payment data.

[0055] 2. Performance: In the test environment, the total time for key negotiation is about 150 milliseconds (including network delay), which meets the real-time payment requirements.

[0056] SM2 signature verification and SM3 hash calculation take less than 10 milliseconds per operation on smartphones, making them suitable for resource-constrained devices.

[0057] The SM4 encryption speed is approximately 10MB / s, supporting large-scale transaction data processing.

[0058] 3. Compatibility: This method is based on standard national cryptographic algorithms, is compatible with existing financial systems, and supports domestically produced cryptographic equipment.

[0059] It can be extended to other scenarios, such as e-government, IoT devices, etc.

[0060] This example demonstrates the successful application of the present method in a financial payment system. By combining the SM2, SM3, and SM4 algorithms, the client and server efficiently negotiated a highly secure temporary session key, protecting the secure transmission of payment data. This method excels in security, performance, and compatibility, making it suitable for network communication scenarios requiring high security.

[0061] The contents not described in detail in this specification belong to the prior art known to those skilled in the art.

[0062] It should be noted that, in this document, relational terms such as first and second, etc., are used only to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the terms "include," "comprise," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or system that includes a list of elements includes not only those elements but also other elements not explicitly listed, or elements inherent to such process, method, article, or system.

[0063] While embodiments of the present invention have been shown and described, it will be appreciated by those skilled in the art that various changes, modifications, substitutions, and variations may be made to these embodiments without departing from the principles and spirit of the invention, and that the scope of the invention is defined by the appended claims and their equivalents.

Claims

1. A high-security method for negotiating temporary session keys based on a national cryptographic algorithm, characterized by: This method is applicable to two communicating parties (hereinafter referred to as initiator A and responder B) negotiating a temporary session key over an insecure channel. The following are the specific steps of this method: Step 1: Initialization and identity authentication; 1. Parameter initialization: The communicating parties A and B each generate a public-private key pair based on the SM2 algorithm: Initiator A: private key (dA), public key (PA = dA cdot G) (G is the base point of the SM2 elliptic curve); Responder B: Private key (dB), public key (PB = dB cdot G); both parties obtain each other's public key and digital certificate through a trusted third party (such as a CA) to ensure identity trust; The system predefines SM2 curve parameters, SM3 hash function and SM4 encryption algorithm parameters; 2. Identity authentication: A generates a random number (rA) and the current timestamp (TA), and uses the private key (dA) to perform SM2 signature on ({rA||TA}) to obtain the signature (SigA); A sends ({rA, TA, SigA, CertA}) (where (CertA) is A's digital certificate) to B. After receiving it, B: uses the public key (PA) in (CertA) to verify the legitimacy of (SigA); checks whether (TA) is within the valid time window (to prevent replay attacks); verifies the randomness of (rA) (to prevent forgery). B generates (rB), (TB), (SigB), (CertB) in a similar way and sends them to A. A performs the same verification. Step 2: Temporary key negotiation 1. Temporary key generation: A generates a random number (kA) and calculates a temporary public key (RA = kA cdot G); B generates a random number (kB) and calculates a temporary public key (RB = kB cdot G); A sends (RA) to B, and B sends (RB) to A; 2. Shared key calculation: A calculates the shared key point according to the SM2 key exchange protocol: K{AB} = kA cdot (h cdotPB + RB), where (h) is the SM2 curve cofactor; B is similarly calculated: K{BA} = kB cdot (h cdot PA + RA). Due to the mathematical properties of the SM2 algorithm, ( K{AB} = K{BA} ), both parties obtain the same shared key point ( K ). The bit string ( K{raw} ) is extracted from the x- and y-coordinates of ( K ).

3. Session key derivation: A and B use the SM3 hash algorithm to hash (K{raw}), (rA), (rB), (TA), (TB): Ks = SM3(K{raw} || rA || rB || TA || TB), (Ks) is the final temporary session key; Step 3: Key confirmation and encrypted communication:

1. Key confirmation: A uses the SM4 algorithm to encrypt a predefined message (such as "KeyConfirmed") with (Ks), obtains the ciphertext (CA), and sends it to B; B uses (Ks) to decrypt (CA) and verify the correctness of the message; if correct, B sends the ciphertext (CB) to A in a similar manner; A decrypts (CB) to verify the correctness of the message and confirm that the key negotiation is successful; 2. Encrypted communication: Both parties use (Ks) as the symmetric key of SM4 to encrypt and decrypt subsequent communication data. After each session ends, (Ks) is automatically destroyed and a new key is renegotiated for the next session. Step 4: Security Enhancement Mechanism:

1. Forward security: Temporary keys (kA) and (kB) are destroyed immediately after the session ends. Even if the long-term private key (dA) or (dB) is leaked, the historical session key cannot be traced back.

2. Anti-replay attack: Timestamp (TA), (TB) and random numbers (rA), (rB) ensure the uniqueness of the message and prevent replay attacks; 3. Anti-man-in-the-middle attack: Digital certificates and SM2 signature verification ensure the identity of both parties in communication is credible and prevent forgery; 4. Dynamic key update: The key validity period can be set according to communication needs, and new key negotiation can be triggered regularly or on demand.

2. A high-security method for negotiating a temporary session key based on a national secret algorithm according to claim 1, characterized in that: The commercial password detection method comprises the following steps: Step 1: Initialization and identity authentication: The communicating parties generate an SM2 public-private key pair and verify their identities through digital certificates and SM2 signatures. Step 2: Temporary key negotiation: Generate a shared key point based on the SM2 key exchange protocol; Step 3: Session key derivation: Generate a temporary session key using the SM3 hash algorithm. Step 4: Key confirmation and encrypted communication: Use the SM4 algorithm to verify the key and encrypt the communication data.

3. A high-security method for negotiating a temporary session key based on a national secret algorithm according to claim 2, characterized in that: Random numbers and timestamps are introduced in the authentication step to prevent replay attacks.

4. A high-security method for negotiating a temporary session key based on a national secret algorithm according to claim 2, characterized in that: Temporary key negotiation uses a one-time random number to ensure forward security.

5. A high-security method for negotiating a temporary session key based on a national secret algorithm according to claim 2, characterized in that: The session key is derived from the shared secret point and dynamic parameters using the SM3 hash algorithm.

6. A high-security method for negotiating a temporary session key based on a national secret algorithm according to claim 2, characterized in that: Suitable for resource-constrained devices, supporting efficient computing and low-power operation.