finitefields 0.0.5 → 0.0.6

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,6 @@
 /* main.ts */
 import { Polynomial } from './polynomial.js';
+import { Util, PrimeField } from './galois.js';
 let log;
 log = console.log;
 let p1;
@@ -20,4 +21,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 };
 //# sourceMappingURL=main.js.map

package/main.ts

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

package/package.json

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