@peerbit/crypto 1.0.1

package/src/ed25519-sign.ts

@@ -0,0 +1,83 @@
+import { Ed25519Keypair, Ed25519PublicKey } from "./ed25519.js";
+import sodium from "libsodium-wrappers";
+import crypto from "crypto";
+import { SignatureWithKey } from "./signature.js";
+import { PreHash, prehashFn } from "./prehash.js";
+
+export const sign = async (
+	data: Uint8Array,
+	keypair: Ed25519Keypair,
+	prehash: PreHash
+) => {
+	const hashedData = await prehashFn(data, prehash);
+
+	if (!keypair.privateKey.keyObject) {
+		keypair.privateKey.keyObject = crypto.createPrivateKey({
+			format: "der",
+			type: "pkcs8",
+			key: toDER(keypair.privateKeyPublicKey, true),
+		});
+	}
+	return new SignatureWithKey({
+		prehash,
+		publicKey: keypair.publicKey,
+		signature: crypto.sign(null, hashedData, keypair.privateKey.keyObject),
+	});
+};
+
+export const verifySignatureEd25519 = async (
+	signature: SignatureWithKey,
+	data: Uint8Array
+) => {
+	let res = false;
+	try {
+		const hashedData = await prehashFn(data, signature.prehash);
+
+		/* 	return crypto.verify(null, hashedData, publicKey.keyObject, signature); */ // Sodium seems faster
+		const verified = sodium.crypto_sign_verify_detached(
+			signature.signature,
+			hashedData,
+			(signature.publicKey as Ed25519PublicKey).publicKey
+		);
+		res = verified;
+	} catch (error) {
+		return false;
+	}
+	return res;
+};
+
+const DER_PREFIX = Buffer.from([
+	48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32,
+]);
+const ED25519_OID = Buffer.from([0x06, 0x03, 0x2b, 0x65, 0x70]);
+const SEQUENCE_TAG = Buffer.from([0x30]); // Sequence tag
+const BIT_TAG = Buffer.from([0x03]); // Bit tag
+const ZERO_BIT_TAG = Buffer.from([0x00]); // Zero bit
+function toDER(key: Uint8Array, p = false) {
+	if (p) {
+		return Buffer.concat([DER_PREFIX, key]);
+	}
+
+	// Ed25519's OID
+	const oid = ED25519_OID;
+
+	// Create a byte sequence containing the OID and key
+	const elements = Buffer.concat([
+		SEQUENCE_TAG,
+		Buffer.from([oid.length]),
+		oid,
+		BIT_TAG,
+		Buffer.from([key.length + 1]),
+		ZERO_BIT_TAG,
+		key,
+	]);
+
+	// Wrap up by creating a sequence of elements
+	const der = Buffer.concat([
+		SEQUENCE_TAG,
+		Buffer.from([elements.length]),
+		elements,
+	]);
+
+	return der;
+}

package/src/ed25519.ts

