MATH 470 Lecture 26

From Notes
Jump to navigation Jump to search

« previous | Tuesday, April 23, 2013 | next »


Encoding Plain-Text on Elliptic Curves

Using /n for n large makes it easy to encode messages:

if n=pq for primes p<q, then

/n={1,,p1,p+1,,q1,q+1,,n1}

You'd like to do the same on an elliptic curve. e.g.

  • 1 ⟼ first point on curve
  • 2 ⟼ second point on curve

Unfortunately, there is no known poly-time algorithm for enumerating points on an elliptic curve over a finite field.

N. Koblitz came up with the following trick:

To transmit m, add a few digits and use square roots.


Consider y2=x39x+1 over 𝔽p, where p=1,159,531.

According to Hasse's Theorem, The number of points n on E satisfies |n(p+1)|2p, so there are about a million points on this curve.

Can we efficiently encode {1,,1051} as points on E? What about 19312?

Koblitz proposed adding a few (z) digits:

19312=19312*10z+d110z1+d210z2++dz

In our cose, let's just add a single digit 0:

19312193120

Now is there a y𝔽p with y2=(193120)39(193120)+1(modp)? Compute legendre symbol ((193120)39(193120)+1p)=1: YES

Decoding: If you see (x,y)E, then your message is just x10.

Note, when encoding {1,,n} as elements of /n for n=pq, there were just 2 failures. When encoding on an elliptic curve, how many failures are there?

Koblitz's Heuristic

Since exactly half the elements of 𝔽p* are squares, a random x results in (x3+bx+cp)=1 with probability approx. 50%

So then, among all 193120–193129, we'll find at least one with probability 11210

Thus, the general trick is to encode {1,,n} as points on E/𝔽p with p>10kn, add on k extra digits, and pick the last k digits randomly

with probability at least 11210k, you've encoded successfully.

Elliptic Curve Analogues of Cryptosystems

El Gamal

Formerly worked over (/p)* and was based on the discrete log problem.

Elliptic Curve El Gamal is defined over E(𝔽) and is based on the elliptic curve discrete log, an even harder problem than discrete log! Thus the fancier cryptosystem allows for smaller keys

Public Private
p = large prime a{1,,n1}
E = (nonsingular) elliptic curve
n = number of points on E
A = point on E
B=[a]A

To sign a message (or message hash) m, the signer does this:

  1. pick a random k{1,,n1} with gcd(k,n)=1 and compute R=[k]A=(x,y).
  2. compute s=k1(max)(modn)
  3. send (m,R,s)
Note: step 1 performed an elliptic curve operation, namely computing x as a point on the elliptic curve. Everyithing else is integer arithmetic

To verify the signature, the verifier does this:

  1. downloads (p,E,n,A,B) and (m,R,s)
  2. compute V1=[x]B[s]R and V2=[m]A
  3. Accept if V1=V2.

Bracket arithmetic is mod n because E has n points, and thus forms a group of order n Therefore, the points eventually wrap around if multiplied by a number greater than n: [n+17]A=[17]A.

Note: verifier only performs elliptic curve operations

Proof. Check that a valid signature indeed implies V1=V2:

V1=[x]B[s]R=[x][a]A[k1(max(modn))][k]A=[xa(modn)]A[max(modn)]A=[xa+max(modn)]A=[m]A=V2

Q.E.D.


Now if an evil party knew a, they could forge signatures. However, finding a appears to boild down to solving B=[a]A for a, which is the elliptic curve discrete log problem.

Practice final is up on the course website!