finitefields 0.0.9 → 0.0.11

package/ellipticcurves.ts

@@ -7,16 +7,17 @@
  *
  */
 
-import type { GF,PrimeField } from './galois.js';
-import { just, nothing, type Maybe, type Nothing } from './maybe.js';
+import { PrimeField, type GF } from './galois.js';
+import { empty, fold, just, nothing, type Maybe, type Nothing } from './maybe.js';
 import { Util } from './galois.js';
 
-let 𝒪:Nothing;
 let log:(...x:any[])=>void;
 let fail:(...x:any[])=>never;
+let mkcurve:(field:PrimeField)=>ECCurve;
+
+let birch17:()=>ECCurve;
 let p256:()=>ECCurve;
 
-𝒪 = nothing();
 log = console.log;
 fail = (...args:any[]): never => {
     console.error(...args);
@@ -25,9 +26,106 @@ fail = (...args:any[]): never => {
     return void 0 as never;
 }
 
+mkcurve = (field:PrimeField): ECCurve => {
+    let bitlen:bigint;
+    let n:bigint;
+    let x:bigint, y:bigint;
+    let q:Point;
+    let mq:Coordinate;
+    let p:bigint;
+    let ret:boolean;
+    let test:(t:Coordinate,f:PrimeField)=>boolean;
+    let formula:ECformula;
+
+    formula = (a:bigint,b:bigint,f:PrimeField)=>(x:bigint,y:bigint) =>
+            (f.add(f.add(               // y^2 =
+                f.exp(x, 3n),           //   x^3
+                f.mul(a,x)),            //   + ax
+                b) % f.p);              //   + b
+
+    test = (mt:Coordinate,f:PrimeField): boolean => {
+        let y2:bigint;
+        let y2_:bigint;
+        let x:bigint, y:bigint;
+        let t:Point;
+        let a_:bigint, b_:bigint;
+        let p_:bigint;
+
+        if (empty(mt))
+            return true;
+        else
+            t = fold(mt);
+
+        p_ = f.p;
+        x=t.x, y=t.y;
+        a_ = 2n;
+        b_ = 2n;
+
+        y2 = Util.sqmul(y, 2n, p_);
+        y2_ = formula(a_, b_, f)(x,y);
+
+        return (y2 === y2_);
+    }
+
+    x=y = 0n;
+    ret = false;
+    p = field.p;
+    bitlen = Util.countbits(p);
+    y = Util.rnd(bitlen, p) % p;
+
+    if (p<4)
+        return fail();
+
+    for ((n=Util.sqmul(2n,bitlen,p)-1n); n; n--) {
+        x = (!x)?Util.rnd(bitlen, p) % p:x--;
+         q = new Point([x,y]);
+         mq = (q['∞'])?nothing():just(q);
+         if (test(mq,field)) {
+            (ret as unknown as number)++;
+            break;
+         }
+        y = (!y)?Util.rnd(bitlen, p) % p:y++;
+         q = new Point([x,y]);
+         mq = (q['∞'])?nothing():just(q);
+         if (test(mq,field)) {
+            (ret as unknown as number)++;
+            break;
+         }
+    }
+
+    return (!ret)?fail('curve generation failed'):{
+   '#E': p,
+    'θ': p,
+    'a': 3n,
+    'b': 2n,
+    'p': [x,y],
+    'q': [x,y],
+     bitlen,
+     formula
+    };
+}
+
+birch17 = ():ECCurve => ({
+  '#E': 17n,
+   'θ': 17n,
+    a: 2n,
+    b: 2n,
+    // p: [ 10n, 11n ],
+    // q: [ 10n, 11n ],
+    p: [ 5n, 1n ],
+    q: [ 5n, 1n ],
+    bitlen: 5n,
+    formula: (a:bigint,b:bigint,f:PrimeField)=>(x:bigint,y:bigint) =>
+            (f.add(f.add(               // y^2 =
+                f.exp(x, 3n),           //   x^3
+                f.mul(a,x)),            //   + ax
+                b) % f.p)               //   + b
+});
+  
 p256 = ():ECCurve => ({
    '#E': 0xffffffff00000000_ffffffffffffffff_bce6faada7179e84_f3b9cac2fc632551n,
     'θ': 0xffffffff00000001_0000000000000000_00000000ffffffff_ffffffffffffffffn,
+    'a': -3n,
     'b': 0x5ac635d8aa3a93e7_b3ebbd55769886bc_651d06b0cc53b0f6_3bce3c3e27d2604bn,
     'p':
      [
@@ -41,16 +139,17 @@ p256 = ():ECCurve => ({
       ],
       bitlen: 256n,
       formula: (a:bigint,b:bigint,f:PrimeField)=>(x:bigint,y:bigint) =>
-            f.add(f.add(                // y^2 =
+            (f.add(f.add(               // y^2 =
                 f.exp(x, 3n),           //   x^3
                 f.mul(a,x)),            //   + ax
-                b)                      //   + b
+                b) % f.p)               //   + b
 });
 
 type Tuple<a> = readonly [a,a];
 type Coordinate = Maybe<Point>;
 type infinity = false | true;
 type ECformula = (a:bigint,b:bigint,f:GF)=>Function;
+type Slope = bigint;
 
 interface Tuples {
     'p':    Tuple<bigint>;
@@ -59,6 +158,7 @@ interface Tuples {
 
 interface IECCurve {
     'θ':     bigint;
+    'a':     bigint;
     'b':     bigint;
     bitlen:  bigint;
     formula: ECformula;
@@ -72,6 +172,8 @@ interface Iellipticcurves<a> {
     constructor:Function;
     add:(a:Coordinate,b:Coordinate)=>Coordinate;
     double:(a:Coordinate)=>Coordinate;
+    get p(): Coordinate;
+    get q(): Coordinate;
 }
 
 interface Icurve extends IECCurve {
@@ -95,11 +197,11 @@ class Point implements Ipoint {
     constructor(point:Tuple<bigint>) {
         [ this['x'], this['y'], this['∞'] ] = [0n,0n,false];
 
-        switch (point.every((xy:bigint):xy is bigint=>!!xy)) {
-            case true:
+        switch (point.every((xy:bigint):xy is bigint=>!xy)) {
+            case false:
                 [ this['x'], this['y'] ] = point;
                 break;
-            case false:
+            case true:
                 (this['∞'] as unknown as number)++;
                 break;
             default:
@@ -113,6 +215,7 @@ class Point implements Ipoint {
 class Curve<a> implements Icurve {
     #E: bigint;
     public θ: bigint;
+    public a: bigint;
     public b: bigint;
     public p: Point;
     public q: Point;
@@ -127,6 +230,8 @@ class Curve<a> implements Icurve {
             || fail(m);
         this.θ = curve.θ
             || fail(m);
+        this.a = curve.a
+            || fail(m);
         this.b = curve.b
             || fail(m);
         this.bitlen = curve.bitlen
@@ -140,36 +245,161 @@ class Curve<a> implements Icurve {
     }
 }
 
-abstract class EllipticCurves<a> implements Iellipticcurves<a> {
+abstract class EllipticCurves<a extends GF> implements Iellipticcurves<a> {
     public abstract backend: a;
     private curve: Curve<a>;
 
-    protected addpoints(a:Coordinate,b:Coordinate): Coordinate {
-        return a;
+    private eq(p:Point,q:Point): boolean {
+        return (
+            (!p || !q) ?
+                fail() :
+            (p['∞'] && q['∞']) ?
+                true :
+            (p['∞'] && !q['∞']) ?
+                false :
+            (!p['∞'] && q['∞']) ?
+                false :
+            ((p.x === q.x) && (p.y === q.y))
+        );
+    }
+
+    private isprimefield(f:GF): f is PrimeField {
+        return (f instanceof PrimeField);
+    }
+
+    private slope(p_:Point,q_:Point): (a:bigint,p:bigint)=>Slope {
+        let f:a;
+        const { x:x1,y:y1 } = p_;
+        const { x:x2,y:y2 } = q_;
+
+        if (!this.isprimefield(this.backend))
+            return fail();
+        else
+            f = this.backend;
+
+        return (this.eq(p_,q_)) ?
+                (a:bigint,p:bigint): bigint =>
+                    (f.mul(
+                        f.add(a,
+                            f.mul(3n, f.exp(x1, 2n))
+                        ),
+                        f.inv(f.mul(y1, 2n))
+                    ) % p) :
+                (a:bigint,p:bigint): bigint =>
+                    (f.mul(
+                        f.sub(y2, y1),
+                        f.inv(f.sub(x2, x1))
+                    ) % p);
+    }
+
+    private isinfinity(f:PrimeField,p:Point,q:Point): boolean {
+        let invpy:bigint;
+        let invqy:bigint;
+        const [ px,py ]:[bigint,bigint] = [p.x,p.y];
+        const [ qx,qy ]:[bigint,bigint] = [q.x,q.y];
+
+        invpy = f.mul(-1n, py);
+        invqy = f.mul(-1n,qy);
+        // log('isinfinity(p) -> !!p[∞] -> ', !!(p['∞']));
+        // log(p);
+        return ((px===qx) && (py===invqy) && (qy===invpy)) ?
+                true : // Q = P + (-P) === ∞
+            false;
+    }
+
+    protected addpoints(p:Coordinate,q:Coordinate): Coordinate {
+        let s:Slope;
+        let p_:Point;
+        let q_:Point;
+        let x:bigint;
+        let y:bigint;
+        let t:Point;
+        let mt:Coordinate;
+        let Δx:bigint, Δy:bigint;
+        let f:a;
+
+        if (!this.isprimefield(this.backend))
+            return fail();
+        else
+            f = this.backend;
+
+        if (empty(p) && empty(q))
+            return <Maybe<Point>>nothing();
+        else if (empty(p))
+            return <Maybe<Point>>just(q as unknown as Point);
+        else if (empty(q))
+            return <Maybe<Point>>just(p as unknown as Point);
+        else
+            [p_, q_] = [fold(p), fold(q)];
+
+        const { x:x1,y:y1 } = p_;
+        const { x:x2,y:y2 } = q_;
+
+        if (this.isinfinity(f,p_,q_))
+            return nothing();
+
+        s = this.slope(p_, q_)(this.curve.a, this.backend.p);
+        Δx = f.add(x1, x2);
+        // x = (f.sub(s, f.mul(s, s)) % this.backend.p);
+        x = f.sub(f.mul(s,s),Δx);
+        Δy = f.sub(x1, x);
+        y = (f.sub(
+            f.mul(s, Δy),
+            y1
+        ) % this.backend.p);
+
+        t = new Point([x,y]);
+        // log('t', t);
+        mt = just(t);
+
+        return mt;
     }
 
     protected doublepoint(a:Coordinate): Coordinate {
-        return a;
+        return this.add(a, a);
     }
 
     public add(a:Coordinate,b:Coordinate): Coordinate {
-        if ((a === 𝒪) && (b === 𝒪))
+        if (empty(a) && empty(b))
             return <Maybe<Point>>nothing();
-        else if (a === 𝒪)
-            return <Maybe<Point>>just(b as unknown as Point);
-        else if (b === 𝒪)
-            return <Maybe<Point>>just(a as unknown as Point);
+        else if (empty(a))
+            return b;
+        else if (empty(b))
+            return a;
         else
             return <Maybe<Point>>this.addpoints(a,b);
     }
 
     public double(a:Coordinate): Coordinate {
-        if (a === 𝒪)
+        if (empty(a))
             return nothing();
         else
             return this.doublepoint(a);
     }
 
+    public get p(): Coordinate {
+        let p:Point;
+        let mp:Coordinate;
+
+        p = this.curve.p;
+        mp = (p['∞']) ?
+                nothing() :
+            just(p);
+        
+        return mp;
+    }
+    public get q(): Coordinate {
+        let q:Point;
+        let mq:Coordinate;
+
+        q = this.curve.q;
+        mq = (q['∞']) ?
+                nothing() :
+            just(q);
+        
+        return mq;
+    }
+
     constructor(curve:ECCurve) {
         this.curve = new Curve<a>(curve);
 
@@ -190,4 +420,5 @@ class ecℤp extends EllipticCurves<PrimeField>
     }
 }
 
-export { ecℤp, p256 };
+export { Point,ecℤp,birch17,p256,mkcurve };
+export type { Coordinate,ECCurve };

package/galois.ts

@@ -32,18 +32,28 @@ enum methods {
     DoubleAndAdd
 }
 
-const arithmeticsℤp = (p:bigint,op:fieldops) =>
-    (op==fieldops.$add) ?
-            (a:bigint,b:bigint=0n) => (a+b)%p :
-    (op==fieldops.$sub) ?
-            (a:bigint,b:bigint=0n) => ((a-b)<1)?(a-b+p):(a-b)%p :
-    (op==fieldops.$mul) ?
-            (a:bigint,b:bigint=0n) => (!a||!b)?0n:Util.dblad(a,b,p) :
-    (op==fieldops.$inv) ?
-            (a:bigint) => (!a)?fail('0 has no inverse'):Util.sqmul(a,(p-2n),p) :
-    (op==fieldops.$exp) ?
-            (a:bigint,b:bigint=0n) => (!a)?0n:(!b)?1n:Util.sqmul(a,b,p) :
-        fail('unknown field operation');
+const arithmeticsℤp = (p:bigint,op:fieldops) => {
+    let x:bigint;
+
+    return (
+        (op==fieldops.$add) ?
+                (a:bigint,b:bigint=0n) => ((x=((a+b)%p))<0n)?((x+p)%p):x :
+        (op==fieldops.$sub) ?
+                (a:bigint,b:bigint=0n) => ((x=((a-b)%p))<0n)?((x+p)%p):x :
+        (op==fieldops.$mul) ?
+                (a:bigint,b:bigint=0n) =>
+                    (!a||!b)?0n:((x=Util.dblad(a,b,p)%p)<0)?((x+p)%p):x :
+        (op==fieldops.$inv) ?
+                (a:bigint) =>
+                        (!a)?fail('0 has no inverse'):(a<0)?-a%p:Util.sqmul(a,(p-2n),p) :
+        (op==fieldops.$exp) ?
+                (a:bigint,b:bigint=0n):bigint =>
+                    (!a)?0n:(!b)?1n:(b<0) ?
+                            arithmeticsℤp(p,fieldops.$inv)(Util.sqmul(a,-b,p)) :
+                        Util.sqmul(a,b,p) :
+            fail('unknown field operation')
+    );
+}
 
 Util = {
     countbits(x:bigint): bigint {
@@ -80,7 +90,7 @@ Util = {
         //     return v;
         // }
 
-        return true;
+        // return true;
 
         if (p<2n)
             return true;
@@ -145,10 +155,30 @@ Util = {
         let sign:string;
         let a:bigint;
         let e:bigint;
+        let minus:boolean;
 
         // sign = (method==methods.SquareAndMultiply) ? '^' : 'x';
         // log(`${a_}${sign}${e_} (mod ${p}) = `);
 
+        minus = false;
+        if (((a_===0n) || (e_===0n)) && (method===methods.DoubleAndAdd))
+            return 0n;
+        else if (a_ === 0n)
+            return 0n;
+
+        if (a_<0) {
+            (minus as unknown as number) ^= 1;
+            a_*=-1n;
+            a_%=p;
+        }
+        if ((e_<0) && (method===methods.DoubleAndAdd)) {
+            (minus as unknown as number) ^= 1;
+            e_*=1n;
+            e_%=p;
+        }
+        else if (e_<0)
+            return fail('cannot raise to a negative exponent');
+
         switch (method) {
             case methods.SquareAndMultiply:
                 sq  = (y:bigint,p_:bigint):bigint           =>
@@ -193,7 +223,9 @@ Util = {
                 return void 0;
             });
         
-        return (val%p);
+        return (minus && (method===methods.DoubleAndAdd)) ?
+                ((val*-1n)%p) :
+            (val%p);
     }
 }
 

package/main.ts

@@ -1,23 +1,62 @@
 /* main.ts */
 import { Polynomial } from './polynomial.js';
 import { Util,PrimeField } from './galois.js';
-import { ecℤp, p256 } from './ellipticcurves.js';
+import { birch17, ecℤp, mkcurve, p256,Point } from './ellipticcurves.js';
 import { empty, fold, just, nothing } from './maybe.js';
+import type { Coordinate, ECCurve } from './ellipticcurves.js';
 import type { Maybe, Just, Nothing } from './maybe.js';
 
 let log:(...x:any[])=>void;
 log = console.log;
 
-let foo:Maybe<string>;
-foo = just(1..toString());
-log(empty(foo));
-
-// let field:PrimeField;
-// let curve:ecℤp;
+let field:PrimeField;
+let curve:ecℤp;
+let mp:Coordinate;
+let mq:Coordinate;
+let mt:Coordinate;
+let p:Point;
+let q:Point;
+let mycurve:ECCurve;
+let n:bigint;
 
+field = new PrimeField(birch17().θ, birch17().bitlen);
+curve = new ecℤp(field, birch17());
+// log(curve);
 // field = new PrimeField(p256().θ, p256().bitlen);
-// log(field);
 // curve = new ecℤp(field, p256());
+// field = new PrimeField(17n,5n);
+// mycurve = mkcurve(field);
+// log(mycurve);
+// log(field);
 // log(curve);
 
-export { Polynomial,Util,PrimeField,ecℤp,p256 };
+// log('[5,1] + [5,16] = ');
+// q = new Point([5n,16n]);
+// mq = just(q);
+// mp = curve.p;
+// mt = curve.add(mp, mq);
+// log (mt);
+// log(curve.add(mp, mt));
+
+// log(mp);
+// process.exit(0);
+// p = undefined as any;
+
+mp = curve.p;
+mq = curve.q;
+log(curve.p);
+
+// mp = curve.add(curve.p, curve.q);
+// mp = curve.q;
+
+q = fold(mq);
+p = fold(curve.p);
+for (n=0n; n<22n; n++) {
+    mp = curve.add(mp, mq);
+    log(mp);
+}
+log(mp);
+
+export { Polynomial,Util,PrimeField,ecℤp,Point };
+export { p256,empty,fold,just,nothing };
+export type { Coordinate,Maybe,Just,Nothing }

package/maybe.ts

@@ -32,7 +32,7 @@ let x:Function;
 
 nothing = (): Nothing => [] as Nothing;
 just = <a>(x:a): Just<a> => [x] as Just<a>;
-empty = <a>(x:Maybe<a>): x is Nothing => !(x&&x.length);
+empty = <a>(x:Maybe<a>): boolean => (!x || !x.length);
 fold = <a>(x:Maybe<a>): a|never =>
     (!empty(x))?x[0] as a:fail("folding nothing") as never;
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "finitefields",
   "type": "module",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Galois/Finite field crypto and raw elliptic curves",
   "main": "main.js",
   "scripts": {