Revisiting a Proof of Security for the SM2 Key Exchange Protocol

Abstract

The SM2 key exchange protocol, proposed by the Chinese State Cryptography Administration and adopted as a national standard, is extensively deployed in commercial applications across China. It has also been incorporated by global industrial organizations and integrated into numerous international products, such as TPM. Today, any cryptographic protocol aspiring to become widely adopted and standardized requires a rigorous security proof within a modern security model. Although Yang et al. claimed to have established such a proof for the SM2 key exchange protocol in the Bellare–Rogaway (BR) model, we show that their proof is flawed. Moreover, we present a group representation attack against the SM2 key exchange protocol, illustrating that the protocol cannot be proven secure in any contemporary security models. Our findings thus delineate the security boundary of the SM2 key exchange protocol.

1. Introduction

Authenticated key exchange (AKE) protocols [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17] lie at the core of secure communications in modern cryptography. They enable two or more parties, who may have had no prior interaction or do not fully trust one another, to establish a shared secret key over an untrusted network. By ensuring both the authenticity of the participants and the confidentiality of the derived key, AKE protocols provide a foundation for numerous security services such as secure channels, password-based authentication, and multi-factor verification. Some research efforts focus on IoT scenarios by proposing lightweight AKE protocols tailored for IoT devices [18,19,20,21,22,23,24,25,26]. Meanwhile, with the advent of quantum computing, other works employ lattice-based methods to construct AKE protocols that resist quantum attacks [27,28,29,30,31].

The SM2 key exchange protocol was proposed by the Chinese State Cryptography Administration and incorporated into the Chinese national standard for the SM2 public key cryptographic algorithm [32,33,34]. This protocol is mandatory in various security applications used by Chinese government agencies and is also extensively adopted in commercial systems throughout China. Moreover, it has achieved international recognition, being standardized in industrial specifications such as Trusted Computing Group’s (TCG) TPM 2.0 specification [35], the Java Card specifications [36], and IETF drafts [37].

Because the applied-cryptography community and standard organizations regard formal analysis as indispensable for any cryptographic protocol aiming to be widely adopted and standardized, a rigorous evaluation of the SM2 key exchange protocol in modern AKE security models is urgently required. In response, Yang et al. [38] analyzed the SM2 key exchange protocol in the Bellare–Rogaway (BR) model [39], claiming that the protocol is secure under the elliptic curve discrete logarithm problem (ECDLP) assumption (Definition 1). However, we find that their proof reduces the compromise of a session key to the knowledge of the long-term and ephemeral private keys of the session’s owner or peer. Their reduction does not cover all the possible ways of computing the session key, and an adversary can compromise a session key through other means. Consequently, their security proof is flawed.

SM2 AKE is widely used and has been standardized by both Chinese cryptographic standards and international standards, demanding rigorous security proofs. However, we have found that a particular computational step (avf) in the SM2 key exchange protocol prevents it from being proven secure under modern AKE models. Therefore, the primary goal of this paper is to use rigorous modern AKE models to explain why the SM2 key exchange protocol cannot be proven. To this end, we propose a group representation attack on the SM2 key exchange protocol. Next, we analyze the elliptic curves employed in the SM2 standard and demonstrate that the specific curves in practical use can resist group representation attacks. Finally, by drawing on all current analyses of the SM2 key exchange protocol, we delineate the security boundary of the SM2 key exchange protocol and offer recommendations for revising the protocol to achieve higher security.

2. Materials and Methods

In this section, we first introduce the SM2 key exchange protocol and then present the Bellare–Rogaway model [39,40] used to analyze this protocol.

2.1. Overview of the SM2 Key Exchange Protocol

The notations used in this paper are summarized in

Table 1. Notations and Definitions.

