finitefields 0.0.6 → 0.0.8

package/ellipticcurves.ts

@@ -0,0 +1,161 @@
+/*
+ * elliptic curves
+ *
+ * finitefields package by @dr-Jonas-Birch
+ *
+ * 2026
+ *
+ */
+
+import type { GF,PrimeField } from './galois.js';
+import { Util } from './galois.js';
+
+let log:(...x:any[])=>void;
+let fail:(...x:any[])=>never;
+let p256:()=>ECCurve;
+
+log = console.log;
+fail = (...args:any[]): never => {
+    console.error(...args);
+    throw new Error(args.toString());
+
+    return void 0 as never;
+}
+
+p256 = ():ECCurve => ({
+   '#E': 0xffffffff00000000_ffffffffffffffff_bce6faada7179e84_f3b9cac2fc632551n,
+    'θ': 0xffffffff00000001_0000000000000000_00000000ffffffff_ffffffffffffffffn,
+    'b': 0x5ac635d8aa3a93e7_b3ebbd55769886bc_651d06b0cc53b0f6_3bce3c3e27d2604bn,
+    'p':
+     [
+        0x6b17d1f2e12c4247_f8bce6e563a440f2_77037d812deb33a0_f4a13945d898c296n,
+        0x4fe342e2fe1a7f9b_8ee7eb4a7c0f9e16_2bce33576b315ece_cbb6406837bf51f5n
+     ],
+     'q':
+      [
+        0xc97445f45cdef9f0_d3e05e1e585fc297_235b82b5be8ff3ef_ca67c59852018192n,
+        0xb28ef557ba31dfcb_dd21ac46e2a91e3c_304f44cb87058ada_2cb815151e610046n
+      ],
+      bitlen: 256n,
+      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)                      //   + b
+});
+
+type Tuple<a> = readonly [a,a];
+type infinity = false | true;
+type ECformula = (a:bigint,b:bigint,f:GF)=>Function;
+
+interface Tuples {
+    'p':    Tuple<bigint>;
+    'q':    Tuple<bigint>;
+}
+
+interface IECCurve {
+    'θ':     bigint;
+    'b':     bigint;
+    bitlen:  bigint;
+    formula: ECformula;
+}
+
+type hashE = {'#E':bigint};
+interface ECCurve extends IECCurve,Tuples,hashE {};
+
+interface Iellipticcurves<a> {
+    backend: a;
+    constructor:Function;
+}
+
+interface Icurve extends IECCurve {
+    p: Point;
+    q: Point;
+    constructor:Function;
+}
+
+interface Ipoint {
+    'x': bigint;
+    'y': bigint;
+    '∞': infinity;
+    constructor: Function;
+}
+
+class Point implements Ipoint {
+    public 'x':bigint;
+    public 'y':bigint;
+    public '∞':infinity;
+
+    constructor(point:Tuple<bigint>) {
+        [ this['x'], this['y'], this['∞'] ] = [0n,0n,false];
+
+        switch (point.every((xy:bigint):xy is bigint=>!!xy)) {
+            case true:
+                [ this['x'], this['y'] ] = point;
+                break;
+            case false:
+                (this['∞'] as unknown as number)++;
+                break;
+            default:
+                return fail();
+        }
+
+        return this;
+    }
+}
+
+class Curve<a> implements Icurve {
+    #E: bigint;
+    public θ: bigint;
+    public b: bigint;
+    public p: Point;
+    public q: Point;
+    public bitlen: bigint;
+    public formula:ECformula;
+    
+    constructor(curve:ECCurve) {
+        let m:string;
+
+        m = 'argument error (incomplete curve params)' as const;
+        this.#E = curve['#E']
+            || fail(m);
+        this.θ = curve.θ
+            || fail(m);
+        this.b = curve.b
+            || fail(m);
+        this.bitlen = curve.bitlen
+            || fail(m);
+        this.formula = curve.formula
+            || fail(m);
+        this.p = new Point(curve.p);
+        this.q = new Point(curve.q);
+
+        return this;
+    }
+}
+
+abstract class EllipticCurves<a> implements Iellipticcurves<a> {
+    public abstract backend: a;
+    private curve: Curve<a>;
+
+    constructor(curve:ECCurve) {
+        this.curve = new Curve<a>(curve);
+
+        return this;
+    }
+}
+
+class ecℤp extends EllipticCurves<PrimeField>
+    implements Iellipticcurves<PrimeField>
+{
+    public backend:PrimeField;
+
+    constructor(field:PrimeField, curve:ECCurve) {
+        super(curve);
+        this.backend = field;
+
+        return this;
+    }
+}
+
+export { ecℤp, p256 };

package/galois.ts

