@haneullabs/haneul 0.1.0

package/src/keypairs/passkey/publickey.ts

@@ -0,0 +1,188 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fromBase64, toBase64 } from '@haneullabs/bcs';
+import { secp256r1 } from '@noble/curves/p256';
+import { sha256 } from '@noble/hashes/sha256';
+
+import { PasskeyAuthenticator } from '../../bcs/bcs.js';
+import { bytesEqual, PublicKey } from '../../cryptography/publickey.js';
+import type { PublicKeyInitData } from '../../cryptography/publickey.js';
+import { SIGNATURE_SCHEME_TO_FLAG } from '../../cryptography/signature-scheme.js';
+
+export const PASSKEY_PUBLIC_KEY_SIZE = 33;
+export const PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE = 65;
+export const PASSKEY_SIGNATURE_SIZE = 64;
+/** Fixed DER header for secp256r1 SubjectPublicKeyInfo
+DER structure for P-256 SPKI:
+30 -- SEQUENCE
+  59 -- length (89 bytes)
+  30 -- SEQUENCE
+    13 -- length (19 bytes)
+    06 -- OBJECT IDENTIFIER
+      07 -- length
+      2A 86 48 CE 3D 02 01 -- id-ecPublicKey
+    06 -- OBJECT IDENTIFIER
+      08 -- length
+      2A 86 48 CE 3D 03 01 07 -- secp256r1/prime256v1
+  03 -- BIT STRING
+    42 -- length (66 bytes)
+    00 -- padding
+	===== above bytes are considered header =====
+    04 || x || y -- uncompressed point (65 bytes: 0x04 || 32-byte x || 32-byte y)
+*/
+export const SECP256R1_SPKI_HEADER = new Uint8Array([
+	0x30,
+	0x59, // SEQUENCE, length 89
+	0x30,
+	0x13, // SEQUENCE, length 19
+	0x06,
+	0x07, // OID, length 7
+	0x2a,
+	0x86,
+	0x48,
+	0xce,
+	0x3d,
+	0x02,
+	0x01, // OID: 1.2.840.10045.2.1 (ecPublicKey)
+	0x06,
+	0x08, // OID, length 8
+	0x2a,
+	0x86,
+	0x48,
+	0xce,
+	0x3d,
+	0x03,
+	0x01,
+	0x07, // OID: 1.2.840.10045.3.1.7 (prime256v1/secp256r1)
+	0x03,
+	0x42, // BIT STRING, length 66
+	0x00, // no unused bits
+] as const);
+
+/**
+ * A passkey public key
+ */
+export class PasskeyPublicKey extends PublicKey {
+	static SIZE = PASSKEY_PUBLIC_KEY_SIZE;
+	private data: Uint8Array<ArrayBuffer>;
+
+	/**
+	 * Create a new PasskeyPublicKey object
+	 * @param value passkey public key as buffer or base-64 encoded string
+	 */
+	constructor(value: PublicKeyInitData) {
+		super();
+
+		if (typeof value === 'string') {
+			this.data = fromBase64(value);
+		} else if (value instanceof Uint8Array) {
+			this.data = value as Uint8Array<ArrayBuffer>;
+		} else {
+			this.data = Uint8Array.from(value);
+		}
+
+		if (this.data.length !== PASSKEY_PUBLIC_KEY_SIZE) {
+			throw new Error(
+				`Invalid public key input. Expected ${PASSKEY_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`,
+			);
+		}
+	}
+
+	/**
+	 * Checks if two passkey public keys are equal
+	 */
+	override equals(publicKey: PasskeyPublicKey): boolean {
+		return super.equals(publicKey);
+	}
+
+	/**
+	 * Return the byte array representation of the Secp256r1 public key
+	 */
+	toRawBytes(): Uint8Array<ArrayBuffer> {
+		return this.data;
+	}
+
+	/**
+	 * Return the Haneul address associated with this Secp256r1 public key
+	 */
+	flag(): number {
+		return SIGNATURE_SCHEME_TO_FLAG['Passkey'];
+	}
+
+	/**
+	 * Verifies that the signature is valid for for the provided message
+	 */
+	async verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {
+		const parsed = parseSerializedPasskeySignature(signature);
+		const clientDataJSON = JSON.parse(parsed.clientDataJson);
+
+		if (clientDataJSON.type !== 'webauthn.get') {
+			return false;
+		}
+
+		// parse challenge from base64 url
+		const parsedChallenge = fromBase64(
+			clientDataJSON.challenge.replace(/-/g, '+').replace(/_/g, '/'),
+		);
+		if (!bytesEqual(message, parsedChallenge)) {
+			return false;
+		}
+
+		const pk = parsed.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE);
+		if (!bytesEqual(this.toRawBytes(), pk)) {
+			return false;
+		}
+
+		const payload = new Uint8Array([...parsed.authenticatorData, ...sha256(parsed.clientDataJson)]);
+		const sig = parsed.userSignature.slice(1, PASSKEY_SIGNATURE_SIZE + 1);
+		return secp256r1.verify(sig, sha256(payload), pk);
+	}
+}
+
+/**
+ * Parses a DER SubjectPublicKeyInfo into an uncompressed public key. This also verifies
+ * that the curve used is P-256 (secp256r1).
+ *
+ * @param data: DER SubjectPublicKeyInfo
+ * @returns uncompressed public key (`0x04 || x || y`)
+ */
+export function parseDerSPKI(derBytes: Uint8Array): Uint8Array {
+	// Verify length and header bytes are expected
+	if (derBytes.length !== SECP256R1_SPKI_HEADER.length + PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE) {
+		throw new Error('Invalid DER length');
+	}
+	for (let i = 0; i < SECP256R1_SPKI_HEADER.length; i++) {
+		if (derBytes[i] !== SECP256R1_SPKI_HEADER[i]) {
+			throw new Error('Invalid spki header');
+		}
+	}
+
+	if (derBytes[SECP256R1_SPKI_HEADER.length] !== 0x04) {
+		throw new Error('Invalid point marker');
+	}
+
+	// Returns the last 65 bytes `04 || x || y`
+	return derBytes.slice(SECP256R1_SPKI_HEADER.length);
+}
+
+/**
+ * Parse signature from bytes or base64 string into the following fields.
+ */
+export function parseSerializedPasskeySignature(signature: Uint8Array | string) {
+	const bytes = typeof signature === 'string' ? fromBase64(signature) : signature;
+
+	if (bytes[0] !== SIGNATURE_SCHEME_TO_FLAG.Passkey) {
+		throw new Error('Invalid signature scheme');
+	}
+	const dec = PasskeyAuthenticator.parse(bytes.slice(1));
+	return {
+		signatureScheme: 'Passkey' as const,
+		serializedSignature: toBase64(bytes),
+		signature: bytes,
+		authenticatorData: dec.authenticatorData,
+		clientDataJson: dec.clientDataJson,
+		userSignature: new Uint8Array(dec.userSignature),
+		publicKey: new Uint8Array(dec.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE)),
+	};
+}