@@ -0,0 +1,194 @@
+import { field, fixedArray, variant } from "@dao-xyz/borsh";
+import { PrivateSignKey, PublicSignKey, Keypair } from "./key.js";
+import { equals } from "@peerbit/uint8arrays";
+import { Identity, Signer, SignWithKey } from "./signer.js";
+import { SignatureWithKey } from "./signature.js";
+import { toHexString } from "./utils.js";
+import { peerIdFromKeys } from "@libp2p/peer-id";
+import { supportedKeys } from "@libp2p/crypto/keys";
+import { coerce } from "./bytes.js";
+import sodium from "libsodium-wrappers";
+import type { Ed25519PeerId, PeerId } from "@libp2p/interface-peer-id";
+import { sign } from "./ed25519-sign.js";
+import { PreHash } from "./prehash.js";
+import { concat } from "uint8arrays";
+
+@variant(0)
+export class Ed25519PublicKey extends PublicSignKey {
+	@field({ type: fixedArray("u8", 32) })
+	publicKey: Uint8Array;
+
+	constructor(properties: { publicKey: Uint8Array }) {
+		super();
+		this.publicKey = properties.publicKey;
+		if (properties.publicKey.length !== 32) {
+			throw new Error("Expecting key to have length 32");
+		}
+	}
+
+	equals(other: PublicSignKey): boolean {
+		if (other instanceof Ed25519PublicKey) {
+			return equals(this.publicKey, other.publicKey);
+		}
+		return false;
+	}
+	toString(): string {
+		return "ed25119p/" + toHexString(this.publicKey);
+	}
+
+	toPeerId(): Promise<PeerId> {
+		return peerIdFromKeys(
+			new supportedKeys["ed25519"].Ed25519PublicKey(this.publicKey).bytes
+		);
+	}
+
+	/* Don't use keyobject for publicKeys becuse it takes longer time to derive it compare to verifying with sodium
+	private keyObject: any;
+	get keyObject() {
+		return (
+			this._keyObject ||
+			(this._keyObject = crypto.createPublicKey({
+				format: "der",
+				type: "spki",
+				key: toDER(this.publicKey),
+			}))
+		);
+	} */
+	static fromPeerId(id: PeerId) {
+		if (!id.publicKey) {
+			throw new Error("Missing public key");
+		}
+		if (id.type === "Ed25519") {
+			return new Ed25519PublicKey({
+				publicKey: coerce(id.publicKey!.slice(4)),
+			});
+		}
+		throw new Error("Unsupported key type: " + id.type);
+	}
+}
+
+@variant(0)
+export class Ed25519PrivateKey extends PrivateSignKey {
+	@field({ type: fixedArray("u8", 32) })
+	privateKey: Uint8Array;
+
+	constructor(properties: { privateKey: Uint8Array }) {
+		super();
+
+		if (properties.privateKey.length !== 32) {
+			throw new Error("Expecting key to have length 32");
+		}
+
+		this.privateKey = properties.privateKey;
+	}
+
+	equals(other: Ed25519PrivateKey): boolean {
+		if (other instanceof Ed25519PrivateKey) {
+			return equals(this.privateKey, other.privateKey);
+		}
+		return false;
+	}
+
+	toString(): string {
+		return "ed25119s/" + toHexString(this.privateKey);
+	}
+
+	keyObject: any; // crypto.KeyObject;
+
+	static fromPeerID(id: PeerId) {
+		if (!id.privateKey) {
+			throw new Error("Missing privateKey key");
+		}
+		if (id.type === "Ed25519") {
+			return new Ed25519PrivateKey({
+				privateKey: coerce(id.privateKey!.slice(4, 36)),
+			});
+		}
+		throw new Error("Unsupported key type: " + id.type);
+	}
+}
+
+@variant(0)
+export class Ed25519Keypair extends Keypair implements Identity {
+	@field({ type: Ed25519PublicKey })
+	publicKey: Ed25519PublicKey;
+
+	@field({ type: Ed25519PrivateKey })
+	privateKey: Ed25519PrivateKey;
+
+	constructor(properties: {
+		publicKey: Ed25519PublicKey;
+		privateKey: Ed25519PrivateKey;
+	}) {
+		super();
+		this.privateKey = properties.privateKey;
+		this.publicKey = properties.publicKey;
+	}
+
+	static async create(): Promise<Ed25519Keypair> {
+		await sodium.ready;
+		const generated = sodium.crypto_sign_keypair();
+		const kp = new Ed25519Keypair({
+			publicKey: new Ed25519PublicKey({
+				publicKey: generated.publicKey,
+			}),
+			privateKey: new Ed25519PrivateKey({
+				privateKey: generated.privateKey.slice(0, 32), // Only the private key part (?)
+			}),
+		});
+
+		return kp;
+	}
+
+	sign(
+		data: Uint8Array,
+		prehash: PreHash = PreHash.NONE
+	): Promise<SignatureWithKey> {
+		return sign(data, this, prehash);
+	}
+
+	signer(prehash: PreHash): SignWithKey {
+		return async (data: Uint8Array) => {
+			return this.sign(data, prehash);
+		};
+	}
+
+	equals(other: Keypair) {
+		if (other instanceof Ed25519Keypair) {
+			return (
+				this.publicKey.equals(other.publicKey) &&
+				this.privateKey.equals(other.privateKey)
+			);
+		}
+		return false;
+	}
+
+	static fromPeerId(peerId: PeerId | Ed25519PeerId) {
+		return new Ed25519Keypair({
+			privateKey: Ed25519PrivateKey.fromPeerID(peerId),
+			publicKey: Ed25519PublicKey.fromPeerId(peerId),
+		});
+	}
+
+	_privateKeyPublicKey: Uint8Array; // length 64
+	get privateKeyPublicKey(): Uint8Array {
+		return (
+			this._privateKeyPublicKey ||
+			(this._privateKeyPublicKey = concat([
+				this.privateKey.privateKey,
+				this.publicKey.publicKey,
+			]))
+		);
+	}
+
+	toPeerId(): Promise<PeerId> {
+		return peerIdFromKeys(
+			new supportedKeys["ed25519"].Ed25519PublicKey(this.publicKey.publicKey)
+				.bytes,
+			new supportedKeys["ed25519"].Ed25519PrivateKey(
+				this.privateKeyPublicKey,
+				this.publicKey.publicKey
+			).bytes
+		);
+	}
+}

