@road-labs/ocmf-crypto-noble 0.0.1

package/build/cjs/crypto.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Crypto = void 0;
+const private_key_1 = require("./private-key");
+const public_key_1 = require("./public-key");
+const sign_1 = __importDefault(require("./sign"));
+const verify_1 = __importDefault(require("./verify"));
+class Crypto {
+    async decodeEcPrivateKey(value, format) {
+        return private_key_1.EcPrivateKey.fromEncoded(value, format);
+    }
+    async decodeEcPublicKey(value, format) {
+        return public_key_1.EcPublicKey.fromEncoded(value, format);
+    }
+    async sign(data, privateKey, hash, format) {
+        return (0, sign_1.default)(data, privateKey, hash, format);
+    }
+    async verify(signature, data, publicKey, hash, format) {
+        return (0, verify_1.default)(signature, data, publicKey, hash, format);
+    }
+}
+exports.Crypto = Crypto;

package/build/cjs/curve.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCurveFn = resolveCurveFn;
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const nist_1 = require("@noble/curves/nist");
+const modular_1 = require("@noble/curves/abstract/modular");
+const sha2_1 = require("@noble/hashes/sha2");
+const weierstrass_1 = require("@noble/curves/abstract/weierstrass");
+const secp192r1 = (0, weierstrass_1.weierstrass)({
+    a: BigInt('0xfffffffffffffffffffffffffffffffefffffffffffffffc'),
+    b: BigInt('0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1'),
+    Fp: (0, modular_1.Field)(BigInt('0xfffffffffffffffffffffffffffffffeffffffffffffffff')),
+    n: BigInt('0xffffffffffffffffffffffff99def836146bc9b1b4d22831'),
+    Gx: BigInt('0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012'),
+    Gy: BigInt('0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811'),
+    h: BigInt(1),
+    lowS: false,
+    hash: sha2_1.sha256,
+});
+const secp192k1 = (0, weierstrass_1.weierstrass)({
+    a: BigInt(0),
+    b: BigInt(3),
+    Fp: (0, modular_1.Field)(BigInt('0xfffffffffffffffffffffffffffffffffffffffeffffee37')),
+    n: BigInt('0xfffffffffffffffffffffffe26f2fc170f69466a74defd8d'),
+    Gx: BigInt('0xdb4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d'),
+    Gy: BigInt('0x9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d'),
+    h: BigInt(1),
+    lowS: false,
+    hash: sha2_1.sha256,
+});
+const brainpool256r1 = (0, weierstrass_1.weierstrass)({
+    a: BigInt('0x7d5a0975fc2c3057eef67530417affe7fb8055c126dc5c6ce94a4b44f330b5d9'),
+    b: BigInt('0x26dc5c6ce94a4b44f330b5d9bbd77cbf958416295cf7e1ce6bccdc18ff8c07b6'),
+    Fp: (0, modular_1.Field)(BigInt('0xa9fb57dba1eea9bc3e660a909d838d726e3bf623d52620282013481d1f6e5377')),
+    n: BigInt('0xa9fb57dba1eea9bc3e660a909d838d718c397aa3b561a6f7901e0e82974856a7'),
+    Gx: BigInt('0x8bd2aeb9cb7e57cb2c4b482ffc81b7afb9de27e1e3bd23c23a4453bd9ace3262'),
+    Gy: BigInt('0x547ef835c3dac4fd97f8461a14611dc9c27745132ded8e545c1d54c72f046997'),
+    h: BigInt(1),
+    lowS: false,
+    hash: sha2_1.sha256,
+});
+const brainpool384r1 = (0, weierstrass_1.weierstrass)({
+    a: BigInt('0x7bc382c63d8c150c3c72080ace05afa0c2bea28e4fb22787139165efba91f90f8aa5814a503ad4eb04a8c7dd22ce2826'),
+    b: BigInt('0x4a8c7dd22ce28268b39b55416f0447c2fb77de107dcd2a62e880ea53eeb62d57cb4390295dbc9943ab78696fa504c11'),
+    Fp: (0, modular_1.Field)(BigInt('0x8cb91e82a3386d280f5d6f7e50e641df152f7109ed5456b412b1da197fb71123acd3a729901d1a71874700133107ec53')),
+    n: BigInt('0x8cb91e82a3386d280f5d6f7e50e641df152f7109ed5456b31f166e6cac0425a7cf3ab6af6b7fc3103b883202e9046565'),
+    Gx: BigInt('0x1d1c64f068cf45ffa2a63a81b7c13f6b8847a3e77ef14fe3db7fcafe0cbd10e8e826e03436d646aaef87b2e247d4af1e'),
+    Gy: BigInt('0x8abe1d7520f9c2a45cb1eb8e95cfd55262b70b29feec5864e19c054ff99129280e4646217791811142820341263c5315'),
+    h: BigInt(1),
+    lowS: false,
+    hash: sha2_1.sha384,
+});
+function resolveCurveFn(curve) {
+    switch (curve) {
+        case 'secp192r1':
+            return secp192r1;
+        case 'secp192k1':
+            return secp192k1;
+        case 'secp256k1':
+            return secp256k1_1.secp256k1;
+        case 'secp256r1':
+            return nist_1.secp256r1;
+        case 'secp384r1':
+            return nist_1.secp384r1;
+        case 'brainpool256r1':
+            return brainpool256r1;
+        case 'brainpool384r1':
+            return brainpool384r1;
+        default:
+            throw new Error(`Failed to resolve curve: ${curve}`);
+    }
+}

