Home Efficiency of SIDH-based signatures (yes, SIDH)
Article Open Access

Efficiency of SIDH-based signatures (yes, SIDH)

  • Wissam Ghantous , Federico Pintore and Mattia Veroni EMAIL logo
Published/Copyright: March 6, 2024
Become an author with De Gruyter Brill

Abstract

In this note, we assess the efficiency of a supersingular isogeny Diffie-Hellman (SIDH)-based digital signature built on a weaker variant of a recent identification protocol proposed by Basso et al. Despite the devastating attacks against (the mathematical problem underlying) SIDH, this identification protocol remains secure, as its security is backed by a different (and more standard) isogeny-finding problem. We conduct our analysis by applying some known cryptographic techniques to decrease the signature size by about 70% for all parameter sets (obtaining signatures of approximately 21 kB for SIKE p 434 ). Moreover, we propose a minor optimisation to compute many isogenies in parallel from the same starting curve. Our assessment confirms that determining the most efficient methods for isogeny-based signature schemes, including optimisations such as those presented in this paper, is still a open problem, with much more work to be done.

MSC 2010: 94A62

1 Introduction

Isogenies between supersingular elliptic curves have been used to construct cryptosystems supposed to be secure even in the presence of quantum attackers. The family of such cryptosystems is named isogeny-based cryptography, and its most appealing members enjoy short keys and ciphertexts. At the time of writing, the most prominent example of this attractive feature is the digital signature SQISign [1], which is the most compact post-quantum signature scheme. On the other hand, isogeny-based cryptosystems incur high execution times, with SQISign making no exception (despite the recent improvements in [2]). The most promising results in terms of computational efficiency have been obtained for the key-exchange supersingular isogeny Diffie-Hellman (SIDH) [3] and the corresponding key-encapsulation mechanism supersingular isogeny key-encapsulation (SIKE) [4]. However, not all schemes built on SIDH share the same quality. An example is the SIDH-based digital signatures proposed in [5,6], for which no substantial amelioration has appeared since their publication. Nevertheless, they represented an alternative starting point for a practical isogeny-based digital signature building on existing schemes. However, three major classical attacks [79] were devised in 2022, which make SIDH, SIKE, and most of the SIDH-based cryptosystems – including the signature schemes based on SIDH mentioned above – completely insecure. As a consequence, SQISign and Sea-Sign/CSI-FiSh[1] were, until recently, the only isogeny-based digital signature schemes still secure.

Fortunately, two isogeny-based Σ -protocols that were recently proposed have restored the family of SIDH-based digital signatures (and non-interactive zero-knowledge proofs). The first one [13, Sec. 5.3] – denoted by Σ wSIDH in the following – was originally designed for the SIDH setting, while for the second one [14, Sec. 4] – which we denote by Σ SECUER base – the SIDH parameters are (probably the most) favourable in terms of practical efficiency, despite it being designed for a general scenario. Consequently, their implementations can take advantage of the optimised implementations for determining and evaluating isogenies in the SIDH configuration. Even so, both Σ wSIDH and Σ SECUER base are not affected by the attacks in [79] and hence can still be the base for constructing digital signature schemes as well as non-interactive zero-knowledge proofs (NIZKPs in short).

1.1 Our contribution

In this note, we assess the compactness and efficiency that can be currently reached by digital signatures (and NIZKPs) based on the SIDH setting. In doing so, we restrict our attention to a digital signature built on a slightly weaker variant of Σ SECUER base . We talk about weaker variant because Σ SECUER base was designed to satisfy statistical honest-verifier zero-knowledge, which is not necessary for our case study. The variant we consider – denoted by Σ SEC – only achieves computational honest-verifier zero-knowledge, but it allows for shorter isogenies, therefore a better efficiency. There are three main reasons to work with Σ SEC instead of other SIDH-based Σ -protocols. First, a similar assessment focused on Σ wSIDH was recently conducted in [15]. Even more importantly, despite the similarities between Σ wSIDH and Σ SEC , the latter has a more lightweight design, leading to smaller transcripts and faster execution times. Last but not least, the optimisations we apply to ( t parallel executions of) Σ SEC are applicable also to Σ SECUER base and are relevant to any application of these Zero-Knowledge Proof systems. In fact, using the Fiat-Shamir transform to remove interactivity from a Σ -protocol has applications beyond digital signatures. For example, Σ SECUER base has been used to prove random generation of supersingular curves of unknown endomorphism rings in a distributed and trusted manner [14].

We conduct our analysis by applying some known signature-shortening techniques. By doing so, we can shorten the signatures produced by means of Σ SEC by approximately 69 % . For example, we obtain signatures of approximately 21 kB for the parameter set SIKEp434. In addition, we propose minor optimisations to compute many isogenies in parallel from the same starting curve.

One of the techniques we consider to shorten the signatures is the unbalanced challenge space technique, firstly proposed in the study by Beullens et al. [16] for a Σ -protocol obtained by running parallel executions of a base Σ -protocol with soundness error 1/2. In this work, however, we apply it to a base Σ -protocol with soundness error 2/3, which requires a non-trivial generalisation of the original proposal. In fact, to determine the number of parallel executions which are required in such case for an unbalanced challenge space, we deduce some combinatorial results. Our findings can be readily applied to every possible soundness error of the base Σ -protocol, and therefore are of independent interest.

Our assessment confirms that the problem of designing a practical isogeny-based signature scheme remains largely open. Nonetheless, the proposed optimisations can be applied to the distributed trusted-setup protocol [14, Sec. 5] built on top of Σ SECUER base to collaboratively produce a random supersingular elliptic curve whose endomorphism ring is hard to compute even for the involved parties. Determining the best techniques to design secure and efficient isogeny-based signatures, against which future protocols can be benchmarked, is still a quite new and very open problem.

1.2 Related work

The SIDH-based digital signature scheme proposed in the study by Galbraith et al. [5] produces signatures of approximately 12 kB when targeting 128 bits of classical security. For the same security target, the signature scheme in the study by Chi-DomAηnguez et al. [17] (deduced from a different SIDH-based Σ -protocol proposed in the study by Chi-DomAηnguez et al. [13, Sec. 6]) outputs signatures of approximately 61 kB. Both these signature schemes are no longer secure after the cryptanalytic attacks against SIDH. The analysis conducted in the study by Chi-Domínguez et al. [15] on a still-secure digital signature built on top of Σ wSIDH achieves signatures of size approximately 74 kB for the parameter set SIKEp 434 . Note that the protocol in the study by Galbraith et al. [5] and Σ wSIDH in the study by Chi-DomAηnguez et al. [13, Sec. 5] are 2-special sound. The protocols in the study by Chi-DomAηnguez et al. [13, Sec. 6] is instead 3-special sound.

1.3 Roadmap

This article is organised as follows. In Section 2, we recall some cryptographic preliminaries and we provide a description of the Σ -protocol Σ SEC , which is a diminished version of Σ SECUER base from the study by Basso et al. [14, Sec. 4]. By applying the Fiat-Shamir transform [18] on Σ SEC , an SIDH-based signature scheme DS SEC is obtained. In Section 3, we apply some optimisation techniques to reduce the size of the signatures produced by DS SEC : commitment recoverability (Section 3.1), response compression (Section 3.2), and seed trees (Section 3.3). In Section 3.4, unbalanced challenge spaces are also taken into account. We conclude the section highlighting the overall gain in applying these optimisations with respect to the original scheme. In Section 4, we suggest two optimisations for the computation of several isogenies of the same degree from the same starting curve. They consists in a pre-computation of repeated initial steps (Section 4.1) and in the parallelisation of kernel generators computation (Section 4.2). Section 5 presents some closing remarks.

2 Preliminaries

In this section, we list some definitions and results regarding isogenies between supersingular elliptic curves, Σ -protocols, and digital signatures. We then detail the Σ -protocol Σ SEC , a diminished variant of Σ SECUER base from the study by Basso et al. [14, Sec. 4].

Remark 1

In the following, commitment schemes ( C ) and pseudorandom number generators ( Expand ) are instantiated with a hash function modelled as a random oracle O . We always assume the input domain of the random oracle is appropriately separated when instantiating different cryptographic primitives. With an abuse of notation, we will write O ( Expand ) instead of Expand ( ) and O ( Com ) instead of C ( ) to make the usage of the random oracle explicit. Here, we identify Expand and Com with unique strings.

2.1 Supersingular elliptic curves, isogenies, and hardness assumptions

We refer the reader to [19,20] for a more detailed introduction to the topic.

Let q be a power of a prime p 5 , and let F q be a finite field with q elements. An isogeny φ : E E between two elliptic curves E and E over F q , with points at infinity denoted by 0 E and 0 E respectively, is a non-constant regular rational map mapping φ ( 0 E ) into 0 E . Every isogeny φ can be written in its polynomial form ( F 1 ( x ) F 2 ( x ) , y G 1 ( x ) G 2 ( x ) ) , where F 1 , F 2 , G 1 , and G 2 are polynomials over the algebraic closure of F , F 1 is coprime with F 2 , and G 1 is coprime with G 2 . The isogeny φ is said to be defined over F q k if the coefficients of the above polynomials are contained in F q k ; in this case, we say that E , E are isogenous over F q k . Tate’s theorem states that E , E are isogenous over F q k if and only if # E ( F q k ) = # E ( F q k ) .

An invertible isogeny is an isomorphism; in addition, if its domain and image coincide, it is an endomorphism. The set of all endomorphisms of an elliptic curve E together with the zero map form a ring under pointwise addition and composition, called the endomorphism ring of E and denoted by End ( E ) . If End ( E ) is not commutative, then E is said to be supersingular. Every supersingular elliptic curve defined over F p k for some k N is isomorphic to an elliptic curve defined over F p 2 . The degree deg ( φ ) of an isogeny φ is the maximum among { deg ( F 1 ) , deg ( F 2 ) } ; we say that φ is a d -isogeny. Two elliptic curves E and E are d -isogenous if there exists an isogeny φ : E E of degree d . Given a power q of a prime p > 5 and a prime number p , we denote by G q ( ) the graph whose vertices are F q -isomorphism classes of supersingular elliptic curves over F q and whose edges are equivalence classes of -isogenies (two isogenies are in the same class if they have the same kernel). The composition of two isogenies of degrees d 1 and d 2 is an isogeny of degree d 1 d 2 .