package/src/encryption.ts

@@ -0,0 +1,376 @@
+export * from "./errors.js";
+import {
+	AbstractType,
+	deserialize,
+	field,
+	serialize,
+	variant,
+	vec,
+} from "@dao-xyz/borsh";
+import { equals } from "@peerbit/uint8arrays";
+import { AccessError } from "./errors.js";
+import sodium from "libsodium-wrappers";
+import { X25519Keypair, X25519PublicKey, X25519SecretKey } from "./x25519.js";
+import { Ed25519Keypair, Ed25519PublicKey } from "./ed25519.js";
+import { randomBytes } from "./random.js";
+import { Keychain } from "./keychain.js";
+
+const NONCE_LENGTH = 24;
+
+@variant(0)
+export abstract class MaybeEncrypted<T> {
+	/**
+	 * Will throw error if not decrypted
+	 */
+	get decrypted(): DecryptedThing<T> {
+		throw new Error("Not implented");
+	}
+
+	decrypt(
+		keyOrKeychain?: Keychain | X25519Keypair
+	): Promise<DecryptedThing<T>> | DecryptedThing<T> {
+		throw new Error("Not implemented");
+	}
+	equals(other: MaybeEncrypted<T>): boolean {
+		throw new Error("Not implemented");
+	}
+
+	/**
+	 * Clear cached data
+	 */
+	clear() {
+		throw new Error("Not implemented");
+	}
+
+	abstract get byteLength(): number;
+}
+
+@variant(0)
+export class DecryptedThing<T> extends MaybeEncrypted<T> {
+	@field({ type: Uint8Array })
+	_data?: Uint8Array;
+
+	constructor(props?: { data?: Uint8Array; value?: T }) {
+		super();
+		if (props) {
+			this._data = props.data;
+			this._value = props.value;
+		}
+	}
+
+	_value?: T;
+	getValue(clazz: AbstractType<T>): T {
+		if (this._value) {
+			return this._value;
+		}
+		if (!this._data) {
+			throw new Error("Missing data");
+		}
+		return deserialize(this._data, clazz);
+	}
+
+	async encrypt(
+		x25519Keypair: X25519Keypair,
+		...recieverPublicKeys: (X25519PublicKey | Ed25519PublicKey)[]
+	): Promise<EncryptedThing<T>> {
+		const bytes = serialize(this);
+		const epheremalKey = sodium.crypto_secretbox_keygen();
+		const nonce = randomBytes(NONCE_LENGTH); // crypto random is faster than sodim random
+		const cipher = sodium.crypto_secretbox_easy(bytes, nonce, epheremalKey);
+
+		const recieverX25519PublicKeys = await Promise.all(
+			recieverPublicKeys.map((key) => {
+				if (key instanceof Ed25519PublicKey) {
+					return X25519PublicKey.from(key);
+				}
+				return key;
+			})
+		);
+
+		const ks = recieverX25519PublicKeys.map((recieverPublicKey) => {
+			const kNonce = randomBytes(NONCE_LENGTH); // crypto random is faster than sodium random
+			return new K({
+				encryptedKey: new CipherWithNonce({
+					cipher: sodium.crypto_box_easy(
+						epheremalKey,
+						kNonce,
+						recieverPublicKey.publicKey,
+						x25519Keypair.secretKey.secretKey
+					),
+					nonce: kNonce,
+				}),
+				recieverPublicKey,
+			});
+		});
+
+		const enc = new EncryptedThing<T>({
+			encrypted: new Uint8Array(cipher),
+			nonce,
+			envelope: new Envelope({
+				senderPublicKey: x25519Keypair.publicKey,
+				ks,
+			}),
+		});
+		enc._decrypted = this;
+		return enc;
+	}
+
+	get decrypted(): DecryptedThing<T> {
+		return this;
+	}
+
+	decrypt(): DecryptedThing<T> {
+		return this;
+	}
+
+	equals(other: MaybeEncrypted<T>) {
+		if (other instanceof DecryptedThing) {
+			return equals(this._data, other._data);
+		} else {
+			return false;
+		}
+	}
+
+	clear() {
+		this._value = undefined;
+	}
+
+	get byteLength() {
+		return this._data!.byteLength;
+	}
+}
+
+@variant(0)
+export class CipherWithNonce {
+	@field({ type: Uint8Array })
+	nonce: Uint8Array;
+
+	@field({ type: Uint8Array })
+	cipher: Uint8Array;
+
+	constructor(props?: { nonce: Uint8Array; cipher: Uint8Array }) {
+		if (props) {
+			this.nonce = props.nonce;
+			this.cipher = props.cipher;
+		}
+	}
+
+	equals(other: CipherWithNonce): boolean {
+		if (other instanceof CipherWithNonce) {
+			return (
+				equals(this.nonce, other.nonce) && equals(this.cipher, other.cipher)
+			);
+		} else {
+			return false;
+		}
+	}
+}
+
+@variant(0)
+export class K {
+	@field({ type: CipherWithNonce })
+	_encryptedKey: CipherWithNonce;
+
+	@field({ type: X25519PublicKey })
+	_recieverPublicKey: X25519PublicKey;
+
+	constructor(props?: {
+		encryptedKey: CipherWithNonce;
+		recieverPublicKey: X25519PublicKey;
+	}) {
+		if (props) {
+			this._encryptedKey = props.encryptedKey;
+			this._recieverPublicKey = props.recieverPublicKey;
+		}
+	}
+
+	equals(other: K): boolean {
+		if (other instanceof K) {
+			return (
+				this._encryptedKey.equals(other._encryptedKey) &&
+				this._recieverPublicKey.equals(other._recieverPublicKey)
+			);
+		} else {
+			return false;
+		}
+	}
+}
+
+@variant(0)
+export class Envelope {
+	@field({ type: X25519PublicKey })
+	_senderPublicKey: X25519PublicKey;
+
+	@field({ type: vec(K) })
+	_ks: K[];
+
+	constructor(props?: { senderPublicKey: X25519PublicKey; ks: K[] }) {
+		if (props) {
+			this._senderPublicKey = props.senderPublicKey;
+			this._ks = props.ks;
+		}
+	}
+
+	equals(other: Envelope): boolean {
+		if (other instanceof Envelope) {
+			if (!this._senderPublicKey.equals(other._senderPublicKey)) {
+				return false;
+			}
+
+			if (this._ks.length !== other._ks.length) {
+				return false;
+			}
+			for (let i = 0; i < this._ks.length; i++) {
+				if (!this._ks[i].equals(other._ks[i])) {
+					return false;
+				}
+			}
+			return true;
+		} else {
+			return false;
+		}
+	}
+}
+
+@variant(1)
+export class EncryptedThing<T> extends MaybeEncrypted<T> {
+	@field({ type: Uint8Array })
+	_encrypted: Uint8Array;
+
+	@field({ type: Uint8Array })
+	_nonce: Uint8Array;
+
+	@field({ type: Envelope })
+	_envelope: Envelope;
+
+	constructor(props?: {
+		encrypted: Uint8Array;
+		nonce: Uint8Array;
+		envelope: Envelope;
+	}) {
+		super();
+		if (props) {
+			this._encrypted = props.encrypted;
+			this._nonce = props.nonce;
+			this._envelope = props.envelope;
+		}
+	}
+
+	_decrypted?: DecryptedThing<T>;
+	get decrypted(): DecryptedThing<T> {
+		if (!this._decrypted) {
+			throw new Error(
+				"Entry has not been decrypted, invoke decrypt method before"
+			);
+		}
+		return this._decrypted;
+	}
+
+	async decrypt(
+		keyResolver?: Keychain | X25519Keypair
+	): Promise<DecryptedThing<T>> {
+		if (this._decrypted) {
+			return this._decrypted;
+		}
+
+		if (!keyResolver) {
+			throw new AccessError("Expecting key resolver");
+		}
+
+		// We only need to open with one of the keys
+		let key: { index: number; keypair: X25519Keypair } | undefined;
+		if (keyResolver instanceof X25519Keypair) {
+			for (const [i, k] of this._envelope._ks.entries()) {
+				if (k._recieverPublicKey.equals(keyResolver.publicKey)) {
+					key = {
+						index: i,
+						keypair: keyResolver,
+					};
+				}
+			}
+		} else {
+			for (const [i, k] of this._envelope._ks.entries()) {
+				const exported = await keyResolver.exportByKey(k._recieverPublicKey);
+				if (exported) {
+					key = {
+						index: i,
+						keypair: exported,
+					};
+					break;
+				}
+			}
+		}
+
+		if (key) {
+			const k = this._envelope._ks[key.index];
+			let secretKey: X25519SecretKey = undefined as any;
+			if (key.keypair instanceof X25519Keypair) {
+				secretKey = key.keypair.secretKey;
+			} else {
+				secretKey = await X25519SecretKey.from(key.keypair);
+			}
+			let epheremalKey: Uint8Array;
+			try {
+				epheremalKey = sodium.crypto_box_open_easy(
+					k._encryptedKey.cipher,
+					k._encryptedKey.nonce,
+					this._envelope._senderPublicKey.publicKey,
+					secretKey.secretKey
+				);
+			} catch (error) {
+				throw new AccessError("Failed to decrypt");
+			}
+
+			// TODO: is nested decryption necessary?
+			/*  let der: any = this;
+			 let counter = 0;
+			 while (der instanceof EncryptedThing) {
+				 const decrypted = await sodium.crypto_secretbox_open_easy(this._encrypted, this._nonce, epheremalKey);
+				 der = deserialize(decrypted, DecryptedThing)
+				 counter += 1;
+				 if (counter >= 10) {
+					 throw new Error("Unexpected decryption behaviour, data seems to always be in encrypted state")
+				 }
+			 } */
+
+			const der = deserialize(
+				sodium.crypto_secretbox_open_easy(
+					this._encrypted,
+					this._nonce,
+					epheremalKey
+				),
+				DecryptedThing
+			);
+			this._decrypted = der as DecryptedThing<T>;
+		} else {
+			throw new AccessError("Failed to resolve decryption key");
+		}
+		return this._decrypted;
+	}
+
+	equals(other: MaybeEncrypted<T>): boolean {
+		if (other instanceof EncryptedThing) {
+			if (!equals(this._encrypted, other._encrypted)) {
+				return false;
+			}
+			if (!equals(this._nonce, other._nonce)) {
+				return false;
+			}
+
+			if (!this._envelope.equals(other._envelope)) {
+				return false;
+			}
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	clear() {
+		this._decrypted = undefined;
+	}
+
+	get byteLength() {
+		return this._encrypted.byteLength; // ignore other metdata for now in the size calculation
+	}
+}

package/src/errors.ts

@@ -0,0 +1,5 @@
+export class AccessError extends Error {
+	constructor(message?: string) {
+		super(message);
+	}
+}

package/src/hash-browser.ts

@@ -0,0 +1,10 @@
+import { toBase64 } from "./utils";
+import { SHA256 } from "@stablelib/sha256";
+export const sha256Base64 = async (bytes: Uint8Array): Promise<string> =>
+	toBase64(await sha256(bytes));
+export const sha256Base64Sync = (bytes: Uint8Array): string =>
+	toBase64(new SHA256().update(bytes).digest());
+export const sha256 = async (bytes: Uint8Array): Promise<Uint8Array> =>
+	new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes));
+export const sha256Sync = (bytes: Uint8Array): Uint8Array =>
+	new SHA256().update(bytes).digest();

package/src/hash.ts

@@ -0,0 +1,10 @@
+import crypto from "crypto";
+
+export const sha256Base64Sync = (bytes: Uint8Array): string =>
+	crypto.createHash("sha256").update(bytes).digest("base64");
+export const sha256Base64 = async (bytes: Uint8Array): Promise<string> =>
+	crypto.createHash("sha256").update(bytes).digest("base64");
+export const sha256 = async (bytes: Uint8Array): Promise<Uint8Array> =>
+	crypto.createHash("sha256").update(bytes).digest();
+export const sha256Sync = (bytes: Uint8Array): Uint8Array =>
+	crypto.createHash("sha256").update(bytes).digest();

package/src/index.ts

@@ -0,0 +1,14 @@
+export * from "./key.js";
+export * from "./ed25519.js";
+export * from "./signature.js";
+export * from "./key.js";
+export * from "./sepc256k1.js";
+export * from "./x25519.js";
+export * from "./encryption.js";
+export * from "./libp2p.js";
+export * from "./utils.js";
+export * from "./hash.js";
+export * from "./random.js";
+export * from "./prehash.js";
+export * from "./signer.js";
+export * from "./keychain.js";