package/build/cjs/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verify = exports.sign = void 0;
+__exportStar(require("./crypto"), exports);
+__exportStar(require("./curve"), exports);
+__exportStar(require("./private-key"), exports);
+__exportStar(require("./public-key"), exports);
+var sign_1 = require("./sign");
+Object.defineProperty(exports, "sign", { enumerable: true, get: function () { return __importDefault(sign_1).default; } });
+var verify_1 = require("./verify");
+Object.defineProperty(exports, "verify", { enumerable: true, get: function () { return __importDefault(verify_1).default; } });

package/build/cjs/private-key.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcPrivateKey = void 0;
+const public_key_1 = require("./public-key");
+const ocmf_crypto_1 = require("@road-labs/ocmf-crypto");
+class EcPrivateKey {
+    value;
+    curve;
+    publicKey;
+    constructor(value, curve, publicKey) {
+        this.value = value;
+        this.curve = curve;
+        this.publicKey = publicKey;
+    }
+    getValue() {
+        return this.value;
+    }
+    getCurve() {
+        return this.curve;
+    }
+    getPublicKey() {
+        return this.publicKey;
+    }
+    static fromEncoded(value, format) {
+        if (format !== 'pkcs8-der') {
+            throw new Error(`Unsupported format: ${format}`);
+        }
+        const keyInfo = (0, ocmf_crypto_1.decodePkcs8PrivateKeyInfo)(value);
+        const namedCurve = keyInfo?.privateKey?.parameters?.namedCurve;
+        if (!namedCurve) {
+            throw new Error(`Named curve not specified`);
+        }
+        const curve = ocmf_crypto_1.oidToCurve.get(namedCurve);
+        if (!curve) {
+            throw new ocmf_crypto_1.UnsupportedCurveError(`Unknown curve: oid=${namedCurve}`);
+        }
+        let publicKey = null;
+        if (keyInfo.privateKey.publicKey) {
+            publicKey = new public_key_1.EcPublicKey(keyInfo.privateKey.publicKey, curve);
+        }
+        return new EcPrivateKey(keyInfo.privateKey.privateKey, curve, publicKey);
+    }
+}
+exports.EcPrivateKey = EcPrivateKey;

package/build/cjs/public-key.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcPublicKey = void 0;
+const ocmf_crypto_1 = require("@road-labs/ocmf-crypto");
+class EcPublicKey {
+    value;
+    curve;
+    constructor(value, curve) {
+        this.value = value;
+        this.curve = curve;
+    }
+    getValue() {
+        return this.value;
+    }
+    getCurve() {
+        return this.curve;
+    }
+    static fromEncoded(value, format) {
+        if (format !== 'spki-der') {
+            throw new ocmf_crypto_1.UnsupportedPublicKeyFormatError(`Unknown format: ${format}`);
+        }
+        const keyInfo = (0, ocmf_crypto_1.decodePkixSubjectPublicKeyInfo)(value);
+        const namedCurve = keyInfo.algorithm.parameters?.namedCurve;
+        if (!namedCurve) {
+            throw new Error(`Named curve not specified`);
+        }
+        const curve = ocmf_crypto_1.oidToCurve.get(namedCurve);
+        if (!curve) {
+            throw new ocmf_crypto_1.UnsupportedCurveError(`Unknown curve: oid=${namedCurve}`);
+        }
+        return new EcPublicKey(keyInfo.subjectPublicKey, curve);
+    }
+    encode(format) {
+        if (format !== 'spki-der') {
+            throw new ocmf_crypto_1.UnsupportedPublicKeyFormatError(`Unknown format: ${format}`);
+        }
+        const namedCurve = ocmf_crypto_1.curveToOid.get(this.curve);
+        if (!namedCurve) {
+            throw new Error(`Failed to map curve to OID: ${this.curve}`);
+        }
+        return (0, ocmf_crypto_1.encodePkixSubjectPublicKeyInfo)({
+            algorithm: {
+                algorithm: ocmf_crypto_1.oidEllipticCurveKey,
+                parameters: {
+                    namedCurve,
+                },
+            },
+            subjectPublicKey: this.value,
+        });
+    }
+}
+exports.EcPublicKey = EcPublicKey;

package/build/cjs/sign.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sign;
+const sha2_1 = require("@noble/hashes/sha2");
+const curve_1 = require("./curve");
+const ocmf_crypto_1 = require("@road-labs/ocmf-crypto");
+function sign(data, privateKey, hash, format) {
+    if (hash !== 'SHA-256') {
+        throw new ocmf_crypto_1.UnsupportedHashError(`Invalid hash: ${hash}`);
+    }
+    if (format !== 'sigvalue-der') {
+        throw new ocmf_crypto_1.UnsupportedSignatureFormatError(`Invalid signature format: ${format}`);
+    }
+    return (0, curve_1.resolveCurveFn)(privateKey.getCurve())
+        .sign((0, sha2_1.sha256)(data), privateKey.getValue())
+        .toDERRawBytes();
+}

package/build/cjs/verify.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = verify;
+const sha2_1 = require("@noble/hashes/sha2");
+const curve_1 = require("./curve");
+const ocmf_crypto_1 = require("@road-labs/ocmf-crypto");
+function verify(signature, data, key, hash, format) {
+    if (hash !== 'SHA-256') {
+        throw new ocmf_crypto_1.UnsupportedHashError(`Invalid hash: ${hash}`);
+    }
+    if (format !== 'sigvalue-der') {
+        throw new ocmf_crypto_1.UnsupportedSignatureFormatError(`Invalid signature format: ${format}`);
+    }
+    return (0, curve_1.resolveCurveFn)(key.getCurve()).verify(signature, (0, sha2_1.sha256)(data), key.getValue(), { format: 'der' });
+}

