finitefields 0.0.5 → 0.0.7

package/ellipticcurves.ts

@@ -0,0 +1,147 @@
+/*
+ * elliptic curves
+ *
+ * finitefields package by @dr-Jonas-Birch
+ *
+ * 2026
+ *
+ */
+
+import type { PrimeField } 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 = {
+   '#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
+      ]
+}
+
+type Tuple<a> = readonly [a,a];
+type infinity = false | true;
+
+interface Tuples {
+    'p':    Tuple<bigint>;
+    'q':    Tuple<bigint>;
+}
+
+interface IECCurve {
+    'θ':    bigint;
+    'b':    bigint;
+}
+
+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;
+    private object: EllipticCurves<a>;
+    
+    constructor(object:EllipticCurves<a>,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.p = new Point(curve.p);
+        this.q = new Point(curve.q);
+        this.object = object;
+
+        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>(this,curve);
+
+        return this;
+    }
+}
+
+class ECoverℤp extends EllipticCurves<PrimeField>
+    implements Iellipticcurves<PrimeField>
+{
+    public backend:PrimeField;
+
+    constructor(field:PrimeField, curve:ECCurve) {
+        super(curve);
+        this.backend = field;
+
+        return this;
+    }
+}
+
+export { ECoverℤp };

package/galois.ts

@@ -19,17 +19,16 @@ fail = (...args:any[]): never => {
     return void 0 as never;
 }
 
-const arithmetics = (p:bigint,op:fieldops) =>
+const arithmeticsℤp = (p:bigint,op:fieldops) =>
     (op==fieldops.$add) ?
-            (a:bigint,b:bigint) => (a+b)%p :
+            (a:bigint,b:bigint=0n) => (a+b)%p :
     (op==fieldops.$sub) ?
-            (a:bigint,b:bigint) => (a-b)%p :
+            (a:bigint,b:bigint=0n) => ((a-b)<1)?(a-b+p):(a-b)%p :
     (op==fieldops.$mul) ?
-            (a:bigint,b:bigint) => (a*b)%p :
-    (op==fieldops.$div) ?
-            (a:bigint,b:bigint) => (b%p)?(a/b)%p:fail() :
-        fail();
-
+            (a:bigint,b:bigint=0n) => (a*b)%p :
+    (op==fieldops.$inv) ?
+            (a:bigint) => (!a)?fail('0 has no inverse'):Util.sqmul(a,(p-2n),p) :
+        fail('unknown field operation');
 
 Util = {
     countbits(x:bigint): bigint {
@@ -87,6 +86,45 @@ Util = {
             return (val%max);
         else
             return val;
+    },
+
+    eea(x:bigint,p:bigint): bigint {
+        return fail('eea() not implemented') as never;
+    },
+
+    sqmul(a:bigint,e:bigint,p:bigint): 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;
+
+        log(`${a}^${e} (mod ${p}) = `);
+
+        mul = (y:bigint,z:bigint,p_:bigint):bigint  => ((y*z)%p_);
+        sq  = (y:bigint,p_:bigint):bigint           => ((y*y)%p_);
+
+        val = a;
+        bitlen = this.countbits(e);
+        if (!bitlen)
+            return fail('error: n ≯  0');
+        n = (bitlen-1n);
+        bitstring = new Array<boolean>(Number(bitlen))
+            .fill(false,0,Number(bitlen))
+            .map((x:boolean,idx:number):boolean =>
+                (((e>>n--)&1n)===1n) && (!!idx));
+        // 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);
+                
+                return void 0;
+            });
+        
+        return (val%p);
     }
 }
 
@@ -94,10 +132,14 @@ enum fieldops {
     $add,
     $sub,
     $mul,
-    $div
+    $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;
     verify:()=>void;
     constructor:Function;
 }