Notation	Definition
$\widehat{A}$,$\widehat{B}$	Identities of two communicating parties
A,B	The parties $\widehat{A}$ and $\widehat{B}$’s long-term public keys
a,b	The parties $\widehat{A}$ and $\widehat{B}$’s long-term private keys
$({\mathbb{F}}_q,+,·)$	In a finite field of size q, we denote addition by + and multiplication by ·. However, the multiplication symbol · can be omitted.
$E\left({\mathbb{F}}_q\right)$	All points that lie on the elliptic curve E defined over ${\mathbb{F}}_q$
G	The generator of an elliptic curve
$\#E\left({\mathbb{F}}_q\right)$	The total count of points lying on the elliptic curve E
h	Let h denotes the co-factor, determined by $\#E\left({\mathbb{F}}_q\right)/n$, where n is the order of the generator G
$KDF(par,klen)$	A key derivation function whose input is specified by $par$ and whose output length is $klen$
$s\left|\right|t$	Combining the contents of two strings s and t in a sequential manner
$0^n$	An n-bit sequence made up entirely of zeroes
$\lceil i\rceil$	The ceiling of an integer i
$[i,j]$	The collection of all integer values x that satisfy $i\le x\le j$
&	A logical bit-by-bit conjunction that yields 1 only when both corresponding bits are 1.
$\left[k\right]P$	An operation defined by repeatedly adding an elliptic-curve point to itself a specified integer number of times, $\left[k\right]P={\underbrace{P+P+\cdots +P}}_k$

, and the SM2 key exchange protocol is depicted in Figure 1. We particularly introduce the $avf\left(\right)$ function, which is important for our analysis of the protocol: the function receives an elliptic curve point $X=(x,y)$ and returns $\overline{x}=2^{\omega }+(x \& (2^{\omega }-1))$ where $\omega =\lceil \left(\lceil lo{g}_2\left(n\right)\rceil \right)/2\rceil -1$ and n is the order of the generator of the elliptic curve.

Definition 1.

[ECDLP Assumption] Let E be an elliptic curve defined over a finite field ${\mathbb{F}}_q$. The ECDLP assumption states that, given two randomly chosen points $P,Q\in E\left({\mathbb{F}}_q\right)$, it is computationally infeasible to compute the integer l satisfying $Q=lP$.

2.2. Overview of the Bellare-Rogaway Model

The Bellare-Rogaway (BR) model is a well-established framework for analyzing and proving the security of key exchange protocols. By incorporating various types of queries to simulate adversarial capabilities, this model allows researchers to rigorously demonstrate whether a protocol can preserve session key confidentiality in the presence of a powerful attacker. We outline the key components of the BR model below.

2.2.1. Session Instances

In the BR model, each user in the system may initialize multiple session instances to replicate the possibility of concurrent executions in real-world scenarios. Let ${\mathrm{\Pi }}_{U_i}^j$ represent the j-th session instance of user $U_i$. Through these instances, an adversary can interact with ongoing or completed protocol runs, testing how well the protocol resists various attacks.

2.2.2. Adversarial Capabilities and Queries

An adversary $\mathcal{M}$ is assumed to have broad capabilities, modeled through specific types of queries:

• Send $({\mathrm{\Pi }}_{U_i}^j,m)$: The adversary transmits a message m to the session instance ${\mathrm{\Pi }}_{U_i}^j$. Upon receiving m, the instance processes it according to the protocol specification and returns the appropriate response. If the instance accepts a session key or terminates, this information is also revealed to $\mathcal{M}$.
• Reveal $\left({\mathrm{\Pi }}_{U_i}^j\right)$: If the session instance ${\Pi }_{U_i}^j$ has already accepted a session key, then this query discloses that session key to $\mathcal{M}$. This models scenarios in which the adversary gains access to ephemeral keys retained in temporary storage.
• Corrupt $\left(U_i\right)$: This query grants the adversary the complete internal state of user $U_i$, including long-term private keys and any other sensitive parameters. It simulates situations such as insider threats or covert access to a user’s device.
• Test $\left({\mathrm{\Pi }}_{U_i}^j\right)$: This query is used to distinguish between a real session key and a randomly generated value. If ${\mathrm{\Pi }}_{U_i}^j$ currently holds a legitimate session key (and is considered “fresh,” as explained below), then a random bit b is chosen. If $b=0$, the adversary receives the actual session key; if $b=1$, the adversary receives a random value of the same length. The adversary’s objective is to guess whether the returned value is real or random.