@@ -19,15 +19,30 @@ fail = (...args:any[]): never => {
     return void 0 as never;
 }
 
+enum fieldops {
+    $add,
+    $sub,
+    $mul,
+    $inv,
+    $exp
+}
+
+enum methods {
+    SquareAndMultiply,
+    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)%p :
+            (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');
 
 Util = {
@@ -44,6 +59,28 @@ Util = {
         let n:number;
         let r:bigint;
         let ret:boolean;
+        // let pow:(x:bigint,e:bigint,p_:bigint)=>bigint;
+
+        // pow = (x:bigint,e:bigint,p_:bigint): bigint => {
+        //     let n_:bigint;
+        //     let v:bigint;
+
+        //     if (e == 1n)
+        //         return (x%p_);
+        //     else if (!e)
+        //         return (1n%p_);
+        //     else if (e<0n)
+        //         return fail("trying to raise to negative power");
+
+        //     n_ = e;
+        //     v = x;
+        //     while (--n_)
+        //         v = (v*v)%p_;
+
+        //     return v;
+        // }
+
+        return true;
 
         if (p<2n)
             return true;
@@ -51,7 +88,8 @@ Util = {
         for (n=0, ret=true; n<s; n++) {
             r = this.rnd(bitlen,(p-1n));
             r += 1n;
-            if (((r**(p-1n))%p) != 1n) {
+            // if (((r**(p-1n))%p) != 1n) {
+            if (this.sqmul(r,(p-1n),p) !== 1n) {
                 ret = false;
                 break;
             }
@@ -92,18 +130,50 @@ Util = {
         return fail('eea() not implemented') as never;
     },
 
-    sqmul(a:bigint,e:bigint,p:bigint): bigint {
+    sqmul: (a:bigint,e:bigint,p:bigint): bigint =>
+        Util.binmethod(a,e,p,methods.SquareAndMultiply),
+    dblad: (a:bigint,e:bigint,p:bigint): bigint =>
+        Util.binmethod(a,e,p,methods.DoubleAndAdd),
+
+    binmethod(a_:bigint,e_:bigint,p:bigint,method:methods): bigint {
         let bitstring:boolean[];
         let bitlen:bigint;
         let n:bigint;
         let val:bigint;
         let mul:(y:bigint,z:bigint,p_:bigint)=>bigint;
         let sq:(y:bigint,p_:bigint)=>bigint;
+        let sign:string;
+        let a:bigint;
+        let e:bigint;
+
+        sign = (method==methods.SquareAndMultiply) ? '^' : 'x';
+        log(`${a_}${sign}${e_} (mod ${p}) = `);
+
+        switch (method) {
+            case methods.SquareAndMultiply:
+                sq  = (y:bigint,p_:bigint):bigint           =>
+                    Util.binmethod(y,y,p_,methods.DoubleAndAdd);
+                mul = (y:bigint,z:bigint,p_:bigint):bigint  =>
+                    Util.binmethod(y,z,p_,methods.DoubleAndAdd);
+                a=a_;
+                e=e_;
+                break;
 
-        log(`${a}^${e} (mod ${p}) = `);
+            case methods.DoubleAndAdd:
+                sq  = (y:bigint,p_:bigint):bigint           =>
+                    // Util.binmethod(y,2n,p_,DoubleAndAdd)
+                    ((y+y)%p_)
+                mul = (y:bigint,z:bigint,p_:bigint):bigint  =>
+                    // Util.binmethod(y,z,p_,DoubleAndAdd)
+                    ((y+z)%p_);
+                a=e_;
+                e=a_;
+                break;
 
-        mul = (y:bigint,z:bigint,p_:bigint):bigint  => ((y*z)%p_);
-        sq  = (y:bigint,p_:bigint):bigint           => ((y*y)%p_);
+            default:
+                return fail('argument error');
+                break;
+        }
 
         val = a;
         bitlen = this.countbits(e);
@@ -114,12 +184,18 @@ Util = {
             .fill(false,0,Number(bitlen))
             .map((x:boolean,idx:number):boolean =>
                 (((e>>n--)&1n)===1n) && (!!idx));
+        // if (method === methods.DoubleAndAdd)
+            bitstring.shift();
         // log(bitstring.map((x:boolean):number => (x)?1:0));
         bitstring
             .forEach((x:boolean):void => {
+                // val = (x) ?
+                //     mul(a,sq(val,p),p) :
+                // sq(a,p);
                 val = (x) ?
                     mul(a,sq(val,p),p) :
-                sq(a,p);
+                sq(val,p);
+                // log(val);
                 
                 return void 0;
             });
@@ -128,19 +204,14 @@ Util = {
     }
 }
 
-enum fieldops {
-    $add,
-    $sub,
-    $mul,
-    $inv
-}
-
 interface Igalois {
     add: (a:bigint,b:bigint)=>bigint;
     sub: (a:bigint,b:bigint)=>bigint;
     mul: (a:bigint,b:bigint)=>bigint; 
     inv: (a:bigint)=>bigint;
+    exp: (a:bigint,b:bigint)=>bigint; 
     verify:()=>void;
+    get p(): bigint;
     constructor:Function;
 }
 
@@ -149,7 +220,9 @@ interface Iutil {
     countbits: (x:bigint)=>bigint;
     rnd: (bitlen:bigint,max:bigint)=>bigint;
     eea: (x:bigint,p:bigint)=>bigint;
+    binmethod: (a:bigint,e:bigint,p:bigint,method:methods)=>bigint;
     sqmul: (a:bigint,e:bigint,p:bigint)=>bigint;
+    dblad: (a:bigint,e:bigint,p:bigint)=>bigint;
 }
 
 abstract class GF implements Igalois {
@@ -159,9 +232,14 @@ abstract class GF implements Igalois {
     public abstract sub: typeof this.add;
     public abstract mul: typeof this.add;
     public abstract inv: (a:bigint)=>bigint;
+    public abstract exp: typeof this.add;
 
     public abstract verify(): void;
 
+    public get p(): bigint {
+        return this.modulus;
+    }
+
     constructor(field:bigint,bitlen:bigint) {
         this.modulus = field;
         this.bitlen = bitlen;
@@ -177,6 +255,7 @@ class PrimeField extends GF implements Igalois {
     public sub: typeof this.add;
     public mul: typeof this.add;
     public inv: (a:bigint)=>bigint;
+    public exp: typeof this.add;
 
     public verify(): void {
         if (!Util.isprime(this.modulus))
@@ -193,6 +272,7 @@ class PrimeField extends GF implements Igalois {
         this.sub = arithmeticsℤp(this.modulus, fieldops.$sub);
         this.mul = arithmeticsℤp(this.modulus, fieldops.$mul);
         this.inv = arithmeticsℤp(this.modulus, fieldops.$inv);
+        this.exp = arithmeticsℤp(this.modulus, fieldops.$exp);
 
         return this;
     }
@@ -200,3 +280,4 @@ class PrimeField extends GF implements Igalois {
 }
 
 export { Util, PrimeField };
+export type { GF }

package/main.ts

@@ -1,30 +1,17 @@
 /* main.ts */
 import { Polynomial } from './polynomial.js';
 import { Util,PrimeField } from './galois.js';
+import { ecℤp, p256 } from './ellipticcurves.js';
 
 let log:(...x:any[])=>void;
 log = console.log;
 
-let p1:Polynomial;
-let p2:Polynomial;
-let p3:Polynomial;
-let x0:bigint;
-let x1:bigint;
-let x2:bigint;
-let x3:bigint;
+let field:PrimeField;
+let curve:ecℤp;
 
-x0 = BigInt(1);
-x1 = BigInt(0);
-x2 = BigInt(1);
-x3 = BigInt(0);
+field = new PrimeField(p256().θ, p256().bitlen);
+log(field);
+curve = new ecℤp(field, p256());
+log(curve);
 
-p1 = new Polynomial([x0, x1, x2, x3], 2n);
-p2 = new Polynomial({ tobject:0n, x3:1n, x2:0n, x:1n, 1:1n }, 2n);
-// log(p1, " + ", p2, " =");
-// p3 = Polynomial.add(p1,p2);
-p3 = new Polynomial(1n<<254n, 2n);
-
-log(p3, p3.eval());
-// log(p3.eval());
-
-export { Polynomial,Util,PrimeField };
+export { Polynomial,Util,PrimeField,ecℤp,p256 };

package/package.json

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

package/main.js

@@ -1,25 +0,0 @@
-/* main.ts */
-import { Polynomial } from './polynomial.js';
-import { Util, PrimeField } from './galois.js';
-let log;
-log = console.log;
-let p1;
-let p2;
-let p3;
-let x0;
-let x1;
-let x2;
-let x3;
-x0 = BigInt(1);
-x1 = BigInt(0);
-x2 = BigInt(1);
-x3 = BigInt(0);
-p1 = new Polynomial([x0, x1, x2, x3], 2n);
-p2 = new Polynomial({ tobject: 0n, x3: 1n, x2: 0n, x: 1n, 1: 1n }, 2n);
-// log(p1, " + ", p2, " =");
-// p3 = Polynomial.add(p1,p2);
-p3 = new Polynomial(1n << 254n, 2n);
-log(p3, p3.eval());
-// log(p3.eval());
-export { Polynomial, Util, PrimeField };
-//# sourceMappingURL=main.js.map