Cécile Antoine Joux

Cécile Pierrot

Keywords: Cryptography, Discrete logarithms, Finite fields

Introduction

The discrete logarithm is, together with integer factorization, one of the main candidate hard problems used to construct public key cryptosystems. Its cryptographic use was started by Diffie and Hellman in their seminal paper [START_REF] Diffie | New directions in cryptography[END_REF] where they introduced the notion of public-key cryptography. This problem can be stated in the following way: let G be a finite cyclic group (usually denoted multiplicatively) of order N and g a generator of G. Since we have computations in mind, we assume the availability of efficient algorithms to compute in G. In particular, multiplication of elements should be efficient. We now consider the map that sends an integer n to g n in G. This map can be efficiently computed with O(log n) multiplications using the square-and-multiply algorithm. In the sequel, we call it discrete exponentiation. Discrete exponentiation is a periodic map of period N , surjective onto G. In fact, it defines an isomorphism Φ between G and the additive group (Z/N Z, +). The inverse isomorphism Φ -1 is called the discrete logarithm in basis g. It maps g n to the class of n modulo N .

Depending on the algorithmic description of the group G, computing discrete logarithms might be very easy or much more difficult. On the one hand, if we choose for G the group (Z/N Z, +) itself, computing discrete logarithms is a trivial matter. On the other hand, there exist hardness results in the generic group model [START_REF] Shoup | Lower bounds for discrete logarithms and related problems[END_REF] which show that to compute discrete logarithms efficiently, it is essential to understand and make use of the algorithmic description of G. In generic groups, computing a discrete logarithm costs at 613 [START_REF] Joux | The function field sieve is quite special[END_REF] Joux, Lercier 2012/06 3 6•97 923 [START_REF] Joux | The function field sieve in the medium prime case[END_REF] Hayashi, Shimoyama, Shinohara, Takagi [ 1279 [START_REF] Göloglu | On the function field sieve and the impact of higher splitting probabilities[END_REF][START_REF] Granger | Breaking "128-bit secure" supersingular binary curves (or how to solve discrete logarithms in F 2 4•1223 and F 2 12•367[END_REF][START_REF] Granger | On the powers of 2[END_REF][START_REF] Joux | A new index calculus algorithm with complexity L(1/4 + o(1)) in small characteristic[END_REF] Kleinjung least Ω( √ p) operations, where p is the largest prime factor of N . This is much faster that exhaustively trying all possible values from 0 to N -1, but remains completely infeasible even for moderately large groups. For cryptographic use, the two main types of groups that are usually considered are subgroups of either the multiplicative group of a finite field or the group of points of an elliptic curve defined over a finite field. For elliptic curves, there are no known algorithms that outperform generic algorithms, except in a few specific cases. However, for finite fields, much faster algorithms do exist. For a group of size N , the complexity of these faster algorithms is often of the form:

L N (α, c) = exp (c + o(1))(log N ) α (log log N ) 1-α ,
where α and c are two parameters such that 0 < α < 1 and c > 0. We also encounter the notation L N (α) when specifying c is undesired. This shortcut is used because the most important parameter is the first one, which governs the transition from an exponential time algorithm to a polynomial time one. Indeed, when α becomes 1, L N (α) is exponential in log N and on the other hand, if α tends to 0, L N (α) becomes polynomial in log N .

The first subexponential algorithms for discrete logarithms in finite fields had complexity L N (1/2). Initially, they only applied to prime fields. They were generalized to fixed characteristic fields, then improved to L N (1/3) for prime and fixed characteristic fields. By 2006, L N (1/3) complexity was achieved for all finite fields. In 2013, the situation changed for small characteristic finite fields and much faster algorithms appeared for this case. This change removed the small finite field discrete logarithm problem from the list of cryptographically usable problems. Note that most of these index calculus have been designed with practical efficiency in mind 1 and that the stated performances can be achieved only under a variety of heuristic assumptions. Thus, unless the contrary is explicitly stated, the reader should assumed that all the algorithms mentioned in the present paper rely on such heuristic assumptions.

In this paper, we survey the key technical ideas behind discrete logarithms in small characteristic finite fields and show the main evolutions that led to the state-of-the-art algorithms. It would be beyond the scope of the present paper to present all the techniques and refinements that have recently appeared for small characteristic fields [START_REF] Adj | Weakness of F 3 6•1429 and F 2 4•3041 for discrete logarithm cryptography[END_REF][START_REF] Adj | Computing discrete logarithms in F 3 6•137 and F 3 6•163 using Magma[END_REF][START_REF] Granger | Breaking "128-bit secure" supersingular binary curves (or how to solve discrete logarithms in F 2 4•1223 and F 2 12•367[END_REF][START_REF] Granger | On the powers of 2[END_REF][START_REF] Granger | On the discrete logarithm problem in finite fields of fixed characteristic[END_REF]. Alternatively, the reader interested in a more general survey about discrete logarithms can refer to [START_REF] Joux | The past, evolving present, and future of the discrete logarithm[END_REF]. For simplicity of exposition, we focus on algorithms that work using polynomials over finite fields. In particular, we avoid all descriptions of the function field sieve algorithm of Adleman-Huang [START_REF] Adleman | Function field sieve method for discrete logarithms over finite fields[END_REF]. Instead, we present a variation on this algorithm based on bivariate polynomials [START_REF] Joux | The function field sieve in the medium prime case[END_REF].

Preliminaries and notations

Throughout the article, q denotes a prime power. For simplicity of exposition, we consider that q is fixed and that we wish to solve the discrete logarithm in F q k for some large extension degree k. As a consequence, all complexities are expressed as functions of k and operations in the basefield F q are considered to have unit cost.

Furthermore, F q [X] denotes the univariate polynomials in X with coefficients in F q . We recall that the finite field F * q k can be represented as F q [X]/(I k (X)) for any irreducible polynomial I k of degree k, that is, elements of the finite field can be represented as polynomials reduced modulo I k (X). Since there is a unique finite field with q k elements, all these representations are isomorphic. However, some of them are much more convenient for discrete logarithm computations and making good choices for I k is an important consideration in this context.

Factoring polynomials over finite fields. It is well-known that any monic polynomial F (X) in F q [X] can be written as a product:

F (X) = t i=1 F i (X) ei ,
where each F i is a monic irreducible polynomial and e i ≥ 1 is its multiplicity. Moreover, up to the order of factors, this factorization into irreducibles is unique. For non-necessarily monic polynomials, we obtain a similar decomposition:

F (X) = β • t i=1 F i (X) ei
by factoring out the leading coefficient β of F .

Decomposing polynomials into a product of irreducibles is one of the key tools in discrete logarithm computations. Such a decomposition is especially useful when all the irreducibles that appear have low degree. To quantify this notion, we say that a polynomial F (X) is -smooth when all the irreducibles in its decomposition have degree at most . This property is easy to test, due to the existence of fast algorithms for factoring univariate polynomials over finite fields [START_REF] Von | Factoring polynomials over finite fields: A survey[END_REF].

Number of smooth polynomials and irreducibles in a finite field. It is also useful to consider a combinatorial point of view and count the number of irreducible and smooth polynomials. To be more precise, let us recall a major theorem used in order to estimate the probability of smoothness of polynomials. This result is due to Panario, Gourdon and Flajolet who generalized in 1998 the probability of smoothness of integers given in [START_REF] Canfield | On a problem of Oppenheim concerning factorisatio numerorum[END_REF] to the probability of smoothness of polynomials in finite fields.

Estimate 1 (Panario, Gourdon and Flajolet [START_REF] Panario | An analytic approach to smooth polynomials over finite fields[END_REF]). The probability for a random polynomial of degree less than n to be m-smooth is:

(n/m) -(n/m)+o (1) .

We do not give the range of validity of the ratio n/m as in the theorem, yet it covers all our cases. Besides, the number N q (n) of irreducible polynomials of degree n in a finite field of cardinality q is such that N q (n) = n -1 d|n µ(d)q n/d where µ is the Möbius function [START_REF] Lidl | Finite fields. Encyclopaedia of mathematics and its applications[END_REF]. Hence we have the following result:

Lemma 2. If N q (n) denotes the number of irreducible polynomials of degree n in a finite field of cardinality q then q n /n -α ≤ N q (n) ≤ q n /n, where α = q n/2 +1 /n.

Proof. We know from [START_REF] Lidl | Finite fields. Encyclopaedia of mathematics and its applications[END_REF] that:

n N q (n) + d|n,d =n d N q (d) = q n . (1)
This directly yields the upper bound N q (n) ≤ q n /n. Back-substituting in (1), we deduce that:

q n ≤ n N q (n) + d|n,d =n q d ≤ n N q (n) + n/2 i=1 q d .
Thus, we find the lower bound N q (n) ≥ n -1 (q n -q n/2 +1 /(q -1)) and the result follows.

Moving between different representations of the same field. Concrete discrete logarithm challenges in finite fields start from an explicit description of F q k as an extension of the base field F q using a fixed irreducible polynomial I of degree k over F q [X]. Then, the problem is to find the discrete logarithm of an element h, given as a polynomial reduced modulo I, in the basis defined by g, another polynomial of the same form. Yet, most discrete logarithm algorithms start by choosing their own, usually different representation of F q k . For this purpose, they select another irreducible polynomial J of degree k over F q [X].

To shift the initial discrete logarithm problem from the original representation to the working representation we proceed as follows. Let β denote a root of J and consider I as a polynomial with coefficients in F q k = F q (β) and factorize it as a polynomial over this larger field. We know that I completely splits into linear terms and we thus express all of its roots as polynomials in β. Arbitrarily choose one of them and call it α. We are now able to write α = f (β) where f is a polynomial expression with coefficients in F q . In the initial problem, h and g are given as polynomials in α, say H(α) and G(α). In the new representation, it now suffices to find the discrete logarithm of H(f (β)) in basis G(f (β)).

On the multiplicative generator. One side issue related to the computation of discrete logarithms is to find a primitive element in a finite field F q k , i.e. a multiplicative generator of the group F * q k . This might be unessential when computing discrete logarithms since we may assume that a generator g is given. Yet, it is important when choosing a group for cryptographic purposes. A commonly encountered method is to take random elements and verify whether their orders are strict divisors of q k -1 or equal to q k -1. This is easy to check assuming that the factorization of q k -1 is known. However, this factorization is hard to compute when q k is large. Interestingly, the techniques to solve the discrete logarithm problem that we survey in the present paper have also been used in [START_REF] Huang | Finding primitive elements in finite fields of small characteristic[END_REF] to compute a multiplicative generator of F q k without knowledge of the factorization of q k -1.

Hellman-Reyneri algorithm

The algorithm of Hellman and Reyneri [START_REF] Hellman | Fast computation of discrete logarithms in GF(q)[END_REF] is an adaptation to F q k of Adleman's index calculus algorithm [START_REF] Adleman | A subexponential algorithm for the discrete logarithm problem with applications to cryptography[END_REF] for computing discrete logarithms in prime fields. It allows us to give a simple introduction to the concepts used in index calculus method. In its original form, it is a heuristic algorithm, like all algorithms described in the present article. However, there exists a rigorous variation due to Pomerance [START_REF] Pomerance | Fast, rigorous factorization and discrete logarithm algorithms[END_REF] with essentially the same asymptotic complexity.

To use the Hellman-Reyneri algorithm, we first choose I k , an arbitrary monic irreducible polynomial of degree k, in order to represent the finite field F q k by F q [α] where α denotes a (fixed) root of I k . We also choose a multiplicative generator g of the multiplicative group F * q k . In addition, we fix an integer parameter with 1 < < k.

For an integer r selected uniformly at random in [0, q k -1], we see that g r is a uniformly random element of F * q k . This element can be represented by a polynomial G r (X) of degree at most k -1 which can be efficiently computed by using a square-and-multiply exponentiation method. When this polynomial G r is -smooth, we can write:

g r = β r • tr i=1 F (r) i (α) e (r) i , (2)
where the F (r) i are the irreducible monic polynomials of degree at most that appear in the factorization of G r and β r the leading coefficient of G r . Taking logarithms in F q k , we obtain an affine equation:

r = log g (β r ) + tr i=1 e (r) i log g F (r) i (α) (mod q k -1),
whose unknowns are formal logarithms of elements of the set:

F = {β|β ∈ F q } ∪ {F (α)|F monic irred. of degree at most in F q [X]} .
This set is usually called the factor base. Since F has cardinality smaller than q +1 and since the equations are randomly generated, we expect that after generating q +1 such equations, we obtain a system with a unique solution formed of the logarithms in basis g of the elements of F. This expectation is precisely the reason why Hellman-Reyneri algorithm is heuristic.

Individual logarithms. Once these logarithms of elements of F are known, in order to find the logarithm of an arbitrary element h in F * q k , it suffices to find one extra equation of a form similar to Equation (2) but involving h. Typically, one can find an element h•g r that factors into elements of F and deduce the logarithm of h by subtracting r from the sum of logarithms of the elements in the factorization. Thus, computing one individual logarithm in the finite field once the precomputation of logarithms of factor base elements has been done costs much less than this precomputation. For practical purposes, this is an extremely important property. For this reason, most discrete logarithm algorithms have a separate individual logarithm phase. Rigorous algorithms form a notable exception to this rule since these algorithms don't aim at being practically competitive and because having a separate individual logarithm phase would make a rigorous analysis much more complicated.

Note. In order to simplify exposition, the above presentation differs from the more traditional way of performing index calculus. Normally, the elements of F q are not included in the factor base F. Instead, they are simply disregarded in the equations. This is possible because these constant elements have order dividing q -1 which implies that their logarithms are multiples of (q k -1)/(q -1). Thus, removing them is possible if we restrict ourselves to computing logarithms modulo (q k -1)/(q -1). More generally, all small factors of q k -1 are usually removed from consideration when doing the linear algebra. There are two main reasons for this. First, small factors might cause problem due to the occurrence of non invertible elements during the linear algebra process. Second, thanks to the use of generic algorithms such as Pohlig-Hellman, Shanks' baby-step-giant-step and Pollard's Rho, recovering the missing part of the logarithm is an easy addition to the individual logarithm computation.

Complexity analysis. In order to analyze the complexity algorithm, since the individual logarithm phase is negligible compared to the precomputation, it suffices to express the cost of the collection of relations and linear algebra as a function of the parameter . Using our upper bound of q +1 on the cardinality of F and denoting by p the probability for a random polynomial G r to be -smooth, the expected running time of the collection of relations is upper bounded by q +1 /p. To analyze the linear algebra, we first remark that the number of factor base elements in any multiplicative relation we form is upper bounded by k. This comes from the simple fact that the number of irreducible polynomials that appear when factor a polynomial is smaller than its degree. Thus the linear algebra is performed on a very sparse matrix containing at most k entries per line, and the cost of this phase is essentially quadratic in the size of F if we use sparse linear algebra techniques such as Lanczos [START_REF] Lanczos | An iteration method for the solution of the eigenvalue problem of linear differential and integral operators[END_REF] or Wiedemann [START_REF] Douglas | Solving sparse linear equations over finite fields[END_REF] algorithms. More precisely, the running time of the linear algebra is upper bounded by k q 2 +2 .

From Estimate 1 we know that:

-log q p ≤ k • log q (k/ ).
Thus, choosing our parameter as follows:

= k log q k 2 ,
yields an total runtime complexity of:

q √ (2+o(1)) k log q k = L q k (1/2, √ 2
).

Coppersmith's algorithm

In 1984, Coppersmith's algorithm [START_REF] Coppersmith | Fast evaluation of logarithms in fields of characteristic two[END_REF] was the first to achieve complexity below L N (1/2) for discrete logarithms in finite fields. This new algorithm was illustrated with a record on the finite field F 2 127 . In its basic form, it works for fields of characteristic 2 but can easily be generalized [START_REF] Blake | Computing logarithms in GF(2 n )[END_REF] to any characteristic. The key idea compared to the Hellman-Reyneri algorithm is to use the freedom we have when representing F q k and to choose a representation that helps the construction of multiplicative relations.

In the original form proposed by Coppersmith, the irreducible that defines F q k is chosen to be of the form x k -S(x), where S is a polynomial of degree d S as low as possible. Here, we replace this choice by a more recent construction from [START_REF] Joux | A new index calculus algorithm with complexity L(1/4 + o(1)) in small characteristic[END_REF], which simplifies the presentation of the construction of multiplicative relations in Coppersmith's algorithm. In this section, we let n be the unique integer such that q n-1 < k ≤ q n and choose a low degree polynomial S(x) such that x q n -S(x) has a single irreducible factor of degree k. We denote this factor by I k (x) and use it as a defining polynomial of F q k . We further write n = n 1 + n 2 for values of n 1 and n 2 to be determined during the complexity analysis. The key to the construction of relations is to note that for any pair of polynomials A and B with coefficients in F q , we have:

A(x) + x q n 1 B(x) q n 2 = A(x q n 2 ) + S(x)B(x q n 2 ) (mod I k (x)), (3)
thanks to the linearity of raising to the power q and to the fact that x q n = S(x) (mod I k (x)). Defining the factor basis F as in Section 3, we see that Equation (3) yields a multiplicative relation when both A(x) + x q n 1 B(x) and A(x q n 2 ) + S(x)B(x q n 2 ) are -smooth. Here, it is traditional to say that this occurs whenever the product

A(x) + x q n 1 B(x) • A(x q n 2 ) + S(x)B(x q n 2 )
is -smooth and make the heuristic argument that this event happens which probability comparable to the smoothness of a random polynomial of the same degree.

To continue the analysis, we look at all the pairs of non-zero polynomials A and B of degree at most , with A being chosen monic. The reason for this last restriction is that multiplying A and B by any constant of F q in fact yields the same equation. Under this condition on the degrees of A and B, we choose (n 1 , n 2 ) in the way that minimizes the degree of the above product. Since the total degree is:

+ q n1 + d S + • q n q n1 ,
it is minimized by making q n1 as close as possible to √ q n . With this choice, the degree asymptotically becomes (2 + o(1)) √ q n . In terms of k, this varies between (2 + o(1)) √ k and (2 √ q + o(1)) √ k depending on how close k is to the next power of q.

Finally, is chosen as in Section 3 by balancing the opposite of the logarithm of the probability of success with . This yields: = (4/3) 1/3 q n/3 n 2/3 .

Hence, the complexity becomes L q q n (1/3, (32/9) 1/3 ). In terms of q k , this varies between L q k (1/3, (32/9) 1/3 ) and L q k (1/3, (32 q/9) 1/3 ) depending on how close k is to the next power of q. Note that, due to the simplified presentation we have chosen, the worst case is less good than with Coppersmith's original algorithm.

Notes on the linear algebra. Compared to the algorithm of Hellman and Reyneri, there are two main differences that occur during the computation of the linear algebra. More precisely, the type of equations that arise from relations as in (3) no longer contain a constant term and they include some large coefficients q n2 . The consequence of the first difference is that the system has many solutions. Thankfully, any of these solutions (except the zero vector) gives logarithms, up to multiplication by a constant. Thus, if the multiplicative generator g appears in the factor base F, it is easy to renormalize the vector we obtain to get logarithms in basis g. In the case where g is outside of F, we need to use the individual logarithm process on g to obtain the correct renormalization constant. The large coefficients q n2 impact the performance of matrix-vector multiplication and thus accordingly slow down the linear algebra process. However, since there is a single large constant, one multiplication per line of the matrix is enough instead of one multiplication per large entry. Moreover, in the frequently considered case where q = 2, the multiplication simply becomes a left shift by n 2 bits and does not really slow down the process.

Individual logarithms -Enters the descent. One difficulty with Coppersmith's algorithm is that the construction of an additional relation involving an arbitrary finite field element is no longer simple. Thus, an additional, extremely important idea becomes necessary: the notion of descent. In a nutshell, this process is a way to write a relation between a polynomial in α and a small number of other polynomials of lower degree. Iterating the method many times, it becomes possible to express everything in terms of the elements of F. As a consequence, the computation of an individual logarithm is now represented as a tree where the descendants of a node (labeled by a polynomial) are the nodes labeled by the lower degree polynomials occurring in the corresponding relation. All the leaves of the tree should belong to F. In order to determine the cost of the computation, we need to bound the number of nodes in the tree and the cost of searching for one relation between a node and its sons. This analysis is beyond the scope of the present survey, the important result being that this whole descent process has negligible cost compared to the initial computation of the logarithms of elements of F.

To find a relation involving a polynomial G(α), which can be assumed to be irreducible without loss of generality, we proceed as follows :

• Choose values of n 1 and n 2 , possibly different from the ones used initially and adapted to the degree of G, such that n = n 1 + n 2 .

• Note that the set of polynomials (A, B) such that G divides A(x) + x q n 1 B(x) form a lattice. Compute a basis (A 1 , B 1 ) and (A 2 , B 2 ) of this lattice.

• For a pair of low degree polynomials (λ 1 , λ 2 ), let A = λ 1 A 1 + λ 2 A 2 and B = λ 1 B 1 + λ 2 B 2 and consider the candidate relation:

A(x) + x q n 1 B(x)
q n 2 = A(x q n 2 ) + S(x)B(x q n 2 ) (mod I k (x)).

• Among these candidates relations which all contain G, keep one such that the degrees of all the other irreducible polynomials involved are smaller that κ deg G for a constant κ < 1 (a typical choice would be κ = 3/4).

[11] considers a family of high-degree polynomials containing many smooth polynomials. However, this option only leads to an L N (1/3) algorithm. At the present time, the largest field of small characteristic that was broken with this family of algorithms, called Frobenius Representation algorithms, is a Kummer extension field with a 9234-bit cardinality.

In order to construct smooth polynomials of high degree, one starts from the identity:

X q -X = γ∈Fq (X -γ). (4)
For simplicity, we follow the approach of [START_REF] Joux | Improving the polynomial time precomputation of frobenius representation discrete logarithm algorithms[END_REF] and consider two non-zero polynomials A and B with coefficients in F q . We can write:

A(X) q B(X) -A(X) B(X) q = B(X) q+1 A(X) B(X) q - A(X) B(X) = B(X) q+1 γ∈Fq A(X) B(X) -γ = B(X) γ∈Fq (A(X) -γ B(X)) .
We see that A(X) q B(X) -A(X) B(X) q is constructed to be a product of polynomials of degree at most equal to the maximum of the degrees of A and B. In order to use this polynomial in a multiplicative relation, we need to relate it to a low degree polynomial in the finite field. For this purpose, we first use the linearity of the Frobenius map and write:

A(X) q B(X) -A(X) B(X) q = A(X q ) B(X) -A(X) B(X q ).
Remembering Coppersmith's algorithm, it is natural to construct the finite field F q k by searching for a low-degree polynomial S such that X q -S(X) has an irreducible factor I k of degree k. Once again, this requires q ≥ k. Letting α denote a root of I k and putting everything together, we can now write:

B(α) γ∈Fq (A(α) -γ B(α)) = A(S(α)) B(α) -A(α) B(S(α)), (5)
with the constructed smooth polynomial on the left and a low-degree polynomial on the right. More precisely, if A and B have degree at most , the degree of the polynomial on the right can be upper bounded by (deg S + 1). As usual, the parameter dictates the size of the factor base. The fundamental difference is that, in this new context, can be chosen to be a small constant. As a consequence, the precomputation of the logarithms of the elements of the factor base becomes polynomial time.

By contrast with the previous algorithm, the computation of individual discrete logarithms becomes the asymptotically limiting phase. Its complexity is quasi-polynomial, thanks to [START_REF] Barbulescu | A heuristic quasipolynomial algorithm for discrete logarithm in finite fields of small characteristic[END_REF] or [START_REF] Granger | On the powers of 2[END_REF], more precisely of the form q O(log(max(q,k))) for an arbitrary finite field F q k . This is worse than any polynomial but incredibly better than subexponential L N (1/3) complexity.

Note. To add flexibility, in most papers, instead of choosing I k as a divisor of X q -S(X), it is chosen as a divisor of S 1 (X)X q -S 0 (X). This means that the right-hand side in Equation (5) becomes: A S 0 (α) S 1 (α) B(α) -A(α) B S 0 (α) S 1 (α) , a rational fraction, whose denominator is fixed and whose numerator has low-degree.

Current state and open problems

After a few very active years, the state of discrete logarithms in small characteristic finite fields has been more or less stabilized. From a practical point of view, the complexity of the polynomial time precomputation of the logarithms of factor base elements has been reduced [START_REF] Joux | Improving the polynomial time precomputation of frobenius representation discrete logarithm algorithms[END_REF] to O(q 6 ) for finite fields of the form F q k with k < 2q. From a theoretical point of view, the most recent progress appears in [START_REF] Granger | On the discrete logarithm problem in finite fields of fixed characteristic[END_REF] and proposes a method to reduce the heuristic hypotheses required : it would now suffice to prove the existence of a pair of polynomials (S 0 , S 1 ) such that S 1 (X)X q -S 0 (X) has an irreducible factor of degree k. This final, challenging question remains open, despite the fact that in practical computations, finding (S 0 , S 1 ) is easy and efficient. Another problem would be to find a truly polynomial time algorithm rather than a quasi-polynomial one. With the current techniques for the individual logarithm part, this does not seem possible. This is due to the fact that each inner node of the tree involved during the descent process has O(q) sons. Since the height of the tree is logarithmic in k, the total number of leaves is already more that polynomial in the size of the field. More precisely, for k ≈ q, the number of leaves is O(q O(log q) ), thus dominating any polynomial in q.

Finally, the hardest and possibly most interesting open problem would be to somehow generalize these algorithms to the case of larger characteristic fields, the goal being to beat the apparent L N (1/3) barrier for large characteristic. Unfortunately, the ideas based on the use of polynomials and change of variables seem to be unusable in this context and different techniques would be required. Related issues are the possibility of finding improved algorithms for the factorization of large integers or for discrete logarithms on elliptic curve. This last question is discussed in [START_REF] Massierer | Some experiments investigating a possible L(1/4) algorithm for the discrete logarithm problem in algebraic curves[END_REF].

Figure

  Figure 1: History of discrete logarithm records in small characteristic finite fields

  1: History of discrete logarithm records in small characteristic finite fields

	Date	Field Bitsize Algorithm	Authors
	1984	2 127	127 [9]	Coppersmith
	1991	2 401	401 [9, 12]	Gordon, McCurley
	2001/09 2 521	521 [20]	Joux, Lercier
	2002/02 2 607	607 [9]	Thomé
	2005/09 2 613

This is illustrated by large-sized computations performed by many research groups in the past decades (see Figure1).

Bivariate polynomials

In order to improve on Coppersmith's algorithm, the next step is the function field sieve algorithm [START_REF] Adleman | Function field sieve method for discrete logarithms over finite fields[END_REF] proposed by Adleman and Huang in 1999. This algorithm was used for several record breaking computations as shown in Figure 1. We present a variation of this method that appeared in [START_REF] Joux | The function field sieve in the medium prime case[END_REF] and only makes use of polynomials. In particular, this variation was used in 2012 to compute discrete logarithms in a 923-bit field of characteristic 3 using about 900 000 CPU•hours [START_REF] Shinohara | Key length estimation of pairing-based cryptosystems using eta pairing over GF (3 n )[END_REF]. The starting point of the algorithm is to define the extension field implicitly using two polynomial bivariate relations over F q : y = f (x) and x = g(y).

Putting the two relations together, we obtain x = g(f (x)). Thus, if the polynomial g(f (x)) -x has an irreducible factor I k (x) of degree k, we obtain a representation of F q k . Under the constraint that the product of the degree of f and g is greater than k, we heuristically expect to easily find a satisfying pair of polynomials f and g. Once this is done, we let α denote a root in F q k of I k (x) and β = f (α). By construction, we also have

From this, given a pair of polynomials A and B, we can write:

Putting together the right-hand sides, we have equality in F q k between a polynomial in α and a polynomial in β. Moreover, both polynomials have relatively low-degree if parameters are properly selected. As a consequence, if both polynomials factor into irreducible factors of degree at most , we obtain a multiplicative relation. Note that we have essentially doubled the size of the factor base since it now contains the evaluation of each irreducible polynomial both at α and at β.

To analyze the complexity, it suffices to optimize on a single parameter . This parameter is the degree bound on the irreducible of F. The degrees of A and B are also fixed to be at most . In addition, the degrees of f and g are chosen to satisfy deg f • deg g ≈ k and deg f / deg g ≈ . Once optimized, this yields a heuristic complexity of L q k 1/3, (32/9) 1/3 .

With this bivariate representation, the computation of individual logarithms also involves a descent process as in Section 4, whose cost is negligible compared to the precomputation of logarithms of elements of the factor base.

The paradigm shift: Constructed smooth polynomials

Despite their obvious differences, the algorithms of Sections 4 and 5 share a common principle. Both create medium degree polynomials that respectively appear on the two sides of a multiplicative relation and hope that these two polynomials simultaneously factor into low-degree irreducibles. The fundamental obstruction that arises here is that the degrees of the two medium-sized polynomials cannot be made arbitrarily small. The reason for this is the fact that the rule that relates these two polynomials encodes the representation of the finite field that we are using. Due to this, lowering the degree of one of the two medium-sized polynomial increases the degree of the other. As long as we rely on chance to obtain smooth polynomials, the best strategy is to balance the two degrees. In this setting, the bivariate algorithm is essentially the best we can do.

In order to escape this obstruction, a different approach is needed. A recently discovered option [START_REF] Joux | A new index calculus algorithm with complexity L(1/4 + o(1)) in small characteristic[END_REF] that allows to break the L N (1/3) barrier works by writing an equation between a high-degree polynomial and a low-degree polynomial, where the high-degree polynomial is constructed to guarantee its smoothness. First announced in 2013, this yielded a L N (1/4) complexity, which was later improved to quasi-polynomial complexity in [START_REF] Barbulescu | A heuristic quasipolynomial algorithm for discrete logarithm in finite fields of small characteristic[END_REF]. This idea of constructing smooth polynomials first appeared in a less efficient version in [START_REF] Joux | Faster index calculus for the medium prime case application to 1175-bit and 1425-bit finite fields[END_REF]. Independently of the L N (1/4) algorithm from [START_REF] Joux | A new index calculus algorithm with complexity L(1/4 + o(1)) in small characteristic[END_REF] which directly construct smooth high degree polynomials,