package/src/keypairs/passkey/types.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * The value returned from navigator.credentials.get()
+ */
+export interface AuthenticationCredential extends PublicKeyCredential {
+	response: AuthenticatorAssertionResponse;
+}
+
+/**
+ * The value returned from navigator.credentials.create()
+ */
+export interface RegistrationCredential extends PublicKeyCredential {
+	response: AuthenticatorAttestationResponse;
+}

package/src/keypairs/secp256k1/index.ts

@@ -0,0 +1,9 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export {
+	DEFAULT_SECP256K1_DERIVATION_PATH,
+	Secp256k1Keypair,
+	type Secp256k1KeypairData,
+} from './keypair.js';
+export { Secp256k1PublicKey } from './publickey.js';

package/src/keypairs/secp256k1/keypair.ts

@@ -0,0 +1,161 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { blake2b } from '@noble/hashes/blake2b';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+import { HDKey } from '@scure/bip32';
+
+import { decodeHaneulPrivateKey, encodeHaneulPrivateKey, Keypair } from '../../cryptography/keypair.js';
+import { isValidBIP32Path, mnemonicToSeed } from '../../cryptography/mnemonics.js';
+import type { PublicKey } from '../../cryptography/publickey.js';
+import type { SignatureScheme } from '../../cryptography/signature-scheme.js';
+import { Secp256k1PublicKey } from './publickey.js';
+
+export const DEFAULT_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
+
+/**
+ * Secp256k1 Keypair data
+ */
+export interface Secp256k1KeypairData {
+	publicKey: Uint8Array;
+	secretKey: Uint8Array;
+}
+
+/**
+ * An Secp256k1 Keypair used for signing transactions.
+ */
+export class Secp256k1Keypair extends Keypair {
+	private keypair: Secp256k1KeypairData;
+
+	/**
+	 * Create a new keypair instance.
+	 * Generate random keypair if no {@link Secp256k1Keypair} is provided.
+	 *
+	 * @param keypair secp256k1 keypair
+	 */
+	constructor(keypair?: Secp256k1KeypairData) {
+		super();
+		if (keypair) {
+			this.keypair = keypair;
+		} else {
+			const secretKey: Uint8Array = secp256k1.utils.randomPrivateKey();
+			const publicKey: Uint8Array = secp256k1.getPublicKey(secretKey, true);
+
+			this.keypair = { publicKey, secretKey };
+		}
+	}
+
+	/**
+	 * Get the key scheme of the keypair Secp256k1
+	 */
+	getKeyScheme(): SignatureScheme {
+		return 'Secp256k1';
+	}
+
+	/**
+	 * Generate a new random keypair
+	 */
+	static generate(): Secp256k1Keypair {
+		return new Secp256k1Keypair();
+	}
+
+	/**
+	 * Create a keypair from a raw secret key byte array.
+	 *
+	 * This method should only be used to recreate a keypair from a previously
+	 * generated secret key. Generating keypairs from a random seed should be done
+	 * with the {@link Keypair.fromSeed} method.
+	 *
+	 * @throws error if the provided secret key is invalid and validation is not skipped.
+	 *
+	 * @param secretKey secret key byte array  or Bech32 secret key string
+	 * @param options: skip secret key validation
+	 */
+
+	static fromSecretKey(
+		secretKey: Uint8Array | string,
+		options?: { skipValidation?: boolean },
+	): Secp256k1Keypair {
+		if (typeof secretKey === 'string') {
+			const decoded = decodeHaneulPrivateKey(secretKey);
+
+			if (decoded.schema !== 'Secp256k1') {
+				throw new Error(`Expected a Secp256k1 keypair, got ${decoded.schema}`);
+			}
+
+			return this.fromSecretKey(decoded.secretKey, options);
+		}
+
+		const publicKey: Uint8Array = secp256k1.getPublicKey(secretKey, true);
+		if (!options || !options.skipValidation) {
+			const encoder = new TextEncoder();
+			const signData = encoder.encode('sui validation');
+			const msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));
+			const signature = secp256k1.sign(msgHash, secretKey);
+			if (!secp256k1.verify(signature, msgHash, publicKey, { lowS: true })) {
+				throw new Error('Provided secretKey is invalid');
+			}
+		}
+		return new Secp256k1Keypair({ publicKey, secretKey });
+	}
+
+	/**
+	 * Generate a keypair from a 32 byte seed.
+	 *
+	 * @param seed seed byte array
+	 */
+	static fromSeed(seed: Uint8Array): Secp256k1Keypair {
+		const publicKey = secp256k1.getPublicKey(seed, true);
+		return new Secp256k1Keypair({ publicKey, secretKey: seed });
+	}
+
+	/**
+	 * The public key for this keypair
+	 */
+	getPublicKey(): PublicKey {
+		return new Secp256k1PublicKey(this.keypair.publicKey);
+	}
+	/**
+	 * The Bech32 secret key string for this Secp256k1 keypair
+	 */
+	getSecretKey(): string {
+		return encodeHaneulPrivateKey(this.keypair.secretKey, this.getKeyScheme());
+	}
+
+	/**
+	 * Return the signature for the provided data.
+	 */
+	async sign(data: Uint8Array) {
+		const msgHash = sha256(data);
+		const sig = secp256k1.sign(msgHash, this.keypair.secretKey, {
+			lowS: true,
+		});
+		return sig.toCompactRawBytes() as Uint8Array<ArrayBuffer>;
+	}
+
+	/**
+	 * Derive Secp256k1 keypair from mnemonics and path. The mnemonics must be normalized
+	 * and validated against the english wordlist.
+	 *
+	 * If path is none, it will default to m/54'/784'/0'/0/0, otherwise the path must
+	 * be compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}.
+	 */
+	static deriveKeypair(mnemonics: string, path?: string): Secp256k1Keypair {
+		if (path == null) {
+			path = DEFAULT_SECP256K1_DERIVATION_PATH;
+		}
+		if (!isValidBIP32Path(path)) {
+			throw new Error('Invalid derivation path');
+		}
+		const key = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path);
+		if (key.publicKey == null || key.privateKey == null) {
+			throw new Error('Invalid key');
+		}
+		return new Secp256k1Keypair({
+			publicKey: key.publicKey,
+			secretKey: key.privateKey,
+		});
+	}
+}