The kernel of an isogeny is finite, and its size is equal to the degree of the isogeny itself if the isogeny is separable. Vice versa, if H is a finite subgroup of an elliptic curve E , then the elliptic curve E H and a separable isogeny ψ : E E of kernel ker ( ψ ) = H are unique (modulo isomorphism). Both E H and ψ can be computed with complexity O ( # H ) using Velu’s formulas. We say that φ is a cyclic isogeny when ker ( φ ) is a cyclic group. Given N , we denote by E [ ] the -torsion subgroup { P E [ ] P = 0 E } of E . When and p are relatively prime, E [ ] ( Z Z ) × ( Z Z ) .

2.2 Σ -protocols

Let X and Y be two sets whose sizes depend on a security parameter λ . Then X × Y is a polynomially computable binary relation over X and Y if, for any ( x , w ) X × Y , whether ( x , w ) can be decided in time poly ( x ) . If ( x , w ) , we call w a witness for the statement x . The language corresponding to is = { x X w Y : ( x , w ) } .

A Σ -protocol for a polynomially-computable binary relation is a public-coin three-move interactive protocol between a prover and a verifier. Informally, a prover can demonstrate knowledge of a valid witness for a certain statement without revealing any information about the witness itself. Below, we define a relaxed version of sigma protocols where the special-soundness extractor only extracts a witness for a slightly larger relation ˜ , with ˜ . Furthermore, the definition is given in the random oracle model, i.e. prover and verifier have access to a random oracle O . We may occasionally omit the superscript O when the meaning is clear from the context.

Definition 1

( Σ -protocols) A Σ -protocol S for polynomially-computable binary relations ˜ consists of five polynomial-time algorithms ( Gen , P = ( P 1 , P 2 ) , V = ( V 1 , V 2 ) ) with oracle-access, where V 2 is deterministic, Gen , P 1 , P 2 , and V 1 are probabilistic, and P 1 , P 2 share states. We denote by ComSet , ChSet , and ResSet the commitment space, challenge space, and response space, respectively. In the random-oracle model, the protocol goes as follows:

  • The key-generation algorithm Gen O ( 1 λ ) takes the security parameter 1 λ as input, and outputs a statement-witness pair ( x , w ) .

  • On input ( x , w ) , the prover computes com P 1 O ( x , w ) and sends the commitment com to the verifier.

  • The verifier runs ch V 1 O ( com ) to obtain a random challenge, and sends ch to the prover.

  • Given ch , the prover computes resp P 2 O ( x , w , com , ch ) and returns the response resp to the verifier.

  • The verifier runs V 2 O ( x , com , ch , resp ) and outputs 1 if they accept, 0 otherwise.

Here O is modelled as a random oracle. Moreover, a transcript ( x , com , ch , resp ) X × ComSet × ChSet × ResSet of the protocol is said to be valid (relative to x ) in case V 2 ( x , com , ch , resp ) outputs 1.

We require the following properties of a Σ -protocol:

  • Correctness: All honestly generated transcripts must be valid. Formally, it is required that

    Pr V 2 O ( x , com , ch , resp ) = 1 ( x , w ) KeyGen O ( 1 λ ) com P 1 O ( x , w ) , ch V 1 O ( com ) , resp P 2 O ( x , com , w , ch ) = 1 .

  • Relaxed κ -special soundness: There exists a polynomial-time extraction algorithm Ex such that, given any κ valid transcripts ( x , com , ch 1 , resp 1 ) , , ( x , com , ch κ , resp κ ) relative to the same statement x , with the same commitment com and κ distinct challenges ch 1 , , ch κ , outputs w such that ( x , w ) ˜ (note that Ex is only required to recover a witness in ˜ ).

  • Statistical and computational honest-verifier zero-knowledge (HVZK): Within this definition, we allow the adversary, the prover, and the simulator to make queries to a common random oracle O . We say the Σ -protocol is statistically HVZK if there exists a probabilistic polynomial-time (PPT) simulator algorithm Sim O such that, for any ( x , w ) , any honestly chosen ch ChSet and any computationally unbounded adversary A that makes at most a polynomial number of queries to O , we have

    Pr A O ( com , ch , resp ) = 1 com P 1 O ( x , w ) ; resp P 2 O ( x , com , w , ch ) Pr [ A O ( com , ch , resp ) = 1 ( com , resp ) Sim O ( x , ch ) ] = negl ( λ ) .

    If the aforementioned relation holds only for computationally bounded adversaries, the protocol is said to be computationally HVZK.

2.3 Digital signatures

Below we recall the definition of digital signature schemes, correctness, and unforgeability.

Definition 2

(Digital signature schemes) A digital signature scheme DS consists of three algorithms ( KeyGen , Sign , Vrfy ) defined as follows:

  • ( vk , sk ) KeyGen ( 1 λ ) : On input a security parameter λ , the key-generation algorithm outputs a pair of verification and signing keys ( vk , sk ) .

  • σ Sign ( sk , M ) : On input a signing key sk and a message M , the signing algorithm outputs a signature σ .

  • b { 0 , 1 } Vrfy ( vk , M , σ ) : On input a verification key vk , a message M , and a signature σ , the verification algorithm outputs 1 (accept) or 0 (reject).

2.3.1 Correctness

For every security parameter λ N and every message M , a signature scheme is correct if the following holds:

Pr Vrfy ( vk , M , σ ) = 1 ( vk , sk ) KeyGen ( 1 λ ) , σ Sign ( sk , M ) = 1 .

2.3.2 Security

We define existential unforgeability under chosen message attack( EUF - CMA ) with the following game between an adversary A and a challenger.

  1. The challenger runs ( vk , sk ) KeyGen ( 1 λ ) and provides the adversary A with the verification key vk . It also prepares an empty set S = .

  2. The adversary A may adaptively submit messages M to the challenger. The challenger responds with σ Sign ( sk , M ) to A ’s query on a message M and updates the set S S { ( M , σ ) } .

  3. Finally, A outputs a forgery ( M * , σ * ) . We say that the adversary A wins if ( M * , ) S and Vrfy ( vk , M * , σ * ) = 1 .

We then say that the signature scheme DS is EUF - CMA -secure if, for all PPT adversaries A , the advantage of A in winning the above game is negligible in the security parameter λ :

Adv A EUF - CMA ( λ ) Pr [ A wins ] = negl ( λ ) .

Via the Fiat-Shamir transform [18], a Σ -protocol S for a binary relation can be turned into a digital signature scheme. The resulting scheme F S ( S ) differs from S in the challenge computation, as the challenge is set equal to the digest H ( com , M ) – where M is the message to sign and H a hash function - instead of being randomly produced by the verifier. If the binary relation is based on a hard problem, then F S ( S ) can be proved EUF-CMA secure.

2.4 The Σ SEC protocol

In this section, we describe the Σ -protocol Σ SEC , a weaker variant of Σ SECUER base from the study by Basso et al. [14, Section 4] (see Remark 2 for the differences between the two protocols).

For every possible value of the security parameter λ , p will denote a prime of the form p = 1 e 1 2 e 2 f ± 1 (where 1 , 2 are small primes such that 1 e 1 2 e 2 and f N is a small cofactor), E 0 is a fixed supersingular elliptic curve over F p 2 such that # E 0 ( F p 2 ) = ( 1 e 1 2 e 2 f ) 2 (when considering SIKE parameters, we will take E 0 : y 2 = x 3 + 6 x 2 + x ), and { P 1 , Q 1 } and { P 2 , Q 2 } basis for E 0 [ 1 e 1 ] and E 0 [ 2 e 2 ] , respectively. Then, the tuple pp = ( p , 1 , 2 , e 1 , e 2 , f , E 0 , P 1 , Q 1 , P 2 , Q 2 ) forms the public parameter for the protocol.

The Σ -protocol Σ SEC consists of five oracle-calling algorithms ( Gen , P = ( P 1 , P 2 ) , V = ( V 1 , V 2 ) ) , where:

  • ( E 1 , φ ) Gen ( 1 λ ) : On input a security parameter, the key-generation algorithm uniformly samples s from Z 1 e 1 Z and computes the cyclic isogeny φ : E 0 E 1 E 0 P 1 + [ s ] Q 1 having P 1 + [ s ] Q 1 as kernel. It returns the statement-witness pair ( E 1 , φ ) .

  • com P 1 ( E 1 , φ ) : Given a statement E 1 and a corresponding witness φ , the prover uniformly samples r from Z 2 e 2 Z and computes the point R = P 2 + [ r ] Q 2 – whose order is 2 e 2 – and the elliptic curves E 2 = E 0 R and E 3 = E 1 φ ( R ) . Then, it uniformly samples b 2 , b 3 from { 0 , 1 } λ and commits to E 2 and E 3 computing com 1 O ( Com E 2 b 2 ) and com 2 O ( Com E 3 b 3 ) via the random oracle O . The output is com = ( com 1 , com 2 ) .

  • { 1 , 0 , 1 } V 1 ( com ) : On input a commitment com , V 1 outputs a random challenge ch { 1 , 0 , 1 } .

  • resp P 2 ( E 1 , φ , com , ch ) : On input a statement E 1 , a corresponding witness φ , a commitment com = ( com 1 , com 2 ) and a challenge ch { 1 , 0 , 1 } , it outputs a response resp defined as follows. If ch = 1 , then resp = ( E 2 , r , b 2 ) ; if ch = 1 , then resp = ( E 3 , φ ( R ) , b 3 ) ; if ch = 0 , then resp = ( E 2 , ψ ( Ker ( φ ) ) , E 3 , b 2 , b 3 ) , where ψ is the isogeny from E 0 having R as kernel.

  • 1 0 V 2 ( E 1 , com , ch , resp ) : It takes as input a statement E 1 , a commitment com = ( com 1 , com 2 ) , a challenge ch { 1 , 0 , 1 } , and a response resp . Depending on ch , the algorithm performs a check. In particular, if ch = 1 then resp = ( E , r , b ) and the algorithm checks whether the isogeny from E 0 with kernel equal to P 2 + [ r ] Q 2 goes to E and whether com 1 = O ( Com E b ) . If ch = 1 , then resp = ( E , T , b ) and the algorithm checks whether the point T is in E 1 , the order of T is 2 e 2 , the isogeny from E 1 with kernel T goes to E and com 2 = O ( Com E b ) . Finally, if ch = 0 , then resp = ( E , T , E ˜ , b , b ˜ ) and the algorithm checks whether the point T is in E , the order of T is 1 e 1 , the isogeny from E with kernel T goes to E ˜ , com 1 = O ( Com E b ) , and com 2 = O ( Com E ˜ b ˜ ) . If the check is successful, then it outputs 1, and 0 otherwise.

Let X be the set of supersingular elliptic curves E 1 over F p 2 having the same number of rational points of E 0 , and Y be the set of all separable isogenies with domain E 0 . Define the relation

SEC = { ( E 1 , φ ) E 1 X , φ Y , φ : E 0 E 1 , deg ( φ ) = 1 e 1 }

and the relaxed relation

˜ SEC = ( E 1 , w ) E 1 X and w = φ : E 0 E 1 , φ Y , deg ( φ ) = 2 2 i 1 e 1 with 0 i e 2 or w = ( x , x ) s.t. x x , O ( Com x ) = O ( Com x ) .

It is not difficult to see that the Σ -protocol Σ SEC described earlier is correct and has relaxed 3-special soundness for the relations SEC and ˜ SEC . Furthermore, under the assumption that the following problem is hard, we prove in Proposition 1 that Σ SEC is computationally HVZK.

Problem 1

(Decisional supersingular product problem) Let φ : E 0 E 1 be an isogeny of degree 1 e 1 . Given ( E 2 , E 3 , φ ) sampled with probability 1/2 from one of the following distributions, the decisional supersingular product problem DSSP pp requires to det ermine which distribution it is from:

  • Choose a random point R E 0 [ 2 e 2 ] of order 2 e 2 . Let ψ : E 0 E 2 and ψ : E 1 E 3 be the isogenies with kernels R and φ ( R ) , respectively. Then let φ : E 1 E 2 be the isogeny having ψ ( Ker ( φ ) ) as kernel, where deg ( φ ) = 1 e 1 .

  • Choose E 2 randomly among all the supersingular elliptic curves defined over F p 2 having the same number of rational points as E 0 . Then, choose a random point U E 2 of order 1 e 1 and compute the isogeny φ : E 2 E 3 having U as kernel.

Proposition 1

Let λ be a security parameter, and let pp = ( p , 1 , 2 , e 1 , e 2 , f , E 0 , P 1 , Q 1 , P 2 , Q 2 ) be the public parameters. The Σ -protocol Σ SEC is computationally HVZK for the relation SEC under DSSP pp , assuming that the commitment oracle is computationally hiding.

Proof

For ch = 1 , the simulator Sim O uniformly samples r from Z 2 e 2 Z and computes the isogeny ψ of kernel generator R = P 2 + [ r ] Q 2 and the elliptic curve E 2 = E 0 R . It then uniformly samples b 2 , b 3 $ { 0 , 1 } λ and sets com 1 O ( Com E 2 b 2 ) and com 2 O ( Com 1 b 3 ) . The isogeny ψ is computed as in the original protocol, so the transcript is valid. Under the assumption that the commitment oracle is computationally hiding, an adversary cannot distinguish between the simulated com 2 and a commitment computed following the protocol.

For ch = 1 , the simulator uniformly samples r from Z 2 e 2 Z , computes a basis { P 2 , Q 2 } of E 1 [ 2 e 2 ] and the isogeny ψ of kernel generator R = P 2 + [ r ] Q 2 , with codomain E 3 = E 1 R . It then uniformly samples b 2 , b 3 $ { 0 , 1 } λ and sets com 1 O ( Com 1 b 2 ) and com 2 O ( Com E 3 b 3 ) . The transcript is valid, since by construction we have that R E 1 , that its order is 2 e 2 and that the resulting φ has image E 3 . Without knowing the witness, an adversary cannot tell R , of order 2 e 2 , from a point of order 2 e 2 that is an image through φ . The mixing properties of supersingular isogeny graphs ensure that E 3 is randomly distributed, as it would be if it was computed following the protocol. Finally, if the commitment oracle is computationally hiding, the adversary cannot distinguish the simulated com 1 from a properly formed one.

For ch = 0 , the simulator samples r from Z 2 e 2 Z and computes the isogeny ψ of kernel generator R = P 2 + [ r ] Q 2 and the elliptic curve E 2 = E 0 R . Then it computes a basis { P , Q } of E 2 [ 1 e 1 ] , it samples s from Z 1 e 1 Z and the isogeny φ of kernel generator S = P + [ s ] Q , with codomain E 3 = E 2 S . It then uniformly samples b 2 , b 3 $ { 0 , 1 } λ and sets com 1 O ( Com E 2 b 2 ) and com 2 O ( Com E 3 b 3 ) . The transcript is valid, since S E 2 has order 1 e 1 and the kernel it generates is that of an isogeny from E 2 to E 3 . The adversary cannot tell the simulated point S from a properly formed ψ ( ker ( φ ) ) , otherwise it would have solved the DSSP pp instance. □

Remark 2

Within the protocol Σ SECUER base , the degree of the isogenies from E 0 to E 1 and from E 2 to E 3 is equal to 1 d 1 (with d 1 a suitable natural number bigger than e 1 ), while the degree of the isogenies from E 0 to E 2 and from E 1 to E 3 is equal to 2 d 2 (with d 2 a suitable natural number bigger than e 2 ). In this way, the protocol can be proved to be statistically HVZK [14, Prop. 17]. The conditions to satisfy this stronger property heavily affect both the transcript size and the execution times. Since in our work we are only interested in standard digital signatures, it is enough to rely on the computational HVZK property of the Σ -protocol. This allows us to preserve in full the SIDH parameters, including the degrees of the isogenies.

As the protocol Σ SEC has a soundness error ε = 2 3 , it is necessary to repeat its execution in parallel t times to obtain a negligible soundness error. It is customary to set t as the minimum positive integer such that ε t < 2 λ . Therefore, we obtain

(1) t > 1 log 2 ( 3 ) 1 λ 1.7 λ .

The Σ -protocol that results from repeating Σ SEC in parallel t -times, which will be denoted by Σ SEC t in the following, is depicted in Figure 1.

Figure 1 
                  Algorithms in 
                        
                           
                           
                              
                                 
                                    Σ
                                 
                                 
                                    SEC
                                 
                                 
                                    t
                                 
                              
                           
                           {\Sigma }_{{\mathsf{SEC}}}^{t}
                        
                     . Given a supersingular elliptic curve 
                        
                           
                           
                              E
                           
                           E
                        
                     , IsogenyFromKernel
                     
                        
                           
                           
                              
                                 (
                                 
                                    E
                                    ,
                                    ⋅
                                 
                                 )
                              
                           
                           \left(E,\cdot )
                        
                      denotes an algorithm which, on input a subgroup 
                        
                           
                           
                              S
                              ⊂
                              E
                           
                           S\subset E
                        
                     , computes an isogeny from 
                        
                           
                           
                              E
                           
                           E
                        
                      with kernel 
                        
                           
                           
                              S
                           
                           S
                        
                     . Moreover, 
                        
                           
                           
                              E
                              
                                 
                                    
                                       [
                                       
                                          
                                             
                                                ℓ
                                             
                                             
                                                e
                                             
                                          
                                       
                                       ]
                                    
                                 
                                 
                                    max
                                 
                              
                           
                           E{\left[{\ell }^{e}]}_{\max }
                        
                      denotes the points of order 
                        
                           
                           
                              
                                 
                                    ℓ
                                 
                                 
                                    e
                                 
                              
                           
                           {\ell }^{e}
                        
                      in 
                        
                           
                           
                              E
                              
                                 [
                                 
                                    
                                       
                                          ℓ
                                       
                                       
                                          e
                                       
                                    
                                 
                                 ]
                              
                           
                           E\left[{\ell }^{e}]
                        
                     , when 
                        
                           
                           
                              ℓ
                           
                           \ell 
                        
                      is prime and 
                        
                           
                           
                              e
                              ∈
                              N
                           
                           e\in {\mathbb{N}}
                        
                     .
Figure 1

Algorithms in Σ SEC t . Given a supersingular elliptic curve E , IsogenyFromKernel ( E , ) denotes an algorithm which, on input a subgroup S E , computes an isogeny from E with kernel S . Moreover, E [ e ] max denotes the points of order e in E [ e ] , when is prime and e N .

Assuming a supersingular elliptic curve over F p 2 is identified by a single element of F p 2 , the average size (in bits) of a transcript of Σ SEC t (excluding the statement) is approximated by

(2) transcript = 4 λ t + log(3) t + t 3 ( ( 2 log p + log 2 e 2 + λ ) + + ( 4 log p + 1 + λ ) + ( 6 log p + 1 + 2 λ ) ) .

where the terms indicate commitment , challenge, and response sizes (the terms within brackets correspond to the sizes of the responses to challenge 1 , 1, and 0).

Within an execution of Σ SEC t , the prover computes 2 t elliptic-curve scalar multiplications, 2 t isogenies and 2 t commitments to produce the commitment. In addition, to produce the response, the prover evaluates an 1 e 1 -isogeny (on a point of order 2 e 2 ) t 3 times, and an 2 e 2 -isogeny (on a point of order 1 e 1 ) t 3 times, on average.

When Σ SEC t is turned into the digital signature scheme DS SEC via the Fiat-Shamir transform, the security of DS SEC is guaranteed by the hardness of the relation ˜ SEC , as the problem of finding an isogeny between two given isogenous elliptic curves is still believed to be hard (and it has not been affected by the recent cryptanalytic attacks on SIDH ). A signature produced by DS SEC is just a transcript of Σ SEC t without the statement and the challenge (as the latter can be easily recovered, being it the digest of a hash function on the message m to sign and the commitment com ). Consequently, the signature size is slightly smaller than the size of a transcript (without the statement) of Σ SEC t , and the computational cost to sign is that undergone by the prover in an execution of Σ SEC t , plus one hash-function evaluation. Therefore, the efficiency analysis presented above applies almost directly to DS SEC (see the last column of Table 1 for the signature sizes of DS SEC for different SIDH/SIKE parameters).

Table 1

Average sizes (in bits) of the transcripts (excluding the statement) produced by Σ SEC t , and the average length of the signatures produced by DS SEC , working with different SIDH/SIKE parameters. The signature sizes are obtained from equation (2) minus the challenge length log ( 3 ) t

SIKE parameters log p λ t Transcript length Signature length
SIKEp 434 434 128 218 543,692 543,256
SIKEp 503 503 128 218 606,404 605,968
SIKEp 610 610 192 326 1,163,277 1,162,625
SIKEp 751 751 256 435 1,956,775 1,955,905

3 Signature-size optimisations

In this section, we apply some known cryptographic techniques to DS SEC to decrease the size of the signatures it produces. We start with some optimisations that determine a reduction of the signature size without causing any increase of the signing computations, and then we discuss those that have an impact on the signing time. We stress that none of the considered optimisations affects the security of DS SEC .

3.1 Challenge and commitment recoverability

A Σ -protocol ( Gen , P = ( P 1 , P 2 ) , V = ( V 1 , V 2 ) ) is said to be commitment-recoverable if, with overwhelming probability over the random choice of a pair ( x , w ) Gen ( 1 λ ) , for any ch ChSet and resp ResSet , there exists a unique commitment com ComSet that makes ( x , com , ch , resp ) a valid transcript, and such a commitment can be publicly computed by means of an algorithm taking ( x , ch , resp ) as input. This property allows for shorter signatures by omitting com from them, and letting the verifier re-compute it. Its correctness is then checked by means of the challenge ch .

The original version of the Σ -protocol Σ SEC t , described in Figure 1, does not satisfy commitment recoverability (e.g., the response resp i when ch i = 1 does not allow to recover com i , 2 ). However, we can modify ( Σ SEC and) Σ SEC t in such a way that the new protocol(s) are commitment recoverable.

The modification of Σ SEC t which we suggest[2] is detailed in Figure 2. In particular, P 1 remains unchanged, while the algorithm P 2 outputs the response resp i = ( r i , b 2 , i , com i , 2 ) when ch i = 1 ; the response resp i = ( φ ( P 2 + [ r i ] Q 2 ) , b 3 , i , com i , 1 ) when ch i = 1 ; and the response resp i = ( E 2 , i , ψ i ( Ker ( φ ) ) , b 2 , i , b 3 , i ) when ch i = 0 , where ψ i is the isogeny with kernel P 2 + [ r i ] Q 2 from E 0 . The verifier then re-computes part of the commitment, and checks whether it corresponds to that received by P 1 .

Figure 2 
                  Modified 
                        
                           
                           
                              
                                 
                                    Σ
                                 
                                 
                                    SEC
                                 
                                 
                                    t
                                 
                              
                           
                           {\Sigma }_{{\mathsf{SEC}}}^{t}
                        
                      protocol which enjoys commitment recoverability. The blue text marks the differences with the original scheme depicted in Figure 1.
Figure 2

Modified Σ SEC t protocol which enjoys commitment recoverability. The blue text marks the differences with the original scheme depicted in Figure 1.

The expected sizes (in bits) of the elements in a transcript of the modified Σ SEC t protocol (excluding the statement) are approximated by

(3) com = 4 λ t , ch = log ( 3 ) t , resp = t 3 ( ( log ( 2 e 2 ) + 3 λ ) + ( 2 log p + 1 + 3 λ ) + ( 4 log p + 1 + 2 λ ) )

(the terms within the brackets corresponds to the size of the responses to challenge 1 , 1, and 0, respectively).

In Table 2, we lists the approximated sizes (in bits) of commitments, challenges, and responses for the four SIKE parameter sets.

Table 2

Sizes (in bits) of the signatures of DS SEC (i.e. the transcripts of Σ SEC t excluding statements and challenges) produced by the modified Σ SEC t after applying challenge and commitment recoverability, for different SIDH/SIKE parameters. The “gain” column indicates by how much the signature lengths have reduced compared to those in Table 1

SIKE param. log p λ t com ch resp = signature Gain (%)
SIKEp 434 434 128 218 111,616 10 279,622 48.53
SIKEp 503 503 128 218 111,616 10 312,249 48.47
SIKEp 610 610 192 326 250,368 10 597,993 48.57
SIKEp 751 751 256 435 445,440 11 1,005,575 48.59

Remark 3

The gain column in Table 2 indicates how many bits (in percentage) we save when storing the response computed by the modified Σ SEC t after applying commitment and challenge recoverability. Each value is computed as ( s 0 s 1 ) s 0 , where s 0 is the average length of the response output by Σ SEC t , and s 1 is the average length of the response output by the modified version. Every time we will introduce a new optimisation, we will compute the gain it provides as ( s i s i 1 ) s 0 , where s i is the average response length produced by the version of Σ SEC t with the current and all previous modifications, and s i 1 , the response length with only the previous modifications. Note that in this way the overall gain provided by our optimisations can be obtained by simply adding together all the intermediate gains.

Thanks to commitment recoverability, when the modified Σ -protocol is turned into a digital signature, the commitment com does not need to be part of the corresponding signature. In principle, the challenge ch should now be part of the signature, as it necessary to recover the commitment com . However, the modified Σ SEC t protocol is also challenge-recoverable, and then ch can be excluded from the signature. We recall that a Σ -protocol is challenge-recoverable if the challenge ch in a transcript ( x , com , ch , resp ) can be reconstructed from resp . This is the case for both Σ SEC t and its modification, since the type of each resp i in resp uniquely determines the corresponding challenge bit ch i in ch . Thus, one can simply omit the challenge from a transcript and let it be deduced from the response. Consequently, both challenge and commitment can be reconstructed by the verifier. Therefore, the signature sizes for different SIDH/SIKE parameters are equal to the response sizes in Table 2. Moreover, we note that the computational effort made by the prover in the modified Σ SEC t protocol is exactly the same as in the original Σ SEC t protocol.

3.2 Compressed responses

In Σ SEC t , when ch i = 1 the prover responds with the point φ ( P 2 + [ r i ] Q 2 ) generating the kernel of the commitment isogeny ψ i : E 1 E 3 , i . Being P 2 and Q 2 over F p 2 by construction, this requires the transmission of 2 log p + 1 bits.

Following the algorithmic improvements proposed in the studies by Costello et al. and Azarderakhsh et al. [21,22], we can deterministically compute a torsion basis { P , Q } of E 1 [ 2 e 2 ] for any statement/public key E 1 . Then, the response can be set as the result ( α i , β i ) of a double discrete logarithm, with α i , β i such that [ α i ] P + [ β i ] Q = φ ( P 2 + [ r i ] Q 2 ) . Since φ ( P 2 + [ r i ] Q 2 ) is of order 2 e 2 , one of the two coefficients α i , β i must be invertible modulo 2 e 2 ; if it is α i , we let ι i 1 and γ i α i 1 β i , otherwise we let γ i 1 and ι i β i 1 α i . The response can then be set as ( ι i , γ i ), and the kernel generator computed as [ ι i ] P + [ γ i ] Q .

With this method, the size of the response is therefore reduced to log ( 2 e 2 ) + 1 bits, at the cost of computing a deterministic torsion basis both by signer and verifier, and determining a double discrete logarithm only on the signer’s side. Note that the basis P , Q can be computed once for all by adding it to the statement/public key E 1 . The new public key would look exactly like an old SIDH public key, with the crucial difference that the basis is computed independently of the secret isogeny φ , preventing the applicability of the attacks on SIDH to this context. Moreover, the following pre-computation would allow us to use the method of compressed responses at no additional computation cost. The prover needs to determine φ ( P 2 ) and φ ( Q 2 ) , and then compute their respective components α , β and γ , ω in the basis { P , Q } . Then, to compute a response, the prover would only need to calculate one multiplications and two sums in Z 2 e 2 Z , since φ ( P 2 + [ r i ] Q 2 ) = [ α + γ ] P + [ r i ( β + ω ) Q ] .

We stress that, since the number of bits of the response on challenge ch i = 1 is one bit shorter than the compressed response for the challenge ch i = 1 , the challenge recoverability of the protocol is preserved. The new response length is then computed as follows:

(4) resp = t 3 ( ( log ( 2 e 2 ) + 3 λ ) + ( log ( 2 e 2 ) + 1 + 3 λ ) + ( 4 log p + 1 + 2 λ ) ) .

Remark 4

The aforementioned compression method could also be applied for the case where ch = 0 , at the cost of a slow down, since a new canonical basis would need to be computed. Indeed, unlike for ch { ± 1 } , the curve E 2 varies for each challenge. We will therefore not consider this compression method for ch = 0 in Table 3.

Table 3

Sizes (in bits) of the responses produced by the modified Σ SEC t with compressed responses for different SIDH/SIKE parameters. Commitment and challenge lengths remain unchanged with respect to Table 2. The “gain" column is computed as the difference between the new signature lengths and the ones in Table 2 divided by the signature lengths from Table 1

SIKE param. log p λ t resp = signature Gain (%)
SIKEp 434 434 128 218 232,388 8.69
SIKEp 503 503 128 218 257,531 9.03
SIKEp 610 610 192 326 498,563 8.55
SIKEp 751 751 256 435 842,740 8.33

3.3 Seed trees

A primitive called seed tree [16] can be used to first generate a number of pseudorandom values and later efficiently disclose an arbitrary subset of them, without revealing any information on the values which are not disclosed. More precisely, a seed tree is a complete binary tree (i.e. a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible) of λ -bit seed values such that the left (resp. right) child of a λ -bit seed seed is the left (resp. right) half of the bit string Expand ( seed h ) , where h is a unique identifier for the position of seed in the binary tree. The seed values of a subset of the set of leaves can be efficiently revealed by sharing the appropriate set of internal seeds in the tree. As a simple example, if the sender (who created the complete binary tree) only provides the seed value associated to the left child of the root of the tree, then the recipient will only be able to recover the seed values associated to the leaves in the left half of the tree. Notably, the recipient will not learn any information about the leaves in the right half of the tree. A seed tree consists of four oracle-calling algorithms: SeedTree , ReleaseSeeds , RecoverLeaves , SimulateSeeds . Below, we recall the formal definitions of the first three algorithms, where Expand : { 0 , 1 } λ + log 2 ( t 1 ) { 0 , 1 } 2 λ is a Pseudo-random generator for any λ , t N , instantiated by a random oracle O .

  • SeedTree O ( seed root , t ) { leaf i } i { 1 , , t } : On input a root seed seed root { 0 , 1 } λ and an integer t N , the algorithm constructs a complete binary tree with t leaves by recursively expanding each seed to obtain its children seeds. Calls to the random oracle are of the form O ( Expand seed h ) , where h { 1 , , t 1 } identifies the position of seed in the binary tree. The algorithm finally outputs the list of seeds associated with the t leaves.

  • ReleaseSeeds O ( seed root , c , j ) seeds internal : On input a root seed seed root { 0 , 1 } λ , a bit string c { 1 , 0 , 1 } t , and j { 1 , 0 , 1 } , it outputs the list of seeds seeds internal that covers all the leaves with index i such that c i = j . Here, we say that a set of nodes F covers a set of leaves S if the union of the leaves of the subtrees rooted at each node v F is exactly the set S . Here, we note that each seed in seeds internal is coupled with an index which identifies its position in the binary tree.

  • RecoverLeaves O ( seeds internal , c , j ) { leaf i ¯ } i s.t. c i = j : On input a set seeds internal , a bit string c { 0 , 1 } t and a chosen j { 1 , 0 , 1 } , it computes and outputs all the leaves of the subtrees rooted at the seeds in seeds internal .

By construction, the leaves { leaf i } i s.t. c i = j output by SeedTree ( seed root , t ) are the same as those output by RecoverLeaves ( ReleaseSeeds ( seed root , c , j ) , c , j ) for any c { 0 , 1 } t and j { 1 , 0 , 1 } . We observe that the last algorithm SimulateSeeds can be used to argue that the seeds associated with all the leaves with index i such that c i j are indistinguishable from uniformly random values for a recipient that is only given seeds internal , c and j .

We now describe how seed trees can be used to optimise the modified Σ SEC t on two fronts. The optimisation we propose in the following is motivated by the observation that in the first three lines of P 1 (Figure 2), all the elements necessary to compute the inputs to the commitment oracle are sampled: the t random coefficients { r 1 , , r t } $ ( Z 2 e 2 Z ) t for the commitment curves ( E 2 , i , E 3 , i ) i = 1 t and two sets of random strings ( b 2 , 1 , , b 2 , t ) , ( b 3 , 1 , , b 3 , t ) $ { 0 , 1 } λ t . Of these inputs, only the coefficients need to be selectively opened, while the entirety of the random strings can be revealed (as their disclosure does not impact the computational HVZK property of the protocol).

Therefore, instead of independently choosing t coefficients and 2 t random bit-strings, 3 t seeds could be generated using two distinct seed trees, one for the coefficients which originates from the root seed root coeff and one for the random bit-strings which originates from the root seed root str . Then, instead of selectively revealing a subset of the 2 t bit strings according to the response algorithm P 2 , the prover could directly sends the initial seed seed root str used to generate them, letting the verifier compute them all. On the other hand, instead of responding with the random coefficients r i for the challenge bits ch i = 1 , the prover could output seeds internal ReleaseSeeds ( seed root coeff , ch , 1 ) . The verifier would then use seeds internal along with ch and j = 1 to recover the required seeds by running RecoverLeaves .

Let us analyse how generating all random strings from a single root seed seed root str and revealing it to the verifier affects the response length. Each random string is represented by λ bits, and without the use of seed trees, one of them is communicated if ch i = 1 or ch i = 1 , and two of them if ch i = 0 . For t responses resp i on challenges evenly distributed over { 1 , 0 , 1 } , this amounts to 1 3 t ( λ + λ + 2 λ ) = 4 3 t λ bits. If all random strings are generated with a seed tree from a root seed seed root str , releasing just the root seed requires only λ bits.

Such neat analysis cannot be performed on the application of the seed tree primitive to the generation of the coefficients r 1 , , r t , since the amount of internal seeds that need to be revealed depends on how 1 , 0, and 1 are distributed over the challenge string. In the worst-case scenario, i.e. when all the leaf seeds need to be revealed, instead of log p 2 bits for the coefficient r i , only λ bits for the generating seed need to be communicated.

The following equation (5) determines how seed trees affect the lengths of the responses produced by the modified Σ SEC t of Figure 2 when it also incorporates compressed responses (for challenges ch i = 1 ). In parenthesis, we add response lengths for ch i = 1 , 1 , 0 respectively, where the 2 λ addends represent the necessary information for commitment recoverability; the lengths of random strings ( b 2 , 1 , , b 2 , t ) , ( b 3 , 1 , , b 3 , t ) is removed from each response and replaced by a unique λ addend representing seed root str .

(5) resp = λ + t 3 ( ( λ + 2 λ ) + ( log ( 2 e 2 ) + 1 + 2 λ ) + ( 4 log p + 1 ) ) .

In Table 4, we report the numbers produced by equation (5) for different SIKE parameters. Table 4 differs from Table 3 only in the last two columns.

Table 4

Sizes (in bits) of the different components of the transcripts (excluding the statement) produced by the modified Σ SEC t of Figure 2 when it also incorporates compressed responses (for challenges ch i = 1 ) and seed trees. The “gain” indicates by how much the signature lengths have reduced compared to those in Table 3

SIKE param. log p λ t com ch resp = signature Gain (%)
SIKEp 434 434 128 218 111,616 10 188,771 8.03
SIKEp 503 503 128 218 111,616 10 211,370 7.62
SIKEp 610 610 192 326 250,368 10 403,020 8.22
SIKEp 751 751 256 435 445,440 11 676,681 8.49

3.4 Unbalanced challenge space

Equation (5) clearly shows that the response resp i when ch i = 0 is significantly bigger than when ch i { 1 , 1 } . As a consequence, one might consider to unbalance the challenge string ch in order to decrease the overall size of resp = ( resp i ) i = 1 t . Such modification was proposed in the study by Beullens et al. [16, Sec. 3.4.1], and has the extra positive effect of making the transcript/signature size constant. To be more concrete, the modification consists in choosing a positive integer K and performing M parallel executions of Σ SEC , exactly K of which use the unfavourable challenge bit 0. The number of challenges in { 1 , 0 , 1 } M having exactly K components equal to 0 is M K 2 M K . Equation 1 dictates that, for a given K , M should be selected in such a way that the success probability of a dishonest prover is bounded above by 2 λ , i.e.

(6) M K 2 M K n 2 λ .

Therefore, for generic M and K , it is necessary to find the maximal number n = n M , K of challenges to which a dishonest prover would be able to correctly reply. Afterwards, we will find the optimal M N and K { 0 , , t 3 } such that

(7) resp = λ + M K 2 ( ( λ + 2 λ ) + ( log ( 2 e 2 ) + 1 + 2 λ ) ) + K ( 4 log p + 1 )

is minimal. We first start by finding n .

Lemma 1

We can express n as follows:

(8) n = max h K 2 M h : h { K , , M } .

Proof

Let S be the set of all subsets U of { 1 , 0 , 1 } M consisting of elements of Hamming weight M K (i.e. elements with M K non-zero components) and such that, for any index i { 1 , , M } , U does not contain three elements whose i -th components are all distinct. Then n is the maximum cardinality among the sets in S . Given a set U S , let h U denote the number of indices i such that there exists a sequence in U that has a zero at index i , i.e.

h U # { i { 1 , , M } : x U , x i = 0 } .

Hence, for a set U S , we can have h U K choices for the entries that are zero. The remaining M h U entries can be either 1 or 1 , giving us 2 M h U choices. Therefore, the maximal size of a set U S is n as in equation (8).□

Proposition 2

Let h max denote a value of h realising the maximum of the set in Equation (8). Then h max = 2 K and

n = 2 K K 2 M 2 K .

Proof

Let us study the behaviour of the discrete function f ( h ) h K 2 M h taking values in { K , , M } , with parametrised integers K < M . We start by noticing that the left factor h K is monotonically increasing, while the right factor 2 M h is monotonically decreasing, with ratio 2 M h 2 M ( h + 1 ) = 2 for any value of h .

The function f ( h ) is initially increasing, since the left factor grows faster than how the right factor decreases. In fact, for any h K ,

h + 1 K h K = h + 1 h + 1 K > 2 h < 2 K 1 .

For h = 2 K 1 , the ratio between the binomial coefficients for h and h + 1 is exactly 2, so f ( 2 K 1 ) = f ( 2 K ) .

For any h > 2 K 1 , the function f is decreasing, since h + 1 K h K < 2 for 2 K h < M .

We conclude by arbitrarily choosing h max = 2 K as a value of h maximising f (one can equivalently set h max = 2 K 1 , obtaining a less neat formula), and thus n = 2 K K 2 M 2 K . □

As an example, when λ = 128 and K is set to 75, it is sufficient to have M = 247 parallel runs of Σ SEC , since here the value h max giving us the maximal size of U is 150. The values of M and K that optimally minimise the length of the response for different SIDH/SIKE parameters are collected in Table 5.

Table 5

Values of M and K for the unbalanced challenge space that minimise the response length of the modified Σ SEC M for different SIDH/SIKE parameters still guaranteeing a negligible soundness error. The size of resp is in bits, while the “gain" column reports by how much the signature lengths have reduced compared to those in Table 4

SIKE parameters log p λ M K h max resp Gain (%)
SIKEp 434 434 128 250 48 96 154,783 6.26
SIKEp 503 503 128 250 48 96 169,041 6.99
SIKEp 610 610 192 362 76 152 336,095 5.76
SIKEp 751 751 256 478 103 206 571,453 5.38

To obtain the values in Table 5, we simply run through all values of M , up to a very large upper bound (say twice the value of the corresponding t ), and all values of K { 0 , , t 3 } and pick out the values ( M , K ) minimizing resp . As expected, the values of M obtained end up being very close (just a little bit bigger) than the corresponding values of t (which can be found, for example, in Table 4).

3.5 Summary

We conclude this section highlighting the overall gain in applying challenge and commitment recoverability, compressed responses, seed trees, and unbalanced challenge space optimisations to the Σ SEC protocol. We phrase the results in terms of signature sizes:

  • for SIKEp 434 , we shorten the signature from 66.31 kB to at most 18.89 kB, corresponding to a reduction of at least 71.51%,

  • for SIKEp 503 , we shorten the signature from 73.97 kB to at most 20.63 kB, corresponding to a reduction of at least 72.10%,

  • for SIKEp 610 , we shorten the signature from 141.92 kB to at most 41.03 kB, corresponding to a reduction of at least 71.09%,

  • for SIKEp 751 , we shorten the signature from 238.76 kB to at most 69.76 kB, corresponding to a reduction of at least 70.78%.

We also note that all the optimisations discussed in this section could be extended to the distributed trusted-setup protocol [14, Sec. 5] built on top of Σ SECUER base to collaboratively produce a random supersingular elliptic curve whose endomorphism ring is hard to compute even for the parties who did the sampling (Table 6).

Table 6

Overall gains in applying all the proposed optimisations to the Σ SEC protocol

SIKE parameters log p λ resp (kB) Total gain (%)
SIKEp 434 434 128 18.89 71.51
SIKEp 503 503 128 20.63 72.1
SIKEp 610 610 192 41.03 71.09
SIKEp 751 751 256 69.76 70.78

4 Running-time optimisations

In an execution of the Σ -protocol Σ SEC t , 2 t commitment isogenies need to be computed. The same holds for all the modified protocols introduced in Section 3, including the one that considers fixed-weight challenges, which we denote by Σ SEC M (see Section 3.4). All such isogenies have degree 2 e 2 – half of them originate from E 0 and half from E 1 .

We now present two optimisations that take advantage of the computation of several isogenies of the same degree from the same supersingular elliptic curve. Despite focusing on Σ SEC t (and, implicitly, on Σ SEC M ), both optimisations could be extended to the distributed trusted-setup protocol [14, Sec. 5] built on top of Σ SECUER base .

To better explain such optimisations, we recall the fastest generic method to compute a cyclic isogeny of degree 2 e 2 from its kernel. For simplicity, we specialise our presentation to the SIKE parameters, and therefore in the following, we will replace 1 with 2, 2 with 3, e 1 with a and e 2 with b .

Let ψ be an isogeny of degree 3 b from a supersingular elliptic curve E over F p 2 , with kernel generated by R P + [ r ] Q for some basis { P , Q } of E [ 3 b ] and some r Z 3 b Z . The isogeny ψ can be expressed as the composition ψ = ψ ( b ) ψ ( b 1 ) ψ ( 1 ) = j = 0 b 1 ψ ( b j ) , where each ψ ( j ) has degree 3. The first isogeny ψ ( 1 ) of such decomposition is the isogeny whose kernel is generated by [ 3 b 1 ] R . Then ψ ( 2 ) is the isogeny with kernel generated by [ 3 b 2 ] ψ ( 1 ) ( R ) , and so on until ψ ( b ) , the last 3-isogeny with kernel generated by ψ ( b 1 ) ( ( ψ ( 1 ) ( R ) ) ) .

The strategies described in [23, Appendix D] speed up the computation of ψ = ψ ( b ) ψ ( b 1 ) ψ ( 1 ) by minimising the number of operations to execute. We give a high-level description of these strategies in the following lines. To recursively determine the kernels of and computing the 3-isogenies in the decomposition ψ = j = 0 b 1 ψ ( b j ) , the strategies combine two operations: scalar multiplication and isogeny evaluation. Each of these two operations runs in a certain time, with the latter slightly faster than the former. The goal of the strategies is that of minimising the overall computational cost. Referring to Figure 3, we can graphically describe their goal and how they operate. In particular, they aim to obtain the points on the hypotenuse of the right-angled triangle using the least amount of arrows – with blue arrows representing scalar multiplications by 3 and red arrows representing 3-isogeny evaluations – under the condition that the ( i + 1 ) -th line from the top cannot be accessed before reaching the rightmost point on the i -th line from the top, i.e. before the computation of the 3-isogeny ψ ( i ) . In fact, the elements on the hypotenuse, from the top-right corner to the bottom-left corner, represent the kernels of ψ ( 1 ) , ψ ( 2 ) , , ψ ( b ) , respectively. The naive (standard) approach to compute ψ = j = 0 b 1 ψ ( b j ) would be to start at the first line, go all the way to the right, then move down to the next line, and go all the way to the right, and so on. However, there exist alternative strategies which accelerate the computations. In particular, Figure 3 depicts the optimal strategy proposed in [23, Appendix D] for the case b = 6 (the general strategy for a generic b is just a generalisation of it).

Figure 3 
               Graphical representation of the optimal strategy proposed in the study by Azarderakhsh et al. [23, Appendix D] for the case 
                     
                        
                        
                           b
                           =
                           6
                        
                        b=6
                     
                   to compute a 
                     
                        
                        
                           
                              
                                 3
                              
                              
                                 6
                              
                           
                        
                        {3}^{6}
                     
                  -isogeny from a kernel generator 
                     
                        
                        
                           R
                        
                        R
                     
                  . Blue arrows represent scalar multiplications by 3, red arrows represent 3-isogeny evaluations.
Figure 3

Graphical representation of the optimal strategy proposed in the study by Azarderakhsh et al. [23, Appendix D] for the case b = 6 to compute a 3 6 -isogeny from a kernel generator R . Blue arrows represent scalar multiplications by 3, red arrows represent 3-isogeny evaluations.

4.1 Computing several isogenies in parallel

We now go back to the computation of 2 t commitment isogenies within an execution of Σ SEC t (or within one of its variations). To outline the first optimisation we propose, we restrict our attention to the isogenies ψ 1 , , ψ t which originate from E 0 . Analogous considerations hold for the isogenies originating from E 1 .

As we saw earlier, for i { 1 , , t } , the fastest method to compute ψ i from its kernel P 2 + [ r i ] Q 2 – where { P 2 , Q 2 } is a basis of E 0 [ 3 b ] – is that of determining the composition ψ i ( b ) ψ i ( b 1 ) ψ i ( 1 ) of 3-isogenies. We then observe that there are 3 possible values for ψ i ( 1 ) , 3 2 for ψ i ( 2 ) , 3 3 for ψ i ( 3 ) , and so on. For example, the three possible values for ψ i ( 1 ) have [ 3 b 1 ] P 2 + [ 0 3 b 1 ] Q 2 , [ 3 b 1 ] P 2 + [ 1 3 b 1 ] Q 2 and [ 3 b 1 ] P 2 + [ 2 3 b 1 ] Q 2 as kernels. Since t = 218 for SIKEp 434 and SIKEp 503 , t = 326 for SIKEp 610 and t = 435 for SIKEp 751 , some of the possible 3-isogenies will surely occur multiple times[3]. In particular, for j { 1 , , b } and two different i , i { 1 , , t } , it holds that

(9) ψ i ( j ) ψ i ( 1 ) = ψ i ( j ) ψ i ( 1 ) r i r i ( mod 3 j ) .

After a few steps, however, repetitions are expected to stop occurring (for the rapid-mixing property of supersingular isogeny graphs). For example, considering the SIKEp 434 parameters, since there are 3 5 = 243 possible values for r i ( mod 3 5 ) and t = 218 , the fourth is the last factor where we can still expect a good amount[4] of repetitions.

Given the aforementioned observations, a speed-up in computing the t isogenies of degree 3 b from E 0 can be obtained by avoiding repeatedly computing 3-isogenies which occur multiple times. To be more precise, this can be achieved by pre-computing all possible values for ψ i ( 1 ) , , ψ i ( α ) – with α being the biggest positive integer such that 3 α < t – and then, for every i { 1 , , t } , calculating the congruence classes of r i modulo 3 , 3 2 , , 3 α to determine ψ i ( 1 ) , , ψ i ( α ) , respectively. Alternatively, for each i { 1 , , t } and j { 1 , , α } , the congruence class of r i modulo 3 j can be determined before computing the kernel of ψ i ( j ) and the isogeny itself. If such congruence class matches the one of a coefficient r k with k { 1 , , j 1 } , then the kernel of ψ i ( j ) and the isogeny itself do not need to be re-computed, since ψ i ( j ) = ψ h ( j ) .

Figure 4 shows how the modular-arithmetic checks can be exploited within the optimal strategies proposed in the study by Azarderakhsh et al. [23, Appendix D]. In particular, they grant the possibility of moving from line 1 to line α + 1 (where α is equal to 3 in the toy example depicted in the figure) without the need to reach the rightmost of the first α lines. In other words, the vertical orange arrows can be simply determined form the modular-arithmetic checks.

Figure 4 
                  By doing some pre-computation or avoiding the multiple computation of 3-isogenies, the optimal strategy from [23, Appendix D] to compute and evaluate a 
                        
                           
                           
                              
                                 
                                    3
                                 
                                 
                                    6
                                 
                              
                           
                           {3}^{6}
                        
                     -isogeny from a kernel generator 
                        
                           
                           
                              R
                           
                           R
                        
                      is granted the possibility to move from line 1 to line 
                        
                           
                           
                              α
                              +
                              1
                           
                           \alpha +1
                        
                      (with 
                        
                           
                           
                              α
                              =
                              3
                           
                           \alpha =3
                        
                      in the figure) without the need to reach the right most of the first 
                        
                           
                           
                              α
                           
                           \alpha 
                        
                      lines. In particular, the points in boxes can be obtained instantly from modular-arithmetic checks, and they determine, in turn, the vertical orange arrows.
Figure 4

By doing some pre-computation or avoiding the multiple computation of 3-isogenies, the optimal strategy from [23, Appendix D] to compute and evaluate a 3 6 -isogeny from a kernel generator R is granted the possibility to move from line 1 to line α + 1 (with α = 3 in the figure) without the need to reach the right most of the first α lines. In particular, the points in boxes can be obtained instantly from modular-arithmetic checks, and they determine, in turn, the vertical orange arrows.

To evaluate the advantage in applying the described tweak, we first deduce formulas for the number of horizontal and vertical arrows, respectively, required in the optimal strategies from the study by Azarderakhsh et al. [23, Appendix D] to compute isogenies of degree 3 b :

(10) H os ( b ) = 3 b 4 2 , V os ( b ) = b + 1 2 2 ( b mod 2 ) .

We borrow from the study by Azarderakhsh et al. [23, Appendix D] the costs (in cycles) of a point-tripling operation, p 3 , and of computation and evaluation of a 3-isogeny, q 3 . With them and Equation (10), we calculate the cost of the optimal strategies from [23, Appendix D] to compute t isogenies of degree 3 b , and we compare it with the cost when pre-computation is performed. The results are presented in Table 7. For example, for SIKEp 434 , t is equal to 218, b = 137 , p 3 = 5,322 , and q 3 = 5,282 , with the total cost for computing t isogenies of degree 3 137 via the optimal strategy being

218 ( V os ( 137 ) q 3 + H os ( 137 ) p 3 ) = 5,716,545,548 .

Table 7

Costs (in clock cycles and kilobytes of storage) and percentage gains in using the pre-computation tweak to compute t commitment isogenies in Σ SEC t and in its unbalanced challenge variant Σ SEC t , U compared to those of using the optimal strategies from the study by Azarderakhsh et al. [23, Appendix D], for different SIKE parameter sets

Protocol SIKE parameters t b Old cost (cc) New cost (cc) Gain (%) Storage (kB)
Σ SEC t SIKEp 434 218 137 5,716,545,548 5,400,988,804 5.52% 13.035
SIKEp 503 218 159 7,642,101,180 7,275,879,492 4.79 15.105
SIKEp 610 326 192 16,365,527,304 15,704,201,096 4.04 55.41
SIKEp 751 435 239 33,908,315,250 32,272,252,410 4.82 68.2
Σ SEC t , U SIKEp 434 250 137 6,555,671,500 6,019,478,500 8.18 39.43
SIKEp 503 250 159 8,763,877,500 8,140,531,500 7.11 45.65
SIKEp 610 362 192 18,172,763,448 17,438,407,352 4.04 55.41
SIKEp 751 478 239 37,260,171,700 35,462,383,108 4.82 68.2

If isogenies are pre-computed and selected using modular arithmetics according to equation (9), we can start each isogeny computation from the fifth line (as noted earlier, we expect a good amount of repetitions in the first four factors when t = 218 ), thus reducing the amount of arrows to compute. In this case, H os ( 137 ) = H os ( 137 4 ) horizontal arrows and V os ( 137 ) = V os ( 137 4 ) + 4 vertical arrows are required to compute a single 3 137 -isogeny. The total cost of computing 218 isogenies of degree 3 137 in parallel is

218 ( V os ( 133 ) q 3 + 4 q 3 + H os ( 133 ) p 3 ) = 5,396,382,900 ,

which corresponds to an efficiency increase of 5.60 % for SIKEp 434 parameters.

We can analogously compute the savings determined by our tweak for the other SIKE parameter sets, pre-computing the first 5 steps for SIKEp 610 and SIKEp 751 (in which cases 3 5 < t ). The results are summarised in Table 7, where we also indicate the cost of storing the pre-computed kernel generators of all possible initial steps ψ 1 , ψ 4 .

For comparison with the parallel strategy with pre-computation, we now describe a sequential approach to speed up Σ SEC t by avoiding recomputing the same steps several times, but without introducing any pre-computations. When we compute the first isogeny ψ 1 from its coefficient r 1 , we store the kernels of its first four initial steps. When computing the second isogeny, we first check whether r 2 r 1 ( mod 3 j ) for any j = 1 , 2 , 3 , 4 : if so, we already have the kernel for that step, and we can save all horizontal lines that would be required to compute it; if not, we compute the kernel corresponding to that step and store it. Repeating this simple procedure would allow us to compute the initial steps of all t isogenies ψ 1 , , ψ t without repeating the same unnecessary scalar multiplications, at the cost of evaluating modular equivalences. To analyse the cost of this strategy, let us start from the one when we considered pre-computations, and let us increase it by the extra cost of performing scalar multiplications in the first 4 steps. In particular, we need 3 ( b 1 ) scalar multiplications to obtain the three possibilities for ψ i ( 1 ) ; as per the optimal strategy, we need 3 2 isogeny evaluations on the kernels 3 b 2 R i to obtain the nine possibilities for ψ i ( 2 ) . Then again, we perform 3 3 ( b 3 ) scalar multiplications to obtain the 27 possibilities for ψ i ( 3 ) , and finally 3 4 isogeny evaluations to obtain the 81 possibilities for ψ i ( 4 ) . The total cost of this strategy is therefore

t ( V os ( b 4 ) q 3 + 4 q 3 + H os ( b 4 ) p 3 ) + ( 30 b 84 ) p 3 + 90 q 3 ,

for SIKEp 434 and SIKEp 503 and

t ( V os ( b 5 ) q 3 + 5 q 3 + H os ( b 5 ) p 3 ) + ( 264 b 1,254 ) p 3 + 90 q 3 ,

for SIKEp 610 and SIKEp 751 (considering the fact that repetitions occur in the fifth step as well), and it requires the same amount of extra storage as the pre-computation strategy. The results for all SIKE parameter sets are presented in Table 8.

Table 8

Costs (in clock cycles and kilobytes of storage) and percentage gains in computing t commitment isogenies in Σ SEC t following the strategy that avoids pre-computation but performs modular-arithmetic checks on-the-fly, compared to those of the optimal strategy from [23, Appendix D], for different SIKE parameter sets

SIKE parameters t b Old cost (cc) New cost (cc) Gain (%) Storage (kB)
SIKEp 434 218 137 5,716,545,548 5,422,890,556 5.14 13.035
SIKEp 503 218 159 7,642,101,180 7,301,293,764 4.46 15.105
SIKEp 610 326 192 16,365,527,304 15,967,764,224 2.43 55.41
SIKEp 751 435 239 33,908,315,250 32,601,850,914 3.85 68.2

4.2 Computing multiple scalar multiplications in parallel

Following the optimisations presented in the previous section, we note that many points belonging to E 0 must be computed. These points are used in the commitment generation of Σ SEC t (or in one of its variants), and are the kernel generators R 1 , R 2 , R t , where each R i = P 2 + [ r i ] Q 2 is obtained by randomly sampling r i from Z 2 e 2 Z (or by using a seed tree, as shown in Section 3.3).

We now discuss how to calculate all R i ’s in parallel and obtain some computational savings. An analogous strategy can be applied to parallelise the computation of the kernel generators of the commitment isogenies which originate from E 1 .

For each R i , the scalar multiplication [ r i ] Q 2 can be performed using the classical double-and-add strategy, in which the points that obtain doubled and (possibly) added at each step are multiples of Q 2 . Hence, we can perform the multiple doublings of Q 2 only once for all R i ’s, as detailed in Figure 5, where m is the minimum number of bits necessary to represent any coefficient in Z 2 e 2 Z , and r i = ( r i 0 , r i 1 , , r i m 1 ) 2 is the little-endian binary representation of r i Z 2 e 2 Z .

Figure 5 
                  Algorithm to compute 
                        
                           
                           
                              t
                           
                           t
                        
                      coefficients 
                        
                           
                           
                              
                                 
                                    R
                                 
                                 
                                    i
                                 
                              
                              =
                              
                                 
                                    P
                                 
                                 
                                    2
                                 
                              
                              +
                              
                                 [
                                 
                                    
                                       
                                          r
                                       
                                       
                                          i
                                       
                                    
                                 
                                 ]
                              
                              
                                 
                                    Q
                                 
                                 
                                    2
                                 
                              
                           
                           {R}_{i}={P}_{2}+\left[{r}_{i}]{Q}_{2}
                        
                      in parallel.
Figure 5

Algorithm to compute t coefficients R i = P 2 + [ r i ] Q 2 in parallel.

In analysing how much this strategy saves us, let Hw ( r i ) denote the Hamming weight (i.e. the number of non-zero components) of the binary representation of the coefficient r i , and let cADD and cDBL denote the cost (in cycles) of adding and doubling points over an elliptic curve, respectively. With a naive approach, we would perform m 1 doublings and Hw ( r i ) + 1 additions (with “ + 1 " counting for the last addition by P 2 ) for each R i , at a total cost of

t ( m 1 ) cDBL + i = 1 t ( Hw ( r i ) + 1 ) cADD .

With our parallelised approach presented in Figure 5, we still perform the same amount Hw ( r i ) + 1 of additions for each R i , but the m 1 doublings are performed once for all the R i ’s, which saves us ( t 1 ) ( m 1 ) cDBL (at least 99% of the doublings for any t 100 , as in our case study).

5 Conclusions

We have assessed the efficiency of a SIDH-based digital signature built on a weaker but more efficient variant of the recent identification protocol Σ SECUER base from the study by Basso et al. [14, Section 4]. The Σ -protocol we consider only achieves computational honest-verifier zero-knowledge instead of the stronger notion of statistical honest-verifier zero-knowledge, but it allows for shorter isogenies. We have conducted our analysis by applying some known cryptographic techniques to decrease the signature size and proposing a minor optimisation to compute many isogenies in parallel from the same starting curve. In addition, we provide novel results on unbalanced challenge space with ternary challenges. Our assessment confirms that the problem of designing a practical isogeny-based signature scheme remains largely open. Nonetheless, the proposed optimisations can be applied to the distributed trusted-setup protocol [14, Sec. 5] built on top of Σ SECUER base to collaboratively produce a random supersingular elliptic curve whose endomorphism ring is hard to compute even for the parties who participated in the sampling.

Acknowledgements

This work has been accepted for presentation at CIFRIS23, the Congress of the Italian association of cryptography "De Componendis Cifris.”

  1. Funding information: None declared.

  2. Author contributions: All authors have accepted responsibility for the entire content of this manuscript and approved its submission. As common practice in cryptography, the authors have not followed the SDC approach; instead, they have sorted the authors alphabetically.

  3. Conflict of interest: Dr. Federico Pintore is an Editorial Board member of the Journal of Mathematical Cryptology and was not involved in the review process of this article.

  4. Data availability statement: Data sharing is not applicable to this article as no datasets were generated or analysed during the current study.

References

[1] De Feo L, Kohel D, Leroux A, Petit C, Wesolowski B. SQISign: compact post-quantum signatures from quaternions and isogenies. International Conference on the Theory and Application of Cryptology and Information Security. 2020. Vol. 8. Issue 3; p. 64–93. 10.1007/978-3-030-64837-4_3Search in Google Scholar

[2] Feo LD, Leroux A, Longa P, Wesolowski B. New algorithms for the Deuring correspondence - towards practical and secure SQISign signatures. In: Hazay C, Stam M, editors. Advances in Cryptology - EUROCRYPT 2023 – 42nd Annual International Conference on the Theory and Applications of Cryptographic Techniques, Lyon, France, April 23–27, 2023, Proceedings, Part V. Vol. 14008 of Lecture Notes in Computer Science. Springer; 2023. p. 659–90. 10.1007/978-3-031-30589-4_23. Search in Google Scholar

[3] De Feo L, Jao D, Pluuuut J. Towards quantum-resistant cryptosystems from supersingular elliptic curve isogenies. J Math Cryptol. 2014;8(3):209–47. 10.1515/jmc-2012-0015Search in Google Scholar

[4] Jao D, Azarderakhsh R, Campagna M, Costello C, De Feo L, Hess B, et al. SIKE. National Institute of Standards and Technology; 2017. //csrc.nist.gov/projects/post-quantum-cryptography/round-1-submissions. Search in Google Scholar

[5] Galbraith SD, Petit C, Silva J. Identification protocols and signature schemes based on supersingular isogeny problems. J Cryptol. 2020;33(1):130–75. 10.1007/s00145-019-09316-0Search in Google Scholar

[6] Yoo Y, Azarderakhsh R, Jalali A, Jao D, Soukharev V. A post-quantum digital signature scheme based on supersingular isogenies. In: FC. Springer; 2017. p. 163–81. 10.1007/978-3-319-70972-7_9Search in Google Scholar

[7] Castryck W, Decru T. An efficient key recovery attack onÂăSIDH. In: Hazay C, Stam M, editors. Advances in cryptology - EUROCRYPT 2023. Cham: Springer Nature Switzerland; 2023. p. 423–47. 10.1007/978-3-031-30589-4_15Search in Google Scholar

[8] Maino L, Martindale C, Panny L, Pope G, Wesolowski B. A direct key recovery attack on SIDH. In: Hazay C, Stam M, editors. Advances in Cryptology - EUROCRYPT 2023 - 42nd Annual International Conference on the Theory and Applications of Cryptographic Techniques, Lyon, France, April 23–27, 2023, Proceedings, Part V. Vol. 14008 of Lecture Notes in Computer Science. Springer; 2023. p. 448–71. 10.1007/978-3-031-30589-4_16. Search in Google Scholar

[9] Robert D. Breaking SIDH in polynomial time. In: Hazay C, Stam M, editors. Advances in Cryptology - EUROCRYPT 2023 - 42nd Annual International Conference on the Theory and Applications of Cryptographic Techniques, Lyon, France, April 23–27, 2023, Proceedings, Part V. Vol. 14008 of Lecture Notes in Computer Science. Springer; 2023. p. 472–503. 10.1007/978-3-031-30589-4_17. Search in Google Scholar

[10] De Feo L, Galbraith SD. SeaSign: compact isogeny signatures from class group actions. In: Ishai Y, Rijmen V, editors. Advances in Cryptology - EUROCRYPT 2019, Part III. Vol. 11478 of Lecture Notes in Computer Science. Darmstadt, Germany: Springer, Heidelberg, Germany; 2019. p. 759–89. 10.1007/978-3-030-17659-4_26Search in Google Scholar

[11] Beullens W, Kleinjung T, Vercauteren F. CSI-FiSh: efficient isogeny based signatures through class group computations. In: Galbraith SD, Moriai S, editors. Advances in Cryptology - ASIACRYPT 2019, Part I. Vol. 11921 of Lecture Notes in Computer Science. Kobe, Japan: Springer, Heidelberg, Germany; 2019. p. 227–47. 10.1007/978-3-030-34578-5_9Search in Google Scholar

[12] Chávez-Saab J, Chi-Domiiiinguez JJ, Jaques S, Rodríguez-Henríquez F. The SQALE of CSIDH: sublinear Vélu quantum-resistant isogeny action with low exponents. J Cryptograph Eng. 2022 Sep;12(3):349–68. 10.1007/s13389-021-00271-wSearch in Google Scholar

[13] Feo LD, Dobson S, Galbraith SD, Zobernig L. SIDH proof of knowledge. In: Agrawal S, Lin D, editors. Advances in Cryptology - ASIACRYPT 2022 – 28th International Conference on the Theory and Application of Cryptology and Information Security, Taipei, Taiwan, December 5–9, 2022, Proceedings, Part II. Vol. 13792 of Lecture Notes in Computer Science. Springer; 2022. p. 310–39. 10.1007/978-3-031-22966-4_11. Search in Google Scholar

[14] Basso A, Codogni G, Connolly D, Feo LD, Fouotsa TB, Lido GM, et al. Supersingular curves you can trust. In: Hazay C, Stam M, editors. Advances in Cryptology - EUROCRYPT 2023 – 42nd Annual International Conference on the Theory and Applications of Cryptographic Techniques, Lyon, France, April 23–27, 2023, Proceedings, Part II. Vol. 14005 of Lecture Notes in Computer Science. Springer; 2023. p. 405–37. 10.1007/978-3-031-30617-4_14. Search in Google Scholar

[15] Chi-Domínguez JJ. A Note on Constructing SIDH-PoK-based Signatures after Castryck-Decru Attack; 2022. //eprint.iacr.org/2022/1479. Cryptology ePrint Archive, Paper 2022/1479. //eprint.iacr.org/2022/1479. Search in Google Scholar

[16] Beullens W, Katsumata S, Pintore F. Calamari and Falafl: logarithmic (linkable) ring signatures from isogenies and lattices. In: International Conference on the Theory and Application of Cryptology and Information Security; 2020. p. 464–92. 10.1007/978-3-030-64834-3_16Search in Google Scholar

[17] Chi-DomAηnguez JJ, Mateu V, Perin LP. SIDH-sign: an efficient SIDH PoK-based signature; 2022. //eprint.iacr.org/2022/475. Cryptology ePrint Archive, Paper 2022/475. //eprint.iacr.org/2022/475. Search in Google Scholar

[18] Fiat A, Shamir A. How to prove yourself: practical solutions to identification and signature problems. In: Advances in Cryptology - CRYPTO ’86, Santa Barbara, California, USA, 1986, Proceedings. Vol. 263 of Lecture Notes in Computer Science. Springer; 1986. p. 186–94. 10.1007/3-540-47721-7_12Search in Google Scholar

[19] Silverman JH. The arithmetic of elliptic curves. Vol. 106. New York: Springer; 2009. 10.1007/978-0-387-09494-6Search in Google Scholar

[20] Galbraith SD. Mathematics of public key cryptography. Cambridge, UK: Cambridge University Press; 2012. //books.google.no/books?id=owd76BElvosC. 10.1017/CBO9781139012843Search in Google Scholar

[21] Costello C, Longa P, Naehrig M. Efficient algorithms for supersingular isogeny Diffie-Hellman. In: Robshaw M, Katz J, editors. Advances in Cryptology - CRYPTO 2016, Part I. Vol. 9814 of Lecture Notes in Computer Science. Santa Barbara, CA, USA: Springer, Heidelberg, Germany; 2016. p. 572–601. 10.1007/978-3-662-53018-4_21Search in Google Scholar

[22] Azarderakhsh R, Jao D, Kalach K, Koziel B, Leonardi C. Key compression for isogeny-based cryptosystems. In: Proceedings of the 3rd ACM International Workshop on ASIA Public-Key Cryptography; 2016. p. 1–10. 10.1145/2898420.2898421Search in Google Scholar

[23] Azarderakhsh R, Campagna M, Costello C, De Feo L, Hess B, Jalali A, et al. Supersingular isogeny key encapsulation november 30, 2017. Third Round Candidate of the NIST’s post-quantum cryptography standardization process; 2020. //sikeorg/. Search in Google Scholar

Received: 2023-09-05
Revised: 2023-10-10
Accepted: 2023-10-10
Published Online: 2024-03-06

© 2024 the author(s), published by De Gruyter

This work is licensed under the Creative Commons Attribution 4.0 International License.

Downloaded on 12.9.2025 from https://www.degruyterbrill.com/document/doi/10.1515/jmc-2023-0023/html
Scroll to top button