2.2.3. Partnership and Freshness

Partnership is defined such that two different session instances are considered partners if they hold the same session identifier (SID), agree on each other’s identities, and derive the same session key, without any other instance deriving that same key.

A session instance that has accepted a key is deemed fresh if neither it nor its partner instance has had its key revealed via a Reveal query and if neither of the two users involved has been compromised via a Corrupt query. Intuitively, freshness ensures that the key has not been exposed at either the session level or the user level.

2.2.4. Security Definition

Definition 2.

[Security of AKE] An AKE protocol is called secure if the following properties hold for any polynomial-time adversary $\mathcal{M}$ defined above:

1. 

When two uncorrupted parties complete matching sessions, they output the same session key.

2. 

The probability that $\mathcal{M}$ guesses the bit b (i.e., outputs $b^{\prime }=b$) from the Test query correctly is no more than $1/2$ plus a negligible fraction, i.e., the advantage of $\mathcal{M}$ in distinguishing the real key is quantified as:

$${Adv}_{\mathcal{M}}=Pr[b^{\prime }=b]\le 1/2+ϵ.$$

3. Results

In this section, we first reveal a flaw in the security analysis of Yang et al. [38], present a concrete group representation attack, and then provide a detailed description of the group representation attack in the BR model, illustrating why the SM2 AKE protocol cannot be rigorously proven secure under modern AKE models.

3.1. A Flaw of Yang’s Security Proof

The security analysis by Yang et al. reduces the compromise of a clean session key to the compromise of the long-term private keys and ephemeral private keys of the related parties. Suppose a party $\widehat{A}$, whose public key is $A=\left[a\right]G$, establishes a session s with $\widehat{B}$, whose public key is $B=\left[b\right]G$, and the session is denoted by $(\widehat{A},\widehat{B},X,Y)$ where X is the outgoing ephemeral public key and Y the incoming ephemeral public key to the session. The argument of Yang et al. to prove the SM2 key exchange protocol is as follows: if an adversary $\mathcal{M}$ computes the session key of s, he must correctly guess the long-term private key a and the ephemeral private key x of the party $\widehat{A}$ or correctly guess the long-term private key b and the ephemeral private key y of the party $\widehat{B}$. Since $\mathcal{M}$ does not know the private key of A, B, X, or Y, he can solve the ECDLP problem if he correctly computes any one of the values of a, b, x, or y.

The argument above is flawed, as $\mathcal{M}$ can compute the session key of s without guessing the long-term or ephemeral private keys. For example, he can learn the session key of s by launching a key-replication attack [10] which forces the establishment of a controlled session $s^{\prime }$ that has the same key as the target session s. In general, a rigorous security proof must show that any method of computing the session key leads to a contradiction of some cryptographic assumption. However, the proof provided by Yang et al. does not meet this requirement because it does not address all possible ways of compromising the session key. In the following section, we construct a group representation attack that allows an adversary to impersonate a legitimate party, establish a session with another party, and compute the corresponding session key. Under modern AKE models, the above session established by the adversary is permitted to be treated as a controlled session, thereby enabling the adversary to obtain the session key of the target session. This indicates that the SM2 key exchange protocol cannot be proven secure in modern AKE models.

3.2. A Brief Group Representation Attack

Here we present a concrete attack against the SM2 key exchange protocol: the group representation attack. This attack shows that the protocol cannot be proven secure in any security model, implying the incorrectness of the security proof of Yang et al. [38].

We begin by introducing an elliptic curve E that satisfies the following requirement: the binary representation of each point’s x-coordinate has its final $\omega$ bits fixed, where