package/build/es2022/crypto.js

@@ -0,0 +1,18 @@
+import { EcPrivateKey } from './private-key';
+import { EcPublicKey } from './public-key';
+import sign from './sign';
+import verify from './verify';
+export class Crypto {
+    async decodeEcPrivateKey(value, format) {
+        return EcPrivateKey.fromEncoded(value, format);
+    }
+    async decodeEcPublicKey(value, format) {
+        return EcPublicKey.fromEncoded(value, format);
+    }
+    async sign(data, privateKey, hash, format) {
+        return sign(data, privateKey, hash, format);
+    }
+    async verify(signature, data, publicKey, hash, format) {
+        return verify(signature, data, publicKey, hash, format);
+    }
+}

package/build/es2022/curve.js

@@ -0,0 +1,69 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { secp256r1, secp384r1 } from '@noble/curves/nist';
+import { Field } from '@noble/curves/abstract/modular';
+import { sha256, sha384 } from '@noble/hashes/sha2';
+import { weierstrass } from '@noble/curves/abstract/weierstrass';
+const secp192r1 = weierstrass({
+    a: BigInt('0xfffffffffffffffffffffffffffffffefffffffffffffffc'),
+    b: BigInt('0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1'),
+    Fp: Field(BigInt('0xfffffffffffffffffffffffffffffffeffffffffffffffff')),
+    n: BigInt('0xffffffffffffffffffffffff99def836146bc9b1b4d22831'),
+    Gx: BigInt('0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012'),
+    Gy: BigInt('0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811'),
+    h: BigInt(1),
+    lowS: false,
+    hash: sha256,
+});
+const secp192k1 = weierstrass({
+    a: BigInt(0),
+    b: BigInt(3),
+    Fp: Field(BigInt('0xfffffffffffffffffffffffffffffffffffffffeffffee37')),
+    n: BigInt('0xfffffffffffffffffffffffe26f2fc170f69466a74defd8d'),
+    Gx: BigInt('0xdb4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d'),
+    Gy: BigInt('0x9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d'),
+    h: BigInt(1),
+    lowS: false,
+    hash: sha256,
+});
+const brainpool256r1 = weierstrass({
+    a: BigInt('0x7d5a0975fc2c3057eef67530417affe7fb8055c126dc5c6ce94a4b44f330b5d9'),
+    b: BigInt('0x26dc5c6ce94a4b44f330b5d9bbd77cbf958416295cf7e1ce6bccdc18ff8c07b6'),
+    Fp: Field(BigInt('0xa9fb57dba1eea9bc3e660a909d838d726e3bf623d52620282013481d1f6e5377')),
+    n: BigInt('0xa9fb57dba1eea9bc3e660a909d838d718c397aa3b561a6f7901e0e82974856a7'),
+    Gx: BigInt('0x8bd2aeb9cb7e57cb2c4b482ffc81b7afb9de27e1e3bd23c23a4453bd9ace3262'),
+    Gy: BigInt('0x547ef835c3dac4fd97f8461a14611dc9c27745132ded8e545c1d54c72f046997'),
+    h: BigInt(1),
+    lowS: false,
+    hash: sha256,
+});
+const brainpool384r1 = weierstrass({
+    a: BigInt('0x7bc382c63d8c150c3c72080ace05afa0c2bea28e4fb22787139165efba91f90f8aa5814a503ad4eb04a8c7dd22ce2826'),
+    b: BigInt('0x4a8c7dd22ce28268b39b55416f0447c2fb77de107dcd2a62e880ea53eeb62d57cb4390295dbc9943ab78696fa504c11'),
+    Fp: Field(BigInt('0x8cb91e82a3386d280f5d6f7e50e641df152f7109ed5456b412b1da197fb71123acd3a729901d1a71874700133107ec53')),
+    n: BigInt('0x8cb91e82a3386d280f5d6f7e50e641df152f7109ed5456b31f166e6cac0425a7cf3ab6af6b7fc3103b883202e9046565'),
+    Gx: BigInt('0x1d1c64f068cf45ffa2a63a81b7c13f6b8847a3e77ef14fe3db7fcafe0cbd10e8e826e03436d646aaef87b2e247d4af1e'),
+    Gy: BigInt('0x8abe1d7520f9c2a45cb1eb8e95cfd55262b70b29feec5864e19c054ff99129280e4646217791811142820341263c5315'),
+    h: BigInt(1),
+    lowS: false,
+    hash: sha384,
+});
+export function resolveCurveFn(curve) {
+    switch (curve) {
+        case 'secp192r1':
+            return secp192r1;
+        case 'secp192k1':
+            return secp192k1;
+        case 'secp256k1':
+            return secp256k1;
+        case 'secp256r1':
+            return secp256r1;
+        case 'secp384r1':
+            return secp384r1;
+        case 'brainpool256r1':
+            return brainpool256r1;
+        case 'brainpool384r1':
+            return brainpool384r1;
+        default:
+            throw new Error(`Failed to resolve curve: ${curve}`);
+    }
+}

package/build/es2022/index.js

@@ -0,0 +1,6 @@
+export * from './crypto';
+export * from './curve';
+export * from './private-key';
+export * from './public-key';
+export { default as sign } from './sign';
+export { default as verify } from './verify';

package/build/es2022/private-key.js

