@peerbit/crypto 1.0.1

package/src/signature.ts

@@ -0,0 +1,284 @@
+import {
+	deserialize,
+	variant,
+	field,
+	option,
+	serialize,
+	AbstractType,
+} from "@dao-xyz/borsh";
+import { equals } from "@peerbit/uint8arrays";
+import { verifySignatureEd25519 } from "./ed25519-sign.js";
+import { Ed25519PublicKey } from "./ed25519.js";
+import { PublicSignKey } from "./key.js";
+import { PreHash } from "./prehash.js";
+import { Secp256k1PublicKey, verifySignatureSecp256k1 } from "./sepc256k1.js";
+import { SignWithKey } from "./signer.js";
+
+@variant(0)
+export class SignatureWithKey {
+	@field({ type: Uint8Array })
+	signature: Uint8Array;
+
+	@field({ type: PublicSignKey })
+	publicKey: PublicSignKey;
+
+	@field({ type: "u8" })
+	prehash: PreHash = PreHash.NONE; // 0 no prehash, 1 sha256, 2 blake3?
+
+	constructor(props: {
+		signature: Uint8Array;
+		publicKey: PublicSignKey;
+		prehash: PreHash;
+	}) {
+		if (props) {
+			this.signature = props.signature;
+			this.publicKey = props.publicKey;
+			this.prehash = props.prehash;
+		}
+	}
+
+	equals(other: SignatureWithKey): boolean {
+		if (!equals(this.signature, other.signature)) {
+			return false;
+		}
+		return (
+			Buffer.compare(serialize(this.publicKey), serialize(other.publicKey)) ===
+				0 && this.prehash == other.prehash
+		);
+	}
+}
+
+@variant(0)
+export class MaybeSigned<T> {
+	@field({ type: Uint8Array })
+	data: Uint8Array;
+
+	@field({ type: option(SignatureWithKey) })
+	signature?: SignatureWithKey;
+
+	constructor(props?: {
+		data: Uint8Array;
+		value?: T;
+		signature?: SignatureWithKey;
+	}) {
+		if (props) {
+			this.data = props.data;
+			this.signature = props.signature;
+			this._value = props.value;
+		}
+	}
+
+	_value?: T;
+
+	getValue(constructor: AbstractType<T>): T {
+		return deserialize(this.data, constructor);
+	}
+
+	async verify(): Promise<boolean> {
+		if (!this.signature) {
+			return true;
+		}
+		return verify(this.signature, this.data);
+	}
+
+	equals(other: MaybeSigned<T>): boolean {
+		if (!equals(this.data, other.data)) {
+			return false;
+		}
+		if (!this.signature !== !other.signature) {
+			return false;
+		}
+		if (this.signature && other.signature) {
+			return this.signature.equals(other.signature);
+		}
+		return true;
+	}
+
+	/**
+	 * In place
+	 * @param signer
+	 */
+	async sign(signer: SignWithKey): Promise<MaybeSigned<T>> {
+		const signatureResult = await signer(this.data);
+		this.signature = signatureResult;
+		return this;
+	}
+}
+
+export const verify = async (signature: SignatureWithKey, data: Uint8Array) => {
+	if (signature.publicKey instanceof Ed25519PublicKey) {
+		return verifySignatureEd25519(signature, data);
+	} else if (signature.publicKey instanceof Secp256k1PublicKey) {
+		return verifySignatureSecp256k1(signature, data);
+	}
+	return false;
+};
+
+/* 
+
+@variant(0)
+export class SignatureWithKey {
+	@field({ type: Uint8Array })
+	signature: Uint8Array;
+
+	@field({ type: PublicSignKey })
+	publicKey: PublicSignKey;
+
+	constructor(props?: { signature: Uint8Array; publicKey: PublicSignKey }) {
+		if (props) {
+			this.signature = props.signature;
+			this.publicKey = props.publicKey;
+		}
+	}
+
+	equals(other: SignatureWithKey): boolean {
+		if (!equals(this.signature, other.signature)) {
+			return false;
+		}
+		return (
+			Buffer.compare(
+				serialize(this.publicKey),
+				serialize(other.publicKey)
+			) === 0
+		);
+	}
+}
+
+@variant(0)
+export abstract class MaybeSigned<T> {
+
+	@field({ type: Uint8Array })
+	data: Uint8Array;
+
+	constructor(props: {
+		data: Uint8Array;
+		value?: T;
+	}) {
+		this.data = props.data;
+		this._value = props.value;
+	}
+
+	_value?: T;
+
+	getValue(constructor: AbstractType<T>): T {
+		return deserialize(this.data, constructor);
+	}
+
+	abstract verify(): Promise<boolean>
+
+	equals(other: MaybeSigned<T>): boolean {
+		if (!equals(this.data, other.data)) {
+			return false;
+		}
+		return true;
+	}
+
+}
+
+@variant(0)
+export class Signed<T> extends MaybeSigned<T> {
+
+	@field({ type: option(SignatureWithKey) })
+	signature: SignatureWithKey;
+
+	constructor(props: {
+		data: Uint8Array;
+		value?: T;
+		signature: SignatureWithKey;
+	}) {
+		super(props)
+		this.signature = props.signature;
+
+	}
+
+	async verify(): Promise<boolean> {
+		return verify(
+			this.signature.signature,
+			this.signature.publicKey,
+			this.data
+		);
+	}
+
+	equals(other: MaybeSigned<T>): boolean {
+		if (other instanceof Signed<T>) {
+			if (!this.signature !== !other.signature) {
+				return false;
+			}
+			if (this.signature && other.signature) {
+				return this.signature.equals(other.signature);
+			}
+			return super.equals(other)
+		}
+		else {
+			return false;
+		}
+	}
+
+
+	async sign(signer: SignWithKey): Promise<MaybeSigned<T>> {
+		const signatureResult = await signer(this.data);
+		this.signature = new SignatureWithKey({
+			publicKey: signatureResult.publicKey,
+			signature: signatureResult.signature,
+		});
+		return this;
+	}
+}
+
+
+@variant(0)
+export class Unsigned<T> extends MaybeSigned<T> {
+
+
+	constructor(props: {
+		data: Uint8Array;
+		value?: T;
+	}) {
+		super(props)
+	}
+
+	equals(other: MaybeSigned<T>): boolean {
+		if (other instanceof Unsigned) {
+			return super.equals(other)
+		}
+		else {
+			return false;
+		}
+	}
+
+   
+	async sign(signer: SignWithKey): Promise<Signed<T>> {
+		const signatureResult = await signer(this.data);
+		return new Signed({
+			data: this.data,
+			signature: new SignatureWithKey({
+				publicKey: signatureResult.publicKey,
+				signature: signatureResult.signature,
+			}),
+			value: this._value
+		});
+	}
+
+	async verify(): Promise<boolean> {
+		return true;
+	}
+}
+
+
+export const verify = (
+	signature: Uint8Array,
+	publicKey: PublicSignKey,
+	data: Uint8Array
+) => {
+	if (!signature) {
+		return true;
+	}
+	if (publicKey instanceof Ed25519PublicKey) {
+		return verifySignatureEd25519(signature, publicKey, data);
+	} else if (publicKey instanceof Secp256k1PublicKey) {
+		return verifySignatureSecp256k1(signature, publicKey, data);
+	}
+	return false;
+};
+
+*/