$$\omega =⌈{\displaystyle \frac{⌈{log}_2\left(n\right)⌉}{2}}⌉-1,n\mathrm{is}\mathrm{the}\mathrm{order}\mathrm{of}\mathrm{the}\mathrm{generator}\mathrm{of}E.$$

Now let us consider another elliptic curve $E^{\prime }$ defined over a finite group ${\mathbb{F}}_q^{\prime }$, where n is the order of the generator of $E^{\prime }$. Denote the addition and multiplication operations in ${\mathbb{F}}_q^{\prime }$ by ‘+’ and ‘·’, respectively. Building upon ${\mathbb{F}}_q^{\prime }$, we construct the algebraic structure $({\mathbb{F}}_q,\oplus ,\otimes )$ as follows.

1.

We define ${\mathbb{F}}_q$ to be the set

$$\{x:x=x^{\prime }\Vert 0^{\omega },x^{\prime }\in {\mathbb{F}}_q^{\prime }\}.$$

2.

For any $x,y\in {\mathbb{F}}_q$ expressed as $x=x^{\prime }\Vert 0^{\omega }$ and $y=y^{\prime }\Vert 0^{\omega }$, where $x^{\prime },y^{\prime }\in {\mathbb{F}}_q^{\prime }$, we then specify the operations

$$x\oplus y=(x^{\prime }+y^{\prime })\Vert 0^{\omega }\mathrm{and}x\otimes y=(x^{\prime }·y^{\prime })\Vert 0^{\omega }.$$

It can be confirmed that $({\mathbb{F}}_q,\oplus ,\otimes )$ forms a finite field. Because the representation of elements in ${\mathbb{F}}_q$ has its $\omega$ least significant bits set to zero, every elliptic curve defined over ${\mathbb{F}}_q$ automatically satisfies the intended property. Specifically, for the elliptic curve E defined on ${\mathbb{F}}_q$, the $avf\left(\right)$ function yields a fixed value. Here we explain why, for any point $X=(x,y)$ on the elliptic curve E, the value of $\overline{x}$, or $avf\left(X\right)$, is a constant c.

$$\overline{x}=avf\left(X\right)=2^{\omega }+\left(x\&(2^{\omega }-1)\right),$$

and then $\overline{x}$ simplifies to $2^{\omega }$, a constant denoted by c.

Based on the elliptic curve E, we propose a brief attack on the protocol in which an attacker $\mathcal{M}$ can impersonate a party $\widehat{A}$ to communicate with another party $\widehat{B}$. $\mathcal{M}$ randomly chooses $x^{*}\in [1,n]$ and sends $X^{*}=[1/c](\left[x^{*}\right]G-A)$ to $\widehat{B}$ as the identity of $\widehat{A}$. After receiving $X^{*}$, $\widehat{B}$ responds with $Y=\left[y\right]G$ and computes its unhashed value $Z=[h·t_B](A+\left[\overline{x}\right]X^{*})=[h·t_B](A+\left[c\right]X^{*})=[h·t_B]\left(\left[x^{*}\right]G\right)$. Finally, $\mathcal{M}$ can compute the session key of $\widehat{B}$ by computing $[h·x^{*}](B+\left[c\right]Y)=[h·t_B]\left(\left[x^{*}\right]G\right)$ which equals the unhashed value Z of $\widehat{B}$. Thus, $\mathcal{M}$ successfully impersonates $\widehat{A}$ to $\widehat{B}$.

Based on the above group representation attack, we claim that the SM2 key exchange protocol indeed cannot be proven secure under modern AKE models, for the following reasons. First, the aim of modern cryptography is to show, under certain mathematical assumptions, that an adversary with a given attack capabilities cannot break the protocol, thereby reducing the protocol’s security to the mathematical assumptions. In modern AKE models, no assumptions are made about the specific elliptic curves used by the protocol; instead, proofs employ pure mathematical elliptic curves. Consequently, the group representation attack we propose is admissible under all such model AKE models, meaning it is correct to conclude that the SM2 key exchange protocol cannot be proven secure in modern AKE models. One advantage of this proof paradigm is that if a protocol is proven secure within these models, it guarantees a very high level of security.