@@ -0,0 +1,40 @@
+import { EcPublicKey } from './public-key';
+import { decodePkcs8PrivateKeyInfo, oidToCurve, UnsupportedCurveError, } from '@road-labs/ocmf-crypto';
+export class EcPrivateKey {
+    value;
+    curve;
+    publicKey;
+    constructor(value, curve, publicKey) {
+        this.value = value;
+        this.curve = curve;
+        this.publicKey = publicKey;
+    }
+    getValue() {
+        return this.value;
+    }
+    getCurve() {
+        return this.curve;
+    }
+    getPublicKey() {
+        return this.publicKey;
+    }
+    static fromEncoded(value, format) {
+        if (format !== 'pkcs8-der') {
+            throw new Error(`Unsupported format: ${format}`);
+        }
+        const keyInfo = decodePkcs8PrivateKeyInfo(value);
+        const namedCurve = keyInfo?.privateKey?.parameters?.namedCurve;
+        if (!namedCurve) {
+            throw new Error(`Named curve not specified`);
+        }
+        const curve = oidToCurve.get(namedCurve);
+        if (!curve) {
+            throw new UnsupportedCurveError(`Unknown curve: oid=${namedCurve}`);
+        }
+        let publicKey = null;
+        if (keyInfo.privateKey.publicKey) {
+            publicKey = new EcPublicKey(keyInfo.privateKey.publicKey, curve);
+        }
+        return new EcPrivateKey(keyInfo.privateKey.privateKey, curve, publicKey);
+    }
+}

package/build/es2022/public-key.js

@@ -0,0 +1,48 @@
+import { curveToOid, decodePkixSubjectPublicKeyInfo, encodePkixSubjectPublicKeyInfo, oidEllipticCurveKey, oidToCurve, UnsupportedCurveError, UnsupportedPublicKeyFormatError, } from '@road-labs/ocmf-crypto';
+export class EcPublicKey {
+    value;
+    curve;
+    constructor(value, curve) {
+        this.value = value;
+        this.curve = curve;
+    }
+    getValue() {
+        return this.value;
+    }
+    getCurve() {
+        return this.curve;
+    }
+    static fromEncoded(value, format) {
+        if (format !== 'spki-der') {
+            throw new UnsupportedPublicKeyFormatError(`Unknown format: ${format}`);
+        }
+        const keyInfo = decodePkixSubjectPublicKeyInfo(value);
+        const namedCurve = keyInfo.algorithm.parameters?.namedCurve;
+        if (!namedCurve) {
+            throw new Error(`Named curve not specified`);
+        }
+        const curve = oidToCurve.get(namedCurve);
+        if (!curve) {
+            throw new UnsupportedCurveError(`Unknown curve: oid=${namedCurve}`);
+        }
+        return new EcPublicKey(keyInfo.subjectPublicKey, curve);
+    }
+    encode(format) {
+        if (format !== 'spki-der') {
+            throw new UnsupportedPublicKeyFormatError(`Unknown format: ${format}`);
+        }
+        const namedCurve = curveToOid.get(this.curve);
+        if (!namedCurve) {
+            throw new Error(`Failed to map curve to OID: ${this.curve}`);
+        }
+        return encodePkixSubjectPublicKeyInfo({
+            algorithm: {
+                algorithm: oidEllipticCurveKey,
+                parameters: {
+                    namedCurve,
+                },
+            },
+            subjectPublicKey: this.value,
+        });
+    }
+}

package/build/es2022/sign.js

@@ -0,0 +1,14 @@
+import { sha256 } from '@noble/hashes/sha2';
+import { resolveCurveFn } from './curve';
+import { UnsupportedHashError, UnsupportedSignatureFormatError, } from '@road-labs/ocmf-crypto';
+export default function sign(data, privateKey, hash, format) {
+    if (hash !== 'SHA-256') {
+        throw new UnsupportedHashError(`Invalid hash: ${hash}`);
+    }
+    if (format !== 'sigvalue-der') {
+        throw new UnsupportedSignatureFormatError(`Invalid signature format: ${format}`);
+    }
+    return resolveCurveFn(privateKey.getCurve())
+        .sign(sha256(data), privateKey.getValue())
+        .toDERRawBytes();
+}

package/build/es2022/verify.js

@@ -0,0 +1,12 @@
+import { sha256 } from '@noble/hashes/sha2';
+import { resolveCurveFn } from './curve';
+import { UnsupportedHashError, UnsupportedSignatureFormatError, } from '@road-labs/ocmf-crypto';
+export default function verify(signature, data, key, hash, format) {
+    if (hash !== 'SHA-256') {
+        throw new UnsupportedHashError(`Invalid hash: ${hash}`);
+    }
+    if (format !== 'sigvalue-der') {
+        throw new UnsupportedSignatureFormatError(`Invalid signature format: ${format}`);
+    }
+    return resolveCurveFn(key.getCurve()).verify(signature, sha256(data), key.getValue(), { format: 'der' });
+}

package/build/types/crypto.d.ts

@@ -0,0 +1,9 @@
+import { CryptoAdapter, Hash, PrivateKeyFormat, PublicKeyFormat, SignatureFormat } from '@road-labs/ocmf-crypto';
+import { EcPrivateKey } from './private-key';
+import { EcPublicKey } from './public-key';
+export declare class Crypto implements CryptoAdapter {
+    decodeEcPrivateKey(value: Uint8Array, format: PrivateKeyFormat): Promise<EcPrivateKey>;
+    decodeEcPublicKey(value: Uint8Array, format: PublicKeyFormat): Promise<EcPublicKey>;
+    sign(data: Uint8Array, privateKey: EcPrivateKey, hash: Hash, format: SignatureFormat): Promise<Uint8Array>;
+    verify(signature: Uint8Array, data: Uint8Array, publicKey: EcPublicKey, hash: Hash, format: SignatureFormat): Promise<boolean>;
+}

