finitefields 0.0.10 → 0.0.12

package/ellipticcurves.ts

@@ -11,12 +11,13 @@ 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,6 +26,102 @@ 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,
@@ -42,10 +139,10 @@ 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];
@@ -92,6 +189,24 @@ interface Ipoint {
     constructor: Function;
 }
 
+(Array as any).prototype.origToString = Array.prototype.toString;
+Array.prototype.toString = function(this:Maybe<Point>): string {
+    let p:Point;
+    let x:bigint;
+    let y:bigint;
+
+    if (!empty(this)) {
+        if (!(typeof this === 'object') && ('∞' in this[0]))
+            return (this as any).origToString();
+        p = fold(this);
+        [x,y] = [p.x,p.y];
+
+        return `(${x},${y})`;
+    }
+    else
+        return '∞';
+}
+
 class Point implements Ipoint {
     public 'x':bigint;
     public 'y':bigint;
@@ -100,17 +215,17 @@ 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:
                 return fail();
         }
-
+    
         return this;
     }
 }
@@ -170,7 +285,7 @@ abstract class EllipticCurves<a extends GF> implements Iellipticcurves<a> {
         return (f instanceof PrimeField);
     }
 
-    private slope(p_:Point,q_:Point): (a:bigint,p:bigint)=>bigint {
+    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_;
@@ -195,8 +310,19 @@ abstract class EllipticCurves<a extends GF> implements Iellipticcurves<a> {
                     ) % p);
     }
 
-    private isinfinity(p:Point): infinity {
-        return false;
+    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 {
@@ -227,9 +353,13 @@ abstract class EllipticCurves<a extends GF> implements Iellipticcurves<a> {
         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.sub(x1, x2);
-        x = (f.sub(s, f.mul(s, s)) % 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),
@@ -237,10 +367,8 @@ abstract class EllipticCurves<a extends GF> implements Iellipticcurves<a> {
         ) % this.backend.p);
 
         t = new Point([x,y]);
-        if (this.isinfinity(t))
-            mt = nothing();
-        else
-            mt = just(t);
+        // log('t', t);
+        mt = just(t);
 
         return mt;
     }
@@ -253,15 +381,15 @@ abstract class EllipticCurves<a extends GF> implements Iellipticcurves<a> {
         if (empty(a) && empty(b))
             return <Maybe<Point>>nothing();
         else if (empty(a))
-            return <Maybe<Point>>just(b as unknown as Point);
+            return b;
         else if (empty(b))
-            return <Maybe<Point>>just(a as unknown as Point);
+            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);
@@ -310,5 +438,5 @@ class ecℤp extends EllipticCurves<PrimeField>
     }
 }
 
-export { ecℤp, p256 };
-export type { Point, Coordinate };
+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,8 +1,9 @@
 /* main.ts */
 import { Polynomial } from './polynomial.js';
 import { Util,PrimeField } from './galois.js';
-import { ecℤp, p256, type Coordinate, type Point } 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;
@@ -11,29 +12,52 @@ log = console.log;
 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(p256().θ, p256().bitlen);
+field = new PrimeField(birch17().θ, birch17().bitlen);
+curve = new ecℤp(field, birch17());
+// log(curve);
+// field = new PrimeField(p256().θ, p256().bitlen);
+// curve = new ecℤp(field, p256());
+// field = new PrimeField(17n,5n);
+// mycurve = mkcurve(field);
+// log(mycurve);
 // log(field);
-curve = new ecℤp(field, p256());
 // log(curve);
 
+// 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;
+
+log(['Adding point (5,1) to itself:']);
+mp = curve.p;
+mq = curve.q;
+log('n=0', mp.toString());
+
 // mp = curve.add(curve.p, curve.q);
-mp = curve.q;
-q = fold(mp);
+// mp = curve.q;
+
+q = fold(mq);
 p = fold(curve.p);
-do {
-    mp = curve.double(mp);
-    if (empty(mp)) {
-        log(mp);
-        break;
-    }
-    else {
-        p = fold(mp);
-        log(p);
-    }
-} while (p.x !== q.x);
-log(q);
-
-export { Polynomial,Util,PrimeField,ecℤp,p256 };
+for (n=1n; n<23n; n++) {
+    mp = curve.add(mp, mq);
+    log('n='+n.toString(), mp.toString());
+}
+log('n='+n.toString(), mp.toString());
+
+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.10",
+  "version": "0.0.12",
   "description": "Galois/Finite field crypto and raw elliptic curves",
   "main": "main.js",
   "scripts": {