package/src/keypairs/secp256k1/publickey.ts

@@ -0,0 +1,94 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fromBase64 } from '@haneullabs/bcs';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { sha256 } from '@noble/hashes/sha256';
+
+import {
+	bytesEqual,
+	parseSerializedKeypairSignature,
+	PublicKey,
+} from '../../cryptography/publickey.js';
+import type { PublicKeyInitData } from '../../cryptography/publickey.js';
+import { SIGNATURE_SCHEME_TO_FLAG } from '../../cryptography/signature-scheme.js';
+
+const SECP256K1_PUBLIC_KEY_SIZE = 33;
+
+/**
+ * A Secp256k1 public key
+ */
+export class Secp256k1PublicKey extends PublicKey {
+	static SIZE = SECP256K1_PUBLIC_KEY_SIZE;
+	private data: Uint8Array<ArrayBuffer>;
+
+	/**
+	 * Create a new Secp256k1PublicKey object
+	 * @param value secp256k1 public key as buffer or base-64 encoded string
+	 */
+	constructor(value: PublicKeyInitData) {
+		super();
+
+		if (typeof value === 'string') {
+			this.data = fromBase64(value);
+		} else if (value instanceof Uint8Array) {
+			this.data = value as Uint8Array<ArrayBuffer>;
+		} else {
+			this.data = Uint8Array.from(value);
+		}
+
+		if (this.data.length !== SECP256K1_PUBLIC_KEY_SIZE) {
+			throw new Error(
+				`Invalid public key input. Expected ${SECP256K1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`,
+			);
+		}
+	}
+
+	/**
+	 * Checks if two Secp256k1 public keys are equal
+	 */
+	override equals(publicKey: Secp256k1PublicKey): boolean {
+		return super.equals(publicKey);
+	}
+
+	/**
+	 * Return the byte array representation of the Secp256k1 public key
+	 */
+	toRawBytes(): Uint8Array<ArrayBuffer> {
+		return this.data;
+	}
+
+	/**
+	 * Return the Haneul address associated with this Secp256k1 public key
+	 */
+	flag(): number {
+		return SIGNATURE_SCHEME_TO_FLAG['Secp256k1'];
+	}
+
+	/**
+	 * Verifies that the signature is valid for for the provided message
+	 */
+	async verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {
+		let bytes;
+		if (typeof signature === 'string') {
+			const parsed = parseSerializedKeypairSignature(signature);
+			if (parsed.signatureScheme !== 'Secp256k1') {
+				throw new Error('Invalid signature scheme');
+			}
+
+			if (!bytesEqual(this.toRawBytes(), parsed.publicKey)) {
+				throw new Error('Signature does not match public key');
+			}
+
+			bytes = parsed.signature;
+		} else {
+			bytes = signature;
+		}
+
+		return secp256k1.verify(
+			secp256k1.Signature.fromCompact(bytes),
+			sha256(message),
+			this.toRawBytes(),
+		);
+	}
+}