package/src/signer.ts

@@ -0,0 +1,18 @@
+import { PublicSignKey } from "./key.js";
+import { PreHash } from "./prehash.js";
+import { SignatureWithKey } from "./signature.js";
+
+export interface Signer {
+	sign: (
+		bytes: Uint8Array,
+		prehash?: PreHash
+	) => Promise<SignatureWithKey> | SignatureWithKey;
+}
+
+export type SignWithKey = (
+	bytes: Uint8Array
+) => Promise<SignatureWithKey> | SignatureWithKey;
+
+export type Identity<T extends PublicSignKey = PublicSignKey> = Signer & {
+	publicKey: T;
+};

package/src/utils.ts

@@ -0,0 +1,15 @@
+import sodium from "libsodium-wrappers";
+export const fromHexString = (hexString: string) =>
+	Uint8Array.from(
+		hexString.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16))
+	);
+
+export const toHexString = (bytes: Uint8Array) =>
+	bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+
+export const toBase64 = (arr: Uint8Array) => {
+	return sodium.to_base64(arr, sodium.base64_variants.ORIGINAL);
+};
+export const fromBase64 = (base64: string) => {
+	return sodium.from_base64(base64, sodium.base64_variants.ORIGINAL);
+};

package/src/x25519.ts

@@ -0,0 +1,167 @@
+export * from "./errors.js";
+import { field, fixedArray, variant } from "@dao-xyz/borsh";
+import { compare } from "@peerbit/uint8arrays";
+import sodium from "libsodium-wrappers";
+import {
+	Keypair,
+	PrivateEncryptionKey,
+	PublicKeyEncryptionKey,
+} from "./key.js";
+import {
+	Ed25519Keypair,
+	Ed25519PublicKey,
+	Ed25519PrivateKey,
+} from "./ed25519.js";
+import { toHexString } from "./utils.js";
+import { PeerId } from "@libp2p/interface-peer-id";
+@variant(0)
+export class X25519PublicKey extends PublicKeyEncryptionKey {
+	@field({ type: fixedArray("u8", 32) })
+	publicKey: Uint8Array;
+
+	constructor(properties: { publicKey: Uint8Array }) {
+		super();
+		if (properties.publicKey.length !== 32) {
+			throw new Error("Expecting key to have length 32");
+		}
+		this.publicKey = properties.publicKey;
+	}
+
+	equals(other: PublicKeyEncryptionKey): boolean {
+		if (other instanceof X25519PublicKey) {
+			return compare(this.publicKey, other.publicKey) === 0;
+		}
+		return false;
+	}
+	toString(): string {
+		return "x25519p/" + toHexString(this.publicKey);
+	}
+
+	static async from(
+		ed25119PublicKey: Ed25519PublicKey
+	): Promise<X25519PublicKey> {
+		await sodium.ready;
+		return new X25519PublicKey({
+			publicKey: sodium.crypto_sign_ed25519_pk_to_curve25519(
+				ed25119PublicKey.publicKey
+			),
+		});
+	}
+
+	static async fromPeerId(peerId: PeerId): Promise<X25519PublicKey> {
+		await sodium.ready;
+		const ed = await Ed25519PublicKey.fromPeerId(peerId);
+		return X25519PublicKey.from(ed);
+	}
+
+	static async create(): Promise<X25519PublicKey> {
+		await sodium.ready;
+		return new X25519PublicKey({
+			publicKey: sodium.crypto_box_keypair().publicKey,
+		});
+	}
+}
+
+@variant(0)
+export class X25519SecretKey extends PrivateEncryptionKey {
+	@field({ type: fixedArray("u8", 32) })
+	secretKey: Uint8Array;
+
+	constructor(properties: { secretKey: Uint8Array }) {
+		super();
+		if (properties.secretKey.length !== 32) {
+			throw new Error("Expecting key to have length 32");
+		}
+		this.secretKey = properties.secretKey;
+	}
+
+	equals(other: PublicKeyEncryptionKey): boolean {
+		if (other instanceof X25519SecretKey) {
+			return (
+				compare(this.secretKey, (other as X25519SecretKey).secretKey) === 0
+			);
+		}
+		return false;
+	}
+	toString(): string {
+		return "x25519s" + toHexString(this.secretKey);
+	}
+
+	async publicKey(): Promise<X25519PublicKey> {
+		return new X25519PublicKey({
+			publicKey: sodium.crypto_scalarmult_base(this.secretKey),
+		});
+	}
+	static async from(ed25119Keypair: Ed25519Keypair): Promise<X25519SecretKey> {
+		await sodium.ready;
+		return new X25519SecretKey({
+			secretKey: sodium.crypto_sign_ed25519_sk_to_curve25519(
+				ed25119Keypair.privateKeyPublicKey
+			),
+		});
+	}
+
+	static async create(): Promise<X25519SecretKey> {
+		await sodium.ready;
+		return new X25519SecretKey({
+			secretKey: sodium.crypto_box_keypair().privateKey,
+		});
+	}
+}
+
+@variant(1)
+export class X25519Keypair extends Keypair {
+	@field({ type: X25519PublicKey })
+	publicKey: X25519PublicKey;
+
+	@field({ type: X25519SecretKey })
+	secretKey: X25519SecretKey;
+
+	constructor(properties: {
+		publicKey: X25519PublicKey;
+		secretKey: X25519SecretKey;
+	}) {
+		super();
+		this.publicKey = properties.publicKey;
+		this.secretKey = properties.secretKey;
+	}
+
+	static async create(): Promise<X25519Keypair> {
+		await sodium.ready;
+		const generated = sodium.crypto_box_keypair();
+		const kp = new X25519Keypair({
+			publicKey: new X25519PublicKey({
+				publicKey: generated.publicKey,
+			}),
+			secretKey: new X25519SecretKey({
+				secretKey: generated.privateKey,
+			}),
+		});
+
+		return kp;
+	}
+
+	static async from(ed25119Keypair: Ed25519Keypair): Promise<X25519Keypair> {
+		const kp = new X25519Keypair({
+			publicKey: await X25519PublicKey.from(ed25119Keypair.publicKey),
+			secretKey: await X25519SecretKey.from(ed25119Keypair),
+		});
+		return kp;
+	}
+
+	static fromPeerId(peerId: PeerId) {
+		const ed = Ed25519Keypair.fromPeerId(peerId);
+		return X25519Keypair.from(ed);
+	}
+	equals(other: Keypair) {
+		if (other instanceof X25519Keypair) {
+			return (
+				this.publicKey.equals(other.publicKey) &&
+				this.secretKey.equals(
+					(other as X25519Keypair).secretKey as X25519SecretKey as any
+				)
+			);
+		}
+		return false;
+	}
+}