@atproto/crypto 0.3.0 → 0.3.1-next.0

package/src/did.ts

@@ -1,13 +1,8 @@
 import * as uint8arrays from 'uint8arrays'
-import * as p256 from './p256/encoding'
-import * as secp from './secp256k1/encoding'
+
+import { BASE58_MULTIBASE_PREFIX, DID_KEY_PREFIX } from './const'
 import plugins from './plugins'
-import {
-  BASE58_MULTIBASE_PREFIX,
-  DID_KEY_PREFIX,
-  P256_JWT_ALG,
-  SECP256K1_JWT_ALG,
-} from './const'
+import { extractMultikey, extractPrefixedBytes, hasPrefix } from './utils'
 
 export type ParsedMultikey = {
   jwtAlg: string
@@ -15,23 +10,14 @@ export type ParsedMultikey = {
 }
 
 export const parseMultikey = (multikey: string): ParsedMultikey => {
-  if (!multikey.startsWith(BASE58_MULTIBASE_PREFIX)) {
-    throw new Error(`Incorrect prefix for multikey: ${multikey}`)
-  }
-  const prefixedBytes = uint8arrays.fromString(
-    multikey.slice(BASE58_MULTIBASE_PREFIX.length),
-    'base58btc',
-  )
+  const prefixedBytes = extractPrefixedBytes(multikey)
   const plugin = plugins.find((p) => hasPrefix(prefixedBytes, p.prefix))
   if (!plugin) {
     throw new Error('Unsupported key type')
   }
-  let keyBytes = prefixedBytes.slice(plugin.prefix.length)
-  if (plugin.jwtAlg === P256_JWT_ALG) {
-    keyBytes = p256.decompressPubkey(keyBytes)
-  } else if (plugin.jwtAlg === SECP256K1_JWT_ALG) {
-    keyBytes = secp.decompressPubkey(keyBytes)
-  }
+  const keyBytes = plugin.decompressPubkey(
+    prefixedBytes.slice(plugin.prefix.length),
+  )
   return {
     jwtAlg: plugin.jwtAlg,
     keyBytes,
@@ -46,28 +32,20 @@ export const formatMultikey = (
   if (!plugin) {
     throw new Error('Unsupported key type')
   }
-  if (jwtAlg === P256_JWT_ALG) {
-    keyBytes = p256.compressPubkey(keyBytes)
-  } else if (jwtAlg === SECP256K1_JWT_ALG) {
-    keyBytes = secp.compressPubkey(keyBytes)
-  }
-  const prefixedBytes = uint8arrays.concat([plugin.prefix, keyBytes])
+  const prefixedBytes = uint8arrays.concat([
+    plugin.prefix,
+    plugin.compressPubkey(keyBytes),
+  ])
   return (
     BASE58_MULTIBASE_PREFIX + uint8arrays.toString(prefixedBytes, 'base58btc')
   )
 }
 
 export const parseDidKey = (did: string): ParsedMultikey => {
-  if (!did.startsWith(DID_KEY_PREFIX)) {
-    throw new Error(`Incorrect prefix for did:key: ${did}`)
-  }
-  return parseMultikey(did.slice(DID_KEY_PREFIX.length))
+  const multikey = extractMultikey(did)
+  return parseMultikey(multikey)
 }
 
 export const formatDidKey = (jwtAlg: string, keyBytes: Uint8Array): string => {
   return DID_KEY_PREFIX + formatMultikey(jwtAlg, keyBytes)
 }
-
-const hasPrefix = (bytes: Uint8Array, prefix: Uint8Array): boolean => {
-  return uint8arrays.equals(prefix, bytes.subarray(0, prefix.byteLength))
-}

package/src/p256/keypair.ts

@@ -1,7 +1,11 @@
 import { p256 } from '@noble/curves/p256'
 import { sha256 } from '@noble/hashes/sha256'
-import * as uint8arrays from 'uint8arrays'
-import { SupportedEncodings } from 'uint8arrays/util/bases'
+import { SupportedEncodings } from 'uint8arrays/to-string'
+import {
+  fromString as ui8FromString,
+  toString as ui8ToString,
+} from 'uint8arrays'
+
 import * as did from '../did'
 import { P256_JWT_ALG } from '../const'
 import { Keypair } from '../types'
@@ -32,9 +36,7 @@ export class P256Keypair implements Keypair {
   ): Promise<P256Keypair> {
     const { exportable = false } = opts || {}
     const privKeyBytes =
-      typeof privKey === 'string'
-        ? uint8arrays.fromString(privKey, 'hex')
-        : privKey
+      typeof privKey === 'string' ? ui8FromString(privKey, 'hex') : privKey
     return new P256Keypair(privKeyBytes, exportable)
   }
 
@@ -43,7 +45,7 @@ export class P256Keypair implements Keypair {
   }
 
   publicKeyStr(encoding: SupportedEncodings = 'base64pad'): string {
-    return uint8arrays.toString(this.publicKey, encoding)
+    return ui8ToString(this.publicKey, encoding)
   }
 
   did(): string {

package/src/p256/operations.ts

@@ -1,9 +1,10 @@
 import { p256 } from '@noble/curves/p256'
 import { sha256 } from '@noble/hashes/sha256'
-import * as ui8 from 'uint8arrays'
-import { P256_JWT_ALG } from '../const'
-import { parseDidKey } from '../did'
+import { equals as ui8equals } from 'uint8arrays'
+
+import { P256_DID_PREFIX } from '../const'
 import { VerifyOptions } from '../types'
+import { extractMultikey, extractPrefixedBytes, hasPrefix } from '../utils'
 
 export const verifyDidSig = async (
   did: string,
@@ -11,10 +12,11 @@ export const verifyDidSig = async (
   sig: Uint8Array,
   opts?: VerifyOptions,
 ): Promise<boolean> => {
-  const { jwtAlg, keyBytes } = parseDidKey(did)
-  if (jwtAlg !== P256_JWT_ALG) {
+  const prefixedBytes = extractPrefixedBytes(extractMultikey(did))
+  if (!hasPrefix(prefixedBytes, P256_DID_PREFIX)) {
     throw new Error(`Not a P-256 did:key: ${did}`)
   }
+  const keyBytes = prefixedBytes.slice(P256_DID_PREFIX.length)
   return verifySig(keyBytes, data, sig, opts)
 }
 
@@ -39,7 +41,7 @@ export const verifySig = async (
 export const isCompactFormat = (sig: Uint8Array) => {
   try {
     const parsed = p256.Signature.fromCompact(sig)
-    return ui8.equals(parsed.toCompactRawBytes(), sig)
+    return ui8equals(parsed.toCompactRawBytes(), sig)
   } catch {
     return false
   }

package/src/p256/plugin.ts

@@ -1,11 +1,16 @@
-import * as operations from './operations'
+import { verifyDidSig } from './operations'
+import { compressPubkey, decompressPubkey } from './encoding'
+
 import { DidKeyPlugin } from '../types'
 import { P256_DID_PREFIX, P256_JWT_ALG } from '../const'
 
 export const p256Plugin: DidKeyPlugin = {
   prefix: P256_DID_PREFIX,
   jwtAlg: P256_JWT_ALG,
-  verifySignature: operations.verifyDidSig,
+  verifySignature: verifyDidSig,
+
+  compressPubkey,
+  decompressPubkey,
 }
 
 export default p256Plugin

package/src/secp256k1/keypair.ts

@@ -1,9 +1,13 @@
 import { secp256k1 as k256 } from '@noble/curves/secp256k1'
 import { sha256 } from '@noble/hashes/sha256'
-import * as uint8arrays from 'uint8arrays'
-import { SupportedEncodings } from 'uint8arrays/util/bases'
-import * as did from '../did'
+import {
+  fromString as ui8FromString,
+  toString as ui8ToString,
+} from 'uint8arrays'
+import { SupportedEncodings } from 'uint8arrays/to-string'
+
 import { SECP256K1_JWT_ALG } from '../const'
+import * as did from '../did'
 import { Keypair } from '../types'
 
 export type Secp256k1KeypairOptions = {
@@ -32,9 +36,7 @@ export class Secp256k1Keypair implements Keypair {
   ): Promise<Secp256k1Keypair> {
     const { exportable = false } = opts || {}
     const privKeyBytes =
-      typeof privKey === 'string'
-        ? uint8arrays.fromString(privKey, 'hex')
-        : privKey
+      typeof privKey === 'string' ? ui8FromString(privKey, 'hex') : privKey
     return new Secp256k1Keypair(privKeyBytes, exportable)
   }
 
@@ -43,7 +45,7 @@ export class Secp256k1Keypair implements Keypair {
   }
 
   publicKeyStr(encoding: SupportedEncodings = 'base64pad'): string {
-    return uint8arrays.toString(this.publicKey, encoding)
+    return ui8ToString(this.publicKey, encoding)
   }
 
   did(): string {

package/src/secp256k1/operations.ts

@@ -1,9 +1,10 @@
 import { secp256k1 as k256 } from '@noble/curves/secp256k1'
 import { sha256 } from '@noble/hashes/sha256'
 import * as ui8 from 'uint8arrays'
-import { SECP256K1_JWT_ALG } from '../const'
-import { parseDidKey } from '../did'
+
+import { SECP256K1_DID_PREFIX } from '../const'
 import { VerifyOptions } from '../types'
+import { extractMultikey, extractPrefixedBytes, hasPrefix } from '../utils'
 
 export const verifyDidSig = async (
   did: string,
@@ -11,10 +12,11 @@ export const verifyDidSig = async (
   sig: Uint8Array,
   opts?: VerifyOptions,
 ): Promise<boolean> => {
-  const { jwtAlg, keyBytes } = parseDidKey(did)
-  if (jwtAlg !== SECP256K1_JWT_ALG) {
+  const prefixedBytes = extractPrefixedBytes(extractMultikey(did))
+  if (!hasPrefix(prefixedBytes, SECP256K1_DID_PREFIX)) {
     throw new Error(`Not a secp256k1 did:key: ${did}`)
   }
+  const keyBytes = prefixedBytes.slice(SECP256K1_DID_PREFIX.length)
   return verifySig(keyBytes, data, sig, opts)
 }
 

package/src/secp256k1/plugin.ts

@@ -1,11 +1,16 @@
-import * as operations from './operations'
+import { verifyDidSig } from './operations'
+import { compressPubkey, decompressPubkey } from './encoding'
+
 import { DidKeyPlugin } from '../types'
 import { SECP256K1_DID_PREFIX, SECP256K1_JWT_ALG } from '../const'
 
 export const secp256k1Plugin: DidKeyPlugin = {
   prefix: SECP256K1_DID_PREFIX,
   jwtAlg: SECP256K1_JWT_ALG,
-  verifySignature: operations.verifyDidSig,
+  verifySignature: verifyDidSig,
+
+  compressPubkey,
+  decompressPubkey,
 }
 
 export default secp256k1Plugin

package/src/sha.ts

@@ -9,3 +9,10 @@ export const sha256 = async (
     typeof input === 'string' ? uint8arrays.fromString(input, 'utf8') : input
   return noble.sha256(bytes)
 }
+
+export const sha256Hex = async (
+  input: Uint8Array | string,
+): Promise<string> => {
+  const hash = await sha256(input)
+  return uint8arrays.toString(hash, 'hex')
+}

package/src/types.ts

@@ -9,6 +9,10 @@ export interface Didable {
 
 export interface Keypair extends Signer, Didable {}
 
+export interface ExportableKeypair extends Keypair {
+  export(): Promise<Uint8Array>
+}
+
 export type DidKeyPlugin = {
   prefix: Uint8Array
   jwtAlg: string
@@ -18,6 +22,9 @@ export type DidKeyPlugin = {
     data: Uint8Array,
     opts?: VerifyOptions,
   ) => Promise<boolean>
+
+  compressPubkey: (uncompressed: Uint8Array) => Uint8Array
+  decompressPubkey: (compressed: Uint8Array) => Uint8Array
 }
 
 export type VerifyOptions = {

package/src/utils.ts

@@ -0,0 +1,23 @@
+import * as uint8arrays from 'uint8arrays'
+import { BASE58_MULTIBASE_PREFIX, DID_KEY_PREFIX } from './const'
+
+export const extractMultikey = (did: string): string => {
+  if (!did.startsWith(DID_KEY_PREFIX)) {
+    throw new Error(`Incorrect prefix for did:key: ${did}`)
+  }
+  return did.slice(DID_KEY_PREFIX.length)
+}
+
+export const extractPrefixedBytes = (multikey: string): Uint8Array => {
+  if (!multikey.startsWith(BASE58_MULTIBASE_PREFIX)) {
+    throw new Error(`Incorrect prefix for multikey: ${multikey}`)
+  }
+  return uint8arrays.fromString(
+    multikey.slice(BASE58_MULTIBASE_PREFIX.length),
+    'base58btc',
+  )
+}
+
+export const hasPrefix = (bytes: Uint8Array, prefix: Uint8Array): boolean => {
+  return uint8arrays.equals(prefix, bytes.subarray(0, prefix.byteLength))
+}

package/tests/signatures.test.ts

@@ -2,11 +2,11 @@ import fs from 'node:fs'
 import * as uint8arrays from 'uint8arrays'
 import { secp256k1 as nobleK256 } from '@noble/curves/secp256k1'
 import { p256 as nobleP256 } from '@noble/curves/p256'
+import { cborEncode } from '@atproto/common'
 import EcdsaKeypair from '../src/p256/keypair'
 import Secp256k1Keypair from '../src/secp256k1/keypair'
 import * as p256 from '../src/p256/operations'
 import * as secp from '../src/secp256k1/operations'
-import { cborEncode } from '@atproto/common'
 import {
   bytesToMultibase,
   multibaseToBytes,
@@ -137,6 +137,7 @@ describe('signatures', () => {
   })
 })
 
+// @ts-expect-error
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 async function generateTestVectors(): Promise<TestVector[]> {
   const p256Key = await EcdsaKeypair.create({ exportable: true })

package/tsconfig.build.json

@@ -1,4 +1,8 @@
 {
-  "extends": "./tsconfig.json",
-  "exclude": ["**/*.spec.ts", "**/*.test.ts"]
+  "extends": "../../tsconfig/isomorphic.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["./src"]
 }

package/tsconfig.json

@@ -1,9 +1,7 @@
 {
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./dist", // Your outDir,
-    "emitDeclarationOnly": true
-  },
-  "include": ["./src", "__tests__/**/**.ts"]
+  "include": [],
+  "references": [
+    { "path": "./tsconfig.build.json" },
+    { "path": "./tsconfig.tests.json" }
+  ]
 }

package/tsconfig.tests.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig/tests.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./tests"]
+}

package/build.js

@@ -1,14 +0,0 @@
-const { nodeExternalsPlugin } = require('esbuild-node-externals')
-
-const buildShallow =
-  process.argv.includes('--shallow') || process.env.ATP_BUILD_SHALLOW === 'true'
-
-require('esbuild').build({
-  logLevel: 'info',
-  entryPoints: ['src/index.ts'],
-  bundle: true,
-  sourcemap: true,
-  outdir: 'dist',
-  platform: 'node',
-  plugins: buildShallow ? [nodeExternalsPlugin()] : [],
-})