3.3. A Formal Attack Based on the BR Model

Below, we provide a formal description, grounded in the BR model, of the group representation attack. Specifically, we show how, through a series of query executions and message exchanges, the adversary can construct a counterfeit session s’ that shares the same session key as a target session. In the BR model, an adversary (denoted by $\mathcal{M}$) can interact with protocol session instances via the following queries: Send, Reveal, Corrupt, and Test. We provide a step-by-step account of how $\mathcal{M}$ can impersonate $\widehat{A}$ to $\widehat{B}$ in an SM2 key exchange setting, constructing a session $s^{\prime }$ that shares the same session key as the session it aims to attack.

3.3.1. Attack Goals and Setup

• Let ${\mathrm{\Pi }}_{\widehat{A}}^i$ represent the i-th session instance of user $\widehat{A}$, and ${\mathrm{\Pi }}_{\widehat{B}}^j$ represent the j-th session instance of user $\widehat{B}$.
• The adversary $\mathcal{M}$ seeks to create a counterfeit session instance, denoted ${\mathrm{\Pi }}_{\widehat{A}}^{i^{\prime }}$ (or $s^{\prime }$ for convenience), which deceives ${\mathrm{\Pi }}_{\widehat{B}}^j$ into believing it is communicating with $\widehat{A}$. As a result, ${\mathrm{\Pi }}_{\widehat{B}}^j$ will generate a session key that $\mathcal{M}$ also learns or shares.

3.3.2. Attack Steps

1.

Preparation: The adversary $\mathcal{M}$ chooses a random integer $x^{*}\in [1,n]$. Using the public elliptic curve parameters $(E,G)$ and the public key A belonging to $\widehat{A}$, plus the constant c, $\mathcal{M}$ computes $X^{*}=[1/c]\left(\left[x^{*}\right]G-A\right)$ and sets $X^{*}$ as the ephemeral public key and sends it to the party with which it intends to establish a session.

2.

Impersonation and Sending Messages (the Send query):

• $\mathcal{M}$ calls $\mathrm{Send}\left({\mathrm{\Pi }}_{\widehat{B}}^j,(\widehat{A},X^{*})\right)$ to send a message to ${\mathrm{\Pi }}_{\widehat{B}}^j$, impersonating the identity $\widehat{A}$, along with the ephemeral public key $X^{*}$.
• Upon receiving the above message, ${\mathrm{\Pi }}_{\widehat{B}}^j$ believes it has received a message from $\widehat{A}$ and proceeds according to the SM2 key exchange protocol.

3.

Generating and Receiving Y (Response to the Send query):

• ${\mathrm{\Pi }}_{\widehat{B}}^j$ randomly chooses an ephemeral secret y, computes $Y=\left[y\right]G$, and then responds via the $\mathrm{Send}\left({\mathrm{\Pi }}_{\widehat{M}},Y\right)$ query, sending Y back to the adversary $\mathcal{M}$.
• The adversary $\mathcal{M}$ obtains Y and continues with the next step.

4.

Session Key Computation at $\widehat{B}$’s Side:

• The instance ${\mathrm{\Pi }}_{\widehat{B}}^j$ uses its local secret $t_B$ (which, in the SM2 key exchange protocol, typically involves both a long-term key and an ephemeral random key) to compute

  $$Z=[h·t_B]\left(A+\left[\overline{x}\right]X^{*}\right).$$
  Given that $X^{*}=[1/c]\left(\left[x^{*}\right]G-A\right)$ and $\left[\overline{x}\right]X^{*}$ equals $\left[c\right]X^{*}$, we get

  $$A+\left[\overline{x}\right]X^{*}=A+\left[c\right]\left([1/c](\left[x^{*}\right]G-A)\right)=\left[x^{*}\right]G.$$
  Therefore,

  $$Z=[h·t_B]\left(\left[x^{*}\right]G\right).$$
  Z is then used by ${\mathrm{\Pi }}_{\widehat{B}}^j$ to derive the session key.