@@ -106,38 +148,55 @@ interface Iutil {
     isprime: (p:bigint,bitlen?:bigint,s?:number)=>boolean;
     countbits: (x:bigint)=>bigint;
     rnd: (bitlen:bigint,max:bigint)=>bigint;
+    eea: (x:bigint,p:bigint)=>bigint;
+    sqmul: (a:bigint,e:bigint,p:bigint)=>bigint;
 }
 
-class GF implements Igalois {
-    private modulus: bigint;
-    private bitlen: bigint;
-    private add: (a:bigint,b:bigint)=>bigint;
-    private sub: typeof this.add;
-    private mul: typeof this.add;
-    private div: typeof this.add;
+abstract class GF implements Igalois {
+    protected modulus: bigint;
+    protected bitlen: bigint;
+    public abstract add: (a:bigint,b:bigint)=>bigint;
+    public abstract sub: typeof this.add;
+    public abstract mul: typeof this.add;
+    public abstract inv: (a:bigint)=>bigint;
+
+    public abstract verify(): void;
+
+    constructor(field:bigint,bitlen:bigint) {
+        this.modulus = field;
+        this.bitlen = bitlen;
+        this.verify();
+
+        return this;
+    }
+
+}
+
+class PrimeField extends GF implements Igalois {
+    public add: (a:bigint,b:bigint)=>bigint;
+    public sub: typeof this.add;
+    public mul: typeof this.add;
+    public inv: (a:bigint)=>bigint;
 
     public verify(): void {
         if (!Util.isprime(this.modulus))
-            return fail(this.modulus, 'needs to be prime');
+            return fail('error: p ∉ ℙ');
         else if (Util.countbits(this.modulus) > this.bitlen)
-            return fail(this.modulus, 'does not fit in bitlen:', this.bitlen);
+            return fail('error: p ≮  2ⁿ', this.bitlen);
 
         return void 0;
     }
 
     constructor(field:bigint,bitlen:bigint) {
-        this.modulus = field;
-        this.bitlen = bitlen;
-        this.verify();
-
-        this.add = arithmetics(this.modulus, fieldops.$add);
-        this.sub = arithmetics(this.modulus, fieldops.$sub);
-        this.mul = arithmetics(this.modulus, fieldops.$mul);
-        this.div = arithmetics(this.modulus, fieldops.$div);
+        super(field,bitlen);
+        this.add = arithmeticsℤp(this.modulus, fieldops.$add);
+        this.sub = arithmeticsℤp(this.modulus, fieldops.$sub);
+        this.mul = arithmeticsℤp(this.modulus, fieldops.$mul);
+        this.inv = arithmeticsℤp(this.modulus, fieldops.$inv);
 
         return this;
     }
 
 }
 
-export { Util, GF };
+export { Util, PrimeField };

package/main.js

@@ -1,5 +1,7 @@
 /* main.ts */
 import { Polynomial } from './polynomial.js';
+import { Util, PrimeField } from './galois.js';
+import { ECoverℤp } from './ellipticcurves.js';
 let log;
 log = console.log;
 let p1;
@@ -20,4 +22,5 @@ p2 = new Polynomial({ tobject: 0n, x3: 1n, x2: 0n, x: 1n, 1: 1n }, 2n);
 p3 = new Polynomial(1n << 254n, 2n);
 log(p3, p3.eval());
 // log(p3.eval());
+export { Polynomial, Util, PrimeField, ECoverℤp };
 //# sourceMappingURL=main.js.map

package/main.ts

@@ -1,5 +1,7 @@
 /* main.ts */
 import { Polynomial } from './polynomial.js';
+import { Util,PrimeField } from './galois.js';
+import { ECoverℤp } from './ellipticcurves.js';
 
 let log:(...x:any[])=>void;
 log = console.log;
@@ -26,3 +28,4 @@ p3 = new Polynomial(1n<<254n, 2n);
 log(p3, p3.eval());
 // log(p3.eval());
 
+export { Polynomial,Util,PrimeField,ECoverℤp };

package/package.json

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