package/build/types/curve.d.ts

@@ -0,0 +1,3 @@
+import { Curve } from '@road-labs/ocmf-crypto';
+import { CurveFn } from '@noble/curves/abstract/weierstrass';
+export declare function resolveCurveFn(curve: Curve): CurveFn;

package/build/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './crypto';
+export * from './curve';
+export * from './private-key';
+export * from './public-key';
+export { default as sign } from './sign';
+export { default as verify } from './verify';

package/build/types/private-key.d.ts

@@ -0,0 +1,16 @@
+import { EcPublicKey } from './public-key';
+import { Curve, PrivateKeyFormat } from '@road-labs/ocmf-crypto';
+export declare class EcPrivateKey {
+    private readonly value;
+    private readonly curve;
+    private readonly publicKey;
+    private constructor();
+    getValue(): Uint8Array;
+    getCurve(): Curve;
+    getPublicKey(): EcPublicKey | null;
+    /**
+     * @param value - Encoded private key value
+     * @param format - Encoding format
+     */
+    static fromEncoded(value: Uint8Array, format: PrivateKeyFormat): EcPrivateKey;
+}

package/build/types/public-key.d.ts

@@ -0,0 +1,10 @@
+import { Curve, PublicKeyFormat } from '@road-labs/ocmf-crypto';
+export declare class EcPublicKey {
+    private readonly value;
+    private readonly curve;
+    constructor(value: Uint8Array, curve: Curve);
+    getValue(): Uint8Array;
+    getCurve(): Curve;
+    static fromEncoded(value: Uint8Array, format: PublicKeyFormat): EcPublicKey;
+    encode(format: PublicKeyFormat): Uint8Array;
+}

package/build/types/sign.d.ts

@@ -0,0 +1,10 @@
+import { EcPrivateKey } from './private-key';
+import { Hash, SignatureFormat } from '@road-labs/ocmf-crypto';
+/**
+ * @param data - Data to be signed
+ * @param privateKey - Private key to use for signing
+ * @param hash - Hash to apply
+ * @param format - Signature format
+ * @return X.509 ECDSASigValue ASN.1 type DER encoded
+ */
+export default function sign(data: Uint8Array, privateKey: EcPrivateKey, hash: Hash, format: SignatureFormat): Uint8Array;

package/build/types/verify.d.ts

@@ -0,0 +1,10 @@
+import { EcPublicKey } from './public-key';
+import { Hash, SignatureFormat } from '@road-labs/ocmf-crypto';
+/**
+ * @param signature - X.509 ECDSASigValue ASN.1 type DER encoded
+ * @param data - Raw value
+ * @param key - The public key to verify against
+ * @param hash - Hash to apply
+ * @param format - Signature format
+ */
+export default function verify(signature: Uint8Array, data: Uint8Array, key: EcPublicKey, hash: Hash, format: SignatureFormat): boolean;

package/jest.config.js

@@ -0,0 +1,11 @@
+const { createDefaultPreset } = require('ts-jest');
+
+const tsJestTransformCfg = createDefaultPreset().transform;
+
+/** @type {import("jest").Config} **/
+module.exports = {
+  testEnvironment: 'node',
+  transform: {
+    ...tsJestTransformCfg,
+  },
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@road-labs/ocmf-crypto-noble",
+  "version": "0.0.1",
+  "main": "build/cjs/index.js",
+  "module": "build/es2022/index.js",
+  "types": "build/types/index.d.ts",
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "description": "",
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@types/node": "^22.15.30",
+    "jest": "^30.0.0",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "test-commons": "0.0.1"
+  },
+  "dependencies": {
+    "@noble/curves": "^1.9.2",
+    "@noble/hashes": "^1.8.0",
+    "@road-labs/ocmf-crypto": "0.0.1"
+  },
+  "scripts": {
+    "clear": "rimraf build",
+    "build": "pnpm run build:module && pnpm run build:types",
+    "build:module": "pnpm run build:cjs && pnpm run build:es2022",
+    "build:cjs": "tsc -p tsconfig.json --removeComments --module commonjs --outDir build/cjs",
+    "build:es2022": "tsc -p tsconfig.json --removeComments --module es2022 --outDir build/es2022",
+    "prebuild:types": "rimraf build/types",
+    "build:types": "tsc -p tsconfig.json --outDir build/types --declaration --emitDeclarationOnly",
+    "rebuild": "pnpm run clear && pnpm run build",
+    "test": "jest"
+  }
+}

package/src/crypto.ts

@@ -0,0 +1,46 @@
+import {
+  CryptoAdapter,
+  Hash,
+  PrivateKeyFormat,
+  PublicKeyFormat,
+  SignatureFormat,
+} from '@road-labs/ocmf-crypto';
+import { EcPrivateKey } from './private-key';
+import { EcPublicKey } from './public-key';
+import sign from './sign';
+import verify from './verify';
+
+export class Crypto implements CryptoAdapter {
+  async decodeEcPrivateKey(
+    value: Uint8Array,
+    format: PrivateKeyFormat
+  ): Promise<EcPrivateKey> {
+    return EcPrivateKey.fromEncoded(value, format);
+  }
+
+  async decodeEcPublicKey(
+    value: Uint8Array,
+    format: PublicKeyFormat
+  ): Promise<EcPublicKey> {
+    return EcPublicKey.fromEncoded(value, format);
+  }
+
+  async sign(
+    data: Uint8Array,
+    privateKey: EcPrivateKey,
+    hash: Hash,
+    format: SignatureFormat
+  ): Promise<Uint8Array> {
+    return sign(data, privateKey, hash, format);
+  }
+
+  async verify(
+    signature: Uint8Array,
+    data: Uint8Array,
+    publicKey: EcPublicKey,
+    hash: Hash,
+    format: SignatureFormat
+  ): Promise<boolean> {
+    return verify(signature, data, publicKey, hash, format);
+  }
+}