5.

Adversary Shares the Same Session Key:

• Using the same $x^{*}$ and the received Y, the adversary computes

  $$[h·x^{*}]\left(B+\left[\overline{y}\right]Y\right)=[h·x^{*}]\left(B+\left[c\right]Y\right).$$
  In the SM2 key exchange protocol, B is $\widehat{B}$’s public key or an identity-based parameter. By substituting $Y=\left[y\right]G$, we can compute that the result $[h·x^{*}]\left(B+\left[c\right]Y\right)$ matches

  $$[h·t_B]\left(\left[x^{*}\right]G\right)=Z,$$

  thus allowing $\mathcal{M}$ to compute the exact same value Z as ${\mathrm{\Pi }}_{\widehat{B}}^j$, through which $\mathcal{M}$ can derive the same session key of ${\mathrm{\Pi }}_{\widehat{B}}^j$.

6.

Conclusion of the Attack: At this point, $\mathcal{M}$ has successfully fooled ${\mathrm{\Pi }}_{\widehat{B}}^j$ into believing it is communicating with $\widehat{A}$. The sessions ${\mathrm{\Pi }}_{\widehat{A}}^{i^{\prime }}$ (controlled by $\mathcal{M}$) and ${\mathrm{\Pi }}_{\widehat{B}}^j$ share the same session key, completing the impersonation.

In summary, through a series of Send queries to manage the receipt of Y and construction of $X^{*}$, the adversary $\mathcal{M}$ is able to compute the same session key as ${\mathrm{\Pi }}_{\widehat{B}}^j$. This results in a successful impersonation of $\widehat{A}$ in the SM2 key exchange protocol.

3.4. The Security of the SM2 Key Exchange Protocol in the Standard

We propose a group representation attack that uses a special elliptic curve on which the $\omega$ least significant bits of the point coordinates are fixed. In practice, however, the SM2 standard specifies the elliptic curves used in deployment. The SM2 standard mandates two types of elliptic curves $E\left(F_q\right)$, one where q is an odd prime and another where $q=2^m$, and it also constrains how elements of $F_q$ are represented as integers (Algorithm 1). Algorithm 1 shows that elements of $F_q$ have a one-to-one mapping to the interval $(0,q-1)$. Consequently, the $\omega$ least significant bits of elliptic curve points are not fixed but are uniformly distributed over $(0,2^{\omega }-1)$. Therefore, the aforementioned group representation attack cannot be applied to the elliptic curves specified in the standard.

Algorithm 1 Conversion of a Field Element to an Integer

Input: An element $\alpha$ of the field $\mathrm{GF}\left(q\right)$

Output: A non-negative integer x in the interval $[0,q-1]$

1: if q is an odd prime:    2:    $\alpha$ is an integer in the interval $[0,q-1]$. Set $x\leftarrow \alpha$.    3: else if $q=2^m$, then $\alpha$ must be a bitstring of length m.    4: Let $s_{m-1},s_{m-2},\dots ,s_1,s_0$ be the bits from left to right of $\alpha$.    5: Set $$x=\sum _{i=0}^{m-1}{2}^i{s}_i.$$    6: end if    7: return x

4. Discussion

In this section, we discuss the security boundaries of the SM2 key exchange protocol and ways to enhance its security, focusing on the theoretical analysis of the SM2 key exchange protocol, how practical elliptic curves resist group representation attacks, and proposed revisions to the SM2 standard.

4.1. Theoretical Analysis of the SM2 Key Exchange Protocol

