@road-labs/ocmf-crypto-noble 0.0.1 → 0.0.3

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@road-labs/ocmf-crypto-noble",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "main": "build/cjs/index.js",
   "module": "build/es2022/index.js",
   "types": "build/types/index.d.ts",
+  "files": [
+    "build/**/*"
+  ],
   "keywords": [],
   "author": "",
   "license": "MIT",
@@ -21,7 +24,7 @@
   "dependencies": {
     "@noble/curves": "^1.9.2",
     "@noble/hashes": "^1.8.0",
-    "@road-labs/ocmf-crypto": "0.0.1"
+    "@road-labs/ocmf-crypto": "0.0.3"
   },
   "scripts": {
     "clear": "rimraf build",

package/jest.config.js

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

package/src/crypto.ts

@@ -1,46 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

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