package/src/curve.ts

@@ -0,0 +1,101 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { secp256r1, secp384r1 } from '@noble/curves/nist';
+import { Field } from '@noble/curves/abstract/modular';
+import { sha256, sha384 } from '@noble/hashes/sha2';
+import { Curve } from '@road-labs/ocmf-crypto';
+import { CurveFn, weierstrass } from '@noble/curves/abstract/weierstrass';
+
+const secp192r1 = weierstrass({
+  a: BigInt('0xfffffffffffffffffffffffffffffffefffffffffffffffc'),
+  b: BigInt('0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1'),
+  Fp: Field(BigInt('0xfffffffffffffffffffffffffffffffeffffffffffffffff')),
+  n: BigInt('0xffffffffffffffffffffffff99def836146bc9b1b4d22831'),
+  Gx: BigInt('0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012'),
+  Gy: BigInt('0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811'),
+  h: BigInt(1),
+  lowS: false,
+  hash: sha256,
+});
+
+const secp192k1 = weierstrass({
+  a: BigInt(0),
+  b: BigInt(3),
+  Fp: Field(BigInt('0xfffffffffffffffffffffffffffffffffffffffeffffee37')),
+  n: BigInt('0xfffffffffffffffffffffffe26f2fc170f69466a74defd8d'),
+  Gx: BigInt('0xdb4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d'),
+  Gy: BigInt('0x9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d'),
+  h: BigInt(1),
+  lowS: false,
+  hash: sha256,
+});
+
+const brainpool256r1 = weierstrass({
+  a: BigInt(
+    '0x7d5a0975fc2c3057eef67530417affe7fb8055c126dc5c6ce94a4b44f330b5d9'
+  ),
+  b: BigInt(
+    '0x26dc5c6ce94a4b44f330b5d9bbd77cbf958416295cf7e1ce6bccdc18ff8c07b6'
+  ),
+  Fp: Field(
+    BigInt('0xa9fb57dba1eea9bc3e660a909d838d726e3bf623d52620282013481d1f6e5377')
+  ),
+  n: BigInt(
+    '0xa9fb57dba1eea9bc3e660a909d838d718c397aa3b561a6f7901e0e82974856a7'
+  ),
+  Gx: BigInt(
+    '0x8bd2aeb9cb7e57cb2c4b482ffc81b7afb9de27e1e3bd23c23a4453bd9ace3262'
+  ),
+  Gy: BigInt(
+    '0x547ef835c3dac4fd97f8461a14611dc9c27745132ded8e545c1d54c72f046997'
+  ),
+  h: BigInt(1),
+  lowS: false,
+  hash: sha256,
+});
+
+const brainpool384r1 = weierstrass({
+  a: BigInt(
+    '0x7bc382c63d8c150c3c72080ace05afa0c2bea28e4fb22787139165efba91f90f8aa5814a503ad4eb04a8c7dd22ce2826'
+  ),
+  b: BigInt(
+    '0x4a8c7dd22ce28268b39b55416f0447c2fb77de107dcd2a62e880ea53eeb62d57cb4390295dbc9943ab78696fa504c11'
+  ),
+  Fp: Field(
+    BigInt(
+      '0x8cb91e82a3386d280f5d6f7e50e641df152f7109ed5456b412b1da197fb71123acd3a729901d1a71874700133107ec53'
+    )
+  ),
+  n: BigInt(
+    '0x8cb91e82a3386d280f5d6f7e50e641df152f7109ed5456b31f166e6cac0425a7cf3ab6af6b7fc3103b883202e9046565'
+  ),
+  Gx: BigInt(
+    '0x1d1c64f068cf45ffa2a63a81b7c13f6b8847a3e77ef14fe3db7fcafe0cbd10e8e826e03436d646aaef87b2e247d4af1e'
+  ),
+  Gy: BigInt(
+    '0x8abe1d7520f9c2a45cb1eb8e95cfd55262b70b29feec5864e19c054ff99129280e4646217791811142820341263c5315'
+  ),
+  h: BigInt(1),
+  lowS: false,
+  hash: sha384,
+});
+
+export function resolveCurveFn(curve: Curve): CurveFn {
+  switch (curve) {
+    case 'secp192r1':
+      return secp192r1;
+    case 'secp192k1':
+      return secp192k1;
+    case 'secp256k1':
+      return secp256k1;
+    case 'secp256r1':
+      return secp256r1;
+    case 'secp384r1':
+      return secp384r1;
+    case 'brainpool256r1':
+      return brainpool256r1;
+    case 'brainpool384r1':
+      return brainpool384r1;
+    default:
+      throw new Error(`Failed to resolve curve: ${curve}`);
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './crypto';
+export * from './curve';
+export * from './private-key';
+export * from './public-key';
+export { default as sign } from './sign';
+export { default as verify } from './verify';

package/src/private-key.ts

@@ -0,0 +1,60 @@
+import { EcPublicKey } from './public-key';
+import {
+  Curve,
+  decodePkcs8PrivateKeyInfo,
+  oidToCurve,
+  PrivateKeyFormat,
+  UnsupportedCurveError,
+} from '@road-labs/ocmf-crypto';
+
+export class EcPrivateKey {
+  private constructor(
+    private readonly value: Uint8Array,
+    private readonly curve: Curve,
+    private readonly publicKey: EcPublicKey | null
+  ) {}
+
+  public getValue(): Uint8Array {
+    return this.value;
+  }
+
+  public getCurve(): Curve {
+    return this.curve;
+  }
+
+  public getPublicKey(): EcPublicKey | null {
+    return this.publicKey;
+  }
+
+  /**
+   * @param value - Encoded private key value
+   * @param format - Encoding format
+   */
+  static fromEncoded(
+    value: Uint8Array,
+    format: PrivateKeyFormat
+  ): EcPrivateKey {
+    if (format !== 'pkcs8-der') {
+      throw new Error(`Unsupported format: ${format}`);
+    }
+
+    const keyInfo = decodePkcs8PrivateKeyInfo(value);
+
+    const namedCurve = keyInfo?.privateKey?.parameters?.namedCurve;
+    if (!namedCurve) {
+      throw new Error(`Named curve not specified`);
+    }
+
+    const curve = oidToCurve.get(namedCurve);
+    if (!curve) {
+      throw new UnsupportedCurveError(`Unknown curve: oid=${namedCurve}`);
+    }
+
+    let publicKey: EcPublicKey | null = null;
+    if (keyInfo.privateKey.publicKey) {
+      publicKey = new EcPublicKey(keyInfo.privateKey.publicKey, curve);
+    }
+
+    return new EcPrivateKey(keyInfo.privateKey.privateKey, curve, publicKey);
+  }
+}

package/src/public-key.ts

@@ -0,0 +1,67 @@
+import {
+  Curve,
+  curveToOid,
+  decodePkixSubjectPublicKeyInfo,
+  encodePkixSubjectPublicKeyInfo,
+  oidEllipticCurveKey,
+  oidToCurve,
+  PublicKeyFormat,
+  UnsupportedCurveError,
+  UnsupportedPublicKeyFormatError,
+} from '@road-labs/ocmf-crypto';
+
+export class EcPublicKey {
+  constructor(
+    private readonly value: Uint8Array,
+    private readonly curve: Curve
+  ) {}
+
+  public getValue(): Uint8Array {
+    return this.value;
+  }
+
+  public getCurve(): Curve {
+    return this.curve;
+  }
+
+  static fromEncoded(value: Uint8Array, format: PublicKeyFormat): EcPublicKey {
+    if (format !== 'spki-der') {
+      throw new UnsupportedPublicKeyFormatError(`Unknown format: ${format}`);
+    }
+
+    const keyInfo = decodePkixSubjectPublicKeyInfo(value);
+
+    const namedCurve = keyInfo.algorithm.parameters?.namedCurve;
+    if (!namedCurve) {
+      throw new Error(`Named curve not specified`);
+    }
+
+    const curve = oidToCurve.get(namedCurve);
+    if (!curve) {
+      throw new UnsupportedCurveError(`Unknown curve: oid=${namedCurve}`);
+    }
+
+    return new EcPublicKey(keyInfo.subjectPublicKey, curve);
+  }
+
+  public encode(format: PublicKeyFormat): Uint8Array {
+    if (format !== 'spki-der') {
+      throw new UnsupportedPublicKeyFormatError(`Unknown format: ${format}`);
+    }
+
+    const namedCurve = curveToOid.get(this.curve);
+    if (!namedCurve) {
+      throw new Error(`Failed to map curve to OID: ${this.curve}`);
+    }
+
+    return encodePkixSubjectPublicKeyInfo({
+      algorithm: {
+        algorithm: oidEllipticCurveKey,
+        parameters: {
+          namedCurve,
+        },
+      },
+      subjectPublicKey: this.value,
+    });
+  }
+}

package/src/sign.ts

@@ -0,0 +1,36 @@
+import { EcPrivateKey } from './private-key';
+import { sha256 } from '@noble/hashes/sha2';
+import { resolveCurveFn } from './curve';
+import {
+  Hash,
+  SignatureFormat,
+  UnsupportedHashError,
+  UnsupportedSignatureFormatError,
+} from '@road-labs/ocmf-crypto';
+
+/**
+ * @param data - Data to be signed
+ * @param privateKey - Private key to use for signing
+ * @param hash - Hash to apply
+ * @param format - Signature format
+ * @return X.509 ECDSASigValue ASN.1 type DER encoded
+ */
+export default function sign(
+  data: Uint8Array,
+  privateKey: EcPrivateKey,
+  hash: Hash,
+  format: SignatureFormat
+): Uint8Array {
+  if (hash !== 'SHA-256') {
+    throw new UnsupportedHashError(`Invalid hash: ${hash}`);
+  }
+  if (format !== 'sigvalue-der') {
+    throw new UnsupportedSignatureFormatError(
+      `Invalid signature format: ${format}`
+    );
+  }
+
+  return resolveCurveFn(privateKey.getCurve())
+    .sign(sha256(data), privateKey.getValue())
+    .toDERRawBytes();
+}

package/src/verify.ts

@@ -0,0 +1,40 @@
+import { EcPublicKey } from './public-key';
+import { sha256 } from '@noble/hashes/sha2';
+import { resolveCurveFn } from './curve';
+import {
+  Hash,
+  SignatureFormat,
+  UnsupportedHashError,
+  UnsupportedSignatureFormatError,
+} from '@road-labs/ocmf-crypto';
+
+/**
+ * @param signature - X.509 ECDSASigValue ASN.1 type DER encoded
+ * @param data - Raw value
+ * @param key - The public key to verify against
+ * @param hash - Hash to apply
+ * @param format - Signature format
+ */
+export default function verify(
+  signature: Uint8Array,
+  data: Uint8Array,
+  key: EcPublicKey,
+  hash: Hash,
+  format: SignatureFormat
+): boolean {
+  if (hash !== 'SHA-256') {
+    throw new UnsupportedHashError(`Invalid hash: ${hash}`);
+  }
+  if (format !== 'sigvalue-der') {
+    throw new UnsupportedSignatureFormatError(
+      `Invalid signature format: ${format}`
+    );
+  }
+
+  return resolveCurveFn(key.getCurve()).verify(
+    signature,
+    sha256(data),
+    key.getValue(),
+    { format: 'der' }
+  );
+}

package/test/private-key.spec.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from '@jest/globals';
+import { Curve } from '@road-labs/ocmf-crypto';
+import { buildPrivateKeyTestCases } from 'test-commons';
+import { EcPrivateKey } from '../src';
+
+const curves: Curve[] = [
+  'brainpool256r1',
+  'brainpool384r1',
+  'secp192r1',
+  'secp192k1',
+  'secp256k1',
+  'secp256r1',
+  'secp384r1',
+];
+
+describe('EcPrivateKey', () => {
+  describe('fromEncoded', () => {
+    it.each(buildPrivateKeyTestCases(curves))(
+      'supports $name',
+      ({ curve, pkcs8 }) => {
+        const privateKey = EcPrivateKey.fromEncoded(pkcs8, 'pkcs8-der');
+        expect(privateKey.getCurve()).toEqual(curve);
+      }
+    );
+  });
+
+  describe('getPublicKey', () => {
+    it.each(buildPrivateKeyTestCases(curves))(
+      'can derive a public key for $name',
+      ({ curve, pkcs8, spki }) => {
+        const publicKey = EcPrivateKey.fromEncoded(
+          pkcs8,
+          'pkcs8-der'
+        ).getPublicKey();
+        expect(publicKey?.getCurve()).toEqual(curve);
+        expect(publicKey?.encode('spki-der')).toEqual(spki);
+      }
+    );
+  });
+});

package/test/public-key.spec.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from '@jest/globals';
+import { Curve } from '@road-labs/ocmf-crypto';
+import { buildPublicKeyTestCases, isValidPublicKey } from 'test-commons';
+import { EcPublicKey } from '../src';
+
+const curves: Curve[] = [
+  'brainpool256r1',
+  'brainpool384r1',
+  'secp192r1',
+  'secp192k1',
+  'secp256k1',
+  'secp256r1',
+  'secp384r1',
+];
+
+describe('EcPublicKey', () => {
+  describe('fromEncoded', () => {
+    it.each(buildPublicKeyTestCases(curves))(
+      'supports $name',
+      ({ curve, spki }) => {
+        const publicKey = EcPublicKey.fromEncoded(spki, 'spki-der');
+        expect(publicKey.getCurve()).toEqual(curve);
+      }
+    );
+  });
+
+  describe('encode', () => {
+    it.each(buildPublicKeyTestCases(curves))(
+      'encodes $name',
+      ({ spki, curve }) => {
+        const publicKey = EcPublicKey.fromEncoded(spki, 'spki-der').encode(
+          'spki-der'
+        );
+        expect(publicKey).toEqual(spki);
+        expect(isValidPublicKey(publicKey, curve)).toEqual(true);
+      }
+    );
+  });
+});

package/test/sign.spec.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from '@jest/globals';
+import { buildSignTestCases, isValidSignature } from 'test-commons';
+import { EcPrivateKey, sign } from '../src';
+import { Curve } from '@road-labs/ocmf-crypto';
+
+const format = 'sigvalue-der';
+const curves: Curve[] = [
+  'brainpool256r1',
+  'brainpool384r1',
+  'secp192r1',
+  'secp192k1',
+  'secp256k1',
+  'secp256r1',
+  'secp384r1',
+];
+
+describe('verify', () => {
+  it.each(buildSignTestCases(curves))(
+    '$name',
+    ({ curve, data, hash, pkcs8 }) => {
+      const privateKey = EcPrivateKey.fromEncoded(pkcs8, 'pkcs8-der');
+      const signature = sign(data, privateKey, hash, format);
+      expect(isValidSignature(signature, curve)).toEqual(true);
+    }
+  );
+});

package/test/verify.spec.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from '@jest/globals';
+import { buildVerifyTestCases } from 'test-commons';
+import { EcPublicKey, verify } from '../src';
+import { Curve } from '@road-labs/ocmf-crypto';
+
+const format = 'sigvalue-der';
+const curves: Curve[] = [
+  'brainpool256r1',
+  'brainpool384r1',
+  'secp192r1',
+  'secp192k1',
+  'secp256k1',
+  'secp256r1',
+  'secp384r1',
+];
+
+describe('verify', () => {
+  it.each(buildVerifyTestCases(curves))(
+    '$name',
+    ({ curve, signature, data, hash, spki, expected }) => {
+      const publicKey = EcPublicKey.fromEncoded(spki, 'spki-der');
+      const actual = verify(signature, data, publicKey, hash, format);
+      expect(actual).toEqual(expected);
+    }
+  );
+});

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src/**/*"]
+}