From a theoretical perspective, the group representation attack discussed above indicates that the SM2 key exchange protocol cannot be rigorously proven secure under model AKE models, at least not without introducing additional assumptions about its internal mechanics. This attack exploits a structural loophole that bypasses the usual reliance on the elliptic curve discrete logarithm problem (ECDLP), highlighting a design gap which, under specially constructed scenarios, enables an adversary to replicate the shared secret key.

4.2. Practical Security of the SM2 Key Exchange Protocol

Although the SM2 key exchange protocol cannot be proven secure under modern AKE models, the analysis of the elliptic curves actually deployed in the SM2 standard (as discussed in Section 3.4) shows that the values of $avf\left(\right)$ on these real-world elliptic curves are not fixed but are instead approximately uniformly distributed. Moreover, Zhao et al. [41,42] conducted empirical measurements of $avf\left(\right)$ on the elliptic curves used in the SM2 standard, demonstrating that the entropy rate of $avf\left(\right)$ is close to 1 and essentially likes the behavior of a random number generator. This observation explains why in their security analysis, $avf\left(\right)$ is assumed as a secure cryptographic hash function. Under this assumption, the SM2 key exchange protocol can be proven secure in modern AKE models.

Therefore, the above analysis delineates the security boundary of the SM2 key exchange protocol. While it cannot be proven secure in the strictest theoretical sense, due to the potential for a group representation attack, its practical deployment may still be robust, as $avf\left(\right)$ provides sufficient randomness to withstand the group representation attack.

4.3. Revision Suggestion of the SM2 Standard

Although empirical measurements suggest that $avf\left(\right)$ for the elliptic curves used in the SM2 standard does provide some degree of randomness to resist the group representation attack, it still does not meet the security requirements of a cryptographic hash function. A cryptographic hash function must fulfill properties such as randomness and collision resistance [43], and the $avf\left(\right)$ in the SM2 standards currently does not attain these properties. Therefore, we still recommend replacing $avf\left(\right)$ with a cryptographically secure hash function in the SM2 standard. However, modifying the avf() function in the SM2 standard to a secure hash function, such as SM3 or SHA3, would impact the security standards or specifications that rely on the SM2 standard, as well as the corresponding products. Taking the trusted computing field as an example, this technology depends on the SM2 cryptographic algorithm. Therefore, changing the avf() function would require revising relevant trusted computing specifications, such as TCG’s TPM 2.0 Library specification [35]. At the same time, any trusted computing products relying on the TPM 2.0 specification, such as TPM 2.0 chips, would also need to be updated (e.g., through firmware updates) to support the revised SM2 cryptographic algorithm.

5. Conclusions

In this paper, we revisited the security of the SM2 key exchange protocol, a widely adopted protocol standardized in both Chinese and international standards. We demonstrated that the security proof put forward by Yang et al. [38] contains a critical flaw: it fails to account for all possible ways by which an adversary might compromise the session key. We presented a group representation attack, showing that an adversary can impersonate one party and derive the same session key. Our findings indicate that the SM2 key exchange protocol cannot be proven secure in modern AKE models. This theoretical limitation arises from the way the protocol uses the function $avf\left(\right)$, which an adversary can exploit to undermine the secure properties that an AKE protocol should provide. Nonetheless, we also showed that in practice, the specific elliptic curves recommended by the SM2 standard significantly mitigate the feasibility of the group representation attack. Empirical measurements suggest that $avf\left(\right)$ exhibits essentially random behavior for these standard curves, making real-world exploitation difficult.

Based on this analysis, we conclude that although SM2 key exchange cannot be proven secure in a rigorous theoretical sense, exploiting its theoretical vulnerabilities requires highly contrived conditions that do not align well with the officially mandated elliptic curves. To further strengthen the protocol, we recommend replacing or upgrading $avf\left(\right)$ with a proper cryptographic hash function, thereby ensuring well-defined security properties such as collision resistance. By clarifying the boundaries between theory and practice, we provide a foundation for improving the design of the SM2 key exchange protocol and further affirm its practical robustness in current deployments.