finitefields 0.0.9 → 0.0.10

package/ellipticcurves.ts

@@ -7,8 +7,8 @@
  *
  */
 
-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;
@@ -28,6 +28,7 @@ fail = (...args:any[]): never => {
 p256 = ():ECCurve => ({
    '#E': 0xffffffff00000000_ffffffffffffffff_bce6faada7179e84_f3b9cac2fc632551n,
     'θ': 0xffffffff00000001_0000000000000000_00000000ffffffff_ffffffffffffffffn,
+    'a': -3n,
     'b': 0x5ac635d8aa3a93e7_b3ebbd55769886bc_651d06b0cc53b0f6_3bce3c3e27d2604bn,
     'p':
      [
@@ -51,6 +52,7 @@ 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 +61,7 @@ interface Tuples {
 
 interface IECCurve {
     'θ':     bigint;
+    'a':     bigint;
     'b':     bigint;
     bitlen:  bigint;
     formula: ECformula;
@@ -72,6 +75,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 {
@@ -113,6 +118,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 +133,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,24 +148,113 @@ 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)=>bigint {
+        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(p:Point): infinity {
+        return 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_;
+
+        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);
+        Δy = f.sub(x1, x);
+        y = (f.sub(
+            f.mul(s, Δy),
+            y1
+        ) % this.backend.p);
+
+        t = new Point([x,y]);
+        if (this.isinfinity(t))
+            mt = nothing();
+        else
+            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 === 𝒪)
+        else if (empty(a))
             return <Maybe<Point>>just(b as unknown as Point);
-        else if (b === 𝒪)
+        else if (empty(b))
             return <Maybe<Point>>just(a as unknown as Point);
         else
             return <Maybe<Point>>this.addpoints(a,b);
@@ -170,6 +267,29 @@ abstract class EllipticCurves<a> implements Iellipticcurves<a> {
             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);
 
@@ -191,3 +311,4 @@ class ecℤp extends EllipticCurves<PrimeField>
 }
 
 export { ecℤp, p256 };
+export type { Point, Coordinate };

package/main.ts

@@ -1,23 +1,39 @@
 /* main.ts */
 import { Polynomial } from './polynomial.js';
 import { Util,PrimeField } from './galois.js';
-import { ecℤp, p256 } from './ellipticcurves.js';
+import { ecℤp, p256, type Coordinate, type Point } from './ellipticcurves.js';
 import { empty, fold, just, nothing } from './maybe.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 mp:Coordinate;
+let p:Point;
+let q:Point;
 
-// let field:PrimeField;
-// let curve:ecℤp;
-
-// field = new PrimeField(p256().θ, p256().bitlen);
+field = new PrimeField(p256().θ, p256().bitlen);
 // log(field);
-// curve = new ecℤp(field, p256());
+curve = new ecℤp(field, p256());
 // log(curve);
 
+// mp = curve.add(curve.p, curve.q);
+mp = curve.q;
+q = fold(mp);
+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 };

package/package.json

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