package/src/keypairs/secp256r1/index.ts

@@ -0,0 +1,9 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export {
+	DEFAULT_SECP256R1_DERIVATION_PATH,
+	Secp256r1Keypair,
+	type Secp256r1KeypairData,
+} from './keypair.js';
+export { Secp256r1PublicKey } from './publickey.js';

package/src/keypairs/secp256r1/keypair.ts

@@ -0,0 +1,157 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { secp256r1 } from '@noble/curves/p256';
+import { blake2b } from '@noble/hashes/blake2b';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+import { HDKey } from '@scure/bip32';
+
+import { decodeHaneulPrivateKey, encodeHaneulPrivateKey, Keypair } from '../../cryptography/keypair.js';
+import { isValidBIP32Path, mnemonicToSeed } from '../../cryptography/mnemonics.js';
+import type { PublicKey } from '../../cryptography/publickey.js';
+import type { SignatureScheme } from '../../cryptography/signature-scheme.js';
+import { Secp256r1PublicKey } from './publickey.js';
+
+export const DEFAULT_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
+
+/**
+ * Secp256r1 Keypair data
+ */
+export interface Secp256r1KeypairData {
+	publicKey: Uint8Array;
+	secretKey: Uint8Array;
+}
+
+/**
+ * An Secp256r1 Keypair used for signing transactions.
+ */
+export class Secp256r1Keypair extends Keypair {
+	private keypair: Secp256r1KeypairData;
+
+	/**
+	 * Create a new keypair instance.
+	 * Generate random keypair if no {@link Secp256r1Keypair} is provided.
+	 *
+	 * @param keypair Secp256r1 keypair
+	 */
+	constructor(keypair?: Secp256r1KeypairData) {
+		super();
+		if (keypair) {
+			this.keypair = keypair;
+		} else {
+			const secretKey: Uint8Array = secp256r1.utils.randomPrivateKey();
+			const publicKey: Uint8Array = secp256r1.getPublicKey(secretKey, true);
+
+			this.keypair = { publicKey, secretKey };
+		}
+	}
+
+	/**
+	 * Get the key scheme of the keypair Secp256r1
+	 */
+	getKeyScheme(): SignatureScheme {
+		return 'Secp256r1';
+	}
+
+	/**
+	 * Generate a new random keypair
+	 */
+	static generate(): Secp256r1Keypair {
+		return new Secp256r1Keypair();
+	}
+
+	/**
+	 * Create a keypair from a raw secret key byte array.
+	 *
+	 * This method should only be used to recreate a keypair from a previously
+	 * generated secret key. Generating keypairs from a random seed should be done
+	 * with the {@link Keypair.fromSeed} method.
+	 *
+	 * @throws error if the provided secret key is invalid and validation is not skipped.
+	 *
+	 * @param secretKey secret key byte array or Bech32 secret key string
+	 * @param options: skip secret key validation
+	 */
+
+	static fromSecretKey(
+		secretKey: Uint8Array | string,
+		options?: { skipValidation?: boolean },
+	): Secp256r1Keypair {
+		if (typeof secretKey === 'string') {
+			const decoded = decodeHaneulPrivateKey(secretKey);
+
+			if (decoded.schema !== 'Secp256r1') {
+				throw new Error(`Expected a Secp256r1 keypair, got ${decoded.schema}`);
+			}
+
+			return this.fromSecretKey(decoded.secretKey, options);
+		}
+
+		const publicKey: Uint8Array = secp256r1.getPublicKey(secretKey, true);
+		if (!options || !options.skipValidation) {
+			const encoder = new TextEncoder();
+			const signData = encoder.encode('sui validation');
+			const msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));
+			const signature = secp256r1.sign(msgHash, secretKey, { lowS: true });
+			if (!secp256r1.verify(signature, msgHash, publicKey, { lowS: true })) {
+				throw new Error('Provided secretKey is invalid');
+			}
+		}
+		return new Secp256r1Keypair({ publicKey, secretKey });
+	}
+
+	/**
+	 * Generate a keypair from a 32 byte seed.
+	 *
+	 * @param seed seed byte array
+	 */
+	static fromSeed(seed: Uint8Array): Secp256r1Keypair {
+		const publicKey = secp256r1.getPublicKey(seed, true);
+		return new Secp256r1Keypair({ publicKey, secretKey: seed });
+	}
+
+	/**
+	 * The public key for this keypair
+	 */
+	getPublicKey(): PublicKey {
+		return new Secp256r1PublicKey(this.keypair.publicKey);
+	}
+
+	/**
+	 * The Bech32 secret key string for this Secp256r1 keypair
+	 */
+	getSecretKey(): string {
+		return encodeHaneulPrivateKey(this.keypair.secretKey, this.getKeyScheme());
+	}
+
+	/**
+	 * Return the signature for the provided data.
+	 */
+	async sign(data: Uint8Array) {
+		const msgHash = sha256(data);
+		const sig = secp256r1.sign(msgHash, this.keypair.secretKey, {
+			lowS: true,
+		});
+		return sig.toCompactRawBytes() as Uint8Array<ArrayBuffer>;
+	}
+
+	/**
+	 * Derive Secp256r1 keypair from mnemonics and path. The mnemonics must be normalized
+	 * and validated against the english wordlist.
+	 *
+	 * If path is none, it will default to m/74'/784'/0'/0/0, otherwise the path must
+	 * be compliant to BIP-32 in form m/74'/784'/{account_index}'/{change_index}/{address_index}.
+	 */
+	static deriveKeypair(mnemonics: string, path?: string): Secp256r1Keypair {
+		if (path == null) {
+			path = DEFAULT_SECP256R1_DERIVATION_PATH;
+		}
+		if (!isValidBIP32Path(path)) {
+			throw new Error('Invalid derivation path');
+		}
+		// We use HDKey which is hardcoded to use Secp256k1 but since we only need the 32 bytes for the private key it's okay to use here as well.
+		const privateKey = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path).privateKey;
+		return Secp256r1Keypair.fromSecretKey(privateKey!);
+	}
+}