@haneullabs/seal 0.1.0 → 1.1.1

package/dist/shamir.mjs

@@ -0,0 +1,730 @@
+import { allEqual, hasDuplicates } from "./utils.mjs";
+
+//#region src/shamir.ts
+const GF256_SIZE = 256;
+/**
+* A field element in the Rijndael finite field GF(2⁸) with a fixed generator g = 0x03.
+*/
+var GF256 = class GF256 {
+	constructor(value) {
+		if (value < 0 || value >= GF256_SIZE) throw new Error(`Invalid value ${value} for GF256`);
+		this.value = value;
+	}
+	log() {
+		if (this.value === 0) throw new Error("Invalid value");
+		return LOG[this.value - 1];
+	}
+	static exp(x) {
+		return new GF256(EXP[x % (GF256_SIZE - 1)]);
+	}
+	add(other) {
+		return new GF256(this.value ^ other.value);
+	}
+	sub(other) {
+		return this.add(other);
+	}
+	neg() {
+		return this;
+	}
+	mul(other) {
+		if (this.value === 0 || other.value === 0) return new GF256(0);
+		return GF256.exp(this.log() + other.log());
+	}
+	div(other) {
+		return this.mul(GF256.exp(GF256_SIZE - other.log() - 1));
+	}
+	equals(other) {
+		return this.value === other.value;
+	}
+	static zero() {
+		return new GF256(0);
+	}
+	static one() {
+		return new GF256(1);
+	}
+};
+const EXP = [
+	1,
+	3,
+	5,
+	15,
+	17,
+	51,
+	85,
+	255,
+	26,
+	46,
+	114,
+	150,
+	161,
+	248,
+	19,
+	53,
+	95,
+	225,
+	56,
+	72,
+	216,
+	115,
+	149,
+	164,
+	247,
+	2,
+	6,
+	10,
+	30,
+	34,
+	102,
+	170,
+	229,
+	52,
+	92,
+	228,
+	55,
+	89,
+	235,
+	38,
+	106,
+	190,
+	217,
+	112,
+	144,
+	171,
+	230,
+	49,
+	83,
+	245,
+	4,
+	12,
+	20,
+	60,
+	68,
+	204,
+	79,
+	209,
+	104,
+	184,
+	211,
+	110,
+	178,
+	205,
+	76,
+	212,
+	103,
+	169,
+	224,
+	59,
+	77,
+	215,
+	98,
+	166,
+	241,
+	8,
+	24,
+	40,
+	120,
+	136,
+	131,
+	158,
+	185,
+	208,
+	107,
+	189,
+	220,
+	127,
+	129,
+	152,
+	179,
+	206,
+	73,
+	219,
+	118,
+	154,
+	181,
+	196,
+	87,
+	249,
+	16,
+	48,
+	80,
+	240,
+	11,
+	29,
+	39,
+	105,
+	187,
+	214,
+	97,
+	163,
+	254,
+	25,
+	43,
+	125,
+	135,
+	146,
+	173,
+	236,
+	47,
+	113,
+	147,
+	174,
+	233,
+	32,
+	96,
+	160,
+	251,
+	22,
+	58,
+	78,
+	210,
+	109,
+	183,
+	194,
+	93,
+	231,
+	50,
+	86,
+	250,
+	21,
+	63,
+	65,
+	195,
+	94,
+	226,
+	61,
+	71,
+	201,
+	64,
+	192,
+	91,
+	237,
+	44,
+	116,
+	156,
+	191,
+	218,
+	117,
+	159,
+	186,
+	213,
+	100,
+	172,
+	239,
+	42,
+	126,
+	130,
+	157,
+	188,
+	223,
+	122,
+	142,
+	137,
+	128,
+	155,
+	182,
+	193,
+	88,
+	232,
+	35,
+	101,
+	175,
+	234,
+	37,
+	111,
+	177,
+	200,
+	67,
+	197,
+	84,
+	252,
+	31,
+	33,
+	99,
+	165,
+	244,
+	7,
+	9,
+	27,
+	45,
+	119,
+	153,
+	176,
+	203,
+	70,
+	202,
+	69,
+	207,
+	74,
+	222,
+	121,
+	139,
+	134,
+	145,
+	168,
+	227,
+	62,
+	66,
+	198,
+	81,
+	243,
+	14,
+	18,
+	54,
+	90,
+	238,
+	41,
+	123,
+	141,
+	140,
+	143,
+	138,
+	133,
+	148,
+	167,
+	242,
+	13,
+	23,
+	57,
+	75,
+	221,
+	124,
+	132,
+	151,
+	162,
+	253,
+	28,
+	36,
+	108,
+	180,
+	199,
+	82,
+	246
+];
+const LOG = [
+	0,
+	25,
+	1,
+	50,
+	2,
+	26,
+	198,
+	75,
+	199,
+	27,
+	104,
+	51,
+	238,
+	223,
+	3,
+	100,
+	4,
+	224,
+	14,
+	52,
+	141,
+	129,
+	239,
+	76,
+	113,
+	8,
+	200,
+	248,
+	105,
+	28,
+	193,
+	125,
+	194,
+	29,
+	181,
+	249,
+	185,
+	39,
+	106,
+	77,
+	228,
+	166,
+	114,
+	154,
+	201,
+	9,
+	120,
+	101,
+	47,
+	138,
+	5,
+	33,
+	15,
+	225,
+	36,
+	18,
+	240,
+	130,
+	69,
+	53,
+	147,
+	218,
+	142,
+	150,
+	143,
+	219,
+	189,
+	54,
+	208,
+	206,
+	148,
+	19,
+	92,
+	210,
+	241,
+	64,
+	70,
+	131,
+	56,
+	102,
+	221,
+	253,
+	48,
+	191,
+	6,
+	139,
+	98,
+	179,
+	37,
+	226,
+	152,
+	34,
+	136,
+	145,
+	16,
+	126,
+	110,
+	72,
+	195,
+	163,
+	182,
+	30,
+	66,
+	58,
+	107,
+	40,
+	84,
+	250,
+	133,
+	61,
+	186,
+	43,
+	121,
+	10,
+	21,
+	155,
+	159,
+	94,
+	202,
+	78,
+	212,
+	172,
+	229,
+	243,
+	115,
+	167,
+	87,
+	175,
+	88,
+	168,
+	80,
+	244,
+	234,
+	214,
+	116,
+	79,
+	174,
+	233,
+	213,
+	231,
+	230,
+	173,
+	232,
+	44,
+	215,
+	117,
+	122,
+	235,
+	22,
+	11,
+	245,
+	89,
+	203,
+	95,
+	176,
+	156,
+	169,
+	81,
+	160,
+	127,
+	12,
+	246,
+	111,
+	23,
+	196,
+	73,
+	236,
+	216,
+	67,
+	31,
+	45,
+	164,
+	118,
+	123,
+	183,
+	204,
+	187,
+	62,
+	90,
+	251,
+	96,
+	177,
+	134,
+	59,
+	82,
+	161,
+	108,
+	170,
+	85,
+	41,
+	157,
+	151,
+	178,
+	135,
+	144,
+	97,
+	190,
+	220,
+	252,
+	188,
+	149,
+	207,
+	205,
+	55,
+	63,
+	91,
+	209,
+	83,
+	57,
+	132,
+	60,
+	65,
+	162,
+	109,
+	71,
+	20,
+	42,
+	158,
+	93,
+	86,
+	242,
+	211,
+	171,
+	68,
+	17,
+	146,
+	217,
+	35,
+	32,
+	46,
+	137,
+	180,
+	124,
+	184,
+	38,
+	119,
+	153,
+	227,
+	165,
+	103,
+	74,
+	237,
+	222,
+	197,
+	49,
+	254,
+	24,
+	13,
+	99,
+	140,
+	128,
+	192,
+	247,
+	112,
+	7
+];
+/**
+* A polynomial over the field GF(2⁸).
+*/
+var Polynomial = class Polynomial {
+	/**
+	* Construct a new Polynomial over [GF256] from the given coefficients.
+	* The first coefficient is the constant term.
+	*/
+	constructor(coefficients) {
+		this.coefficients = coefficients.slice();
+		while (this.coefficients.length > 0 && this.coefficients[this.coefficients.length - 1].value === 0) this.coefficients.pop();
+	}
+	/**
+	* Construct a polynomial from the given bytes.
+	* Each byte is a coefficient of the polynomial starting from the constant term.
+	*/
+	static fromBytes(bytes) {
+		return new Polynomial(Array.from(bytes, (b) => new GF256(b)));
+	}
+	degree() {
+		if (this.coefficients.length === 0) return 0;
+		return this.coefficients.length - 1;
+	}
+	/** Get the coefficient of the polynomial at the given index. */
+	getCoefficient(index) {
+		if (index >= this.coefficients.length) return GF256.zero();
+		return this.coefficients[index];
+	}
+	/** Add two polynomials. */
+	add(other) {
+		const degree = Math.max(this.degree(), other.degree());
+		return new Polynomial(Array.from({ length: degree + 1 }, (_, i) => this.getCoefficient(i).add(other.getCoefficient(i))));
+	}
+	/** Multiply two polynomials. */
+	mul(other) {
+		const degree = this.degree() + other.degree();
+		return new Polynomial(Array.from({ length: degree + 1 }, (_, i) => {
+			let sum = GF256.zero();
+			for (let j = 0; j <= i; j++) if (j <= this.degree() && i - j <= other.degree()) sum = sum.add(this.getCoefficient(j).mul(other.getCoefficient(i - j)));
+			return sum;
+		}));
+	}
+	/** The polynomial s * this. */
+	scale(s) {
+		return new Polynomial(this.coefficients.map((c) => c.mul(s)));
+	}
+	/** The polynomial (1 / s) * this. */
+	div(s) {
+		return this.scale(new GF256(1).div(s));
+	}
+	/** The polynomial x + c. */
+	static monic_linear(c) {
+		return new Polynomial([c, GF256.one()]);
+	}
+	/** The zero polynomial. */
+	static zero() {
+		return new Polynomial([]);
+	}
+	/** The polynomial 1. */
+	static one() {
+		return new Polynomial([GF256.one()]);
+	}
+	/** Given a set of coordinates, interpolate a polynomial. */
+	static interpolate(coordinates) {
+		if (coordinates.length < 1) throw new Error("At least one coefficient is required");
+		if (hasDuplicates(coordinates.map(({ x }) => x.value))) throw new Error("Coefficients must have unique x values");
+		return coordinates.reduce((sum, { x: x_j, y: y_j }, j) => sum.add(coordinates.filter((_, i) => i !== j).reduce((product, { x: x_i }) => product.mul(Polynomial.monic_linear(x_i.neg()).div(x_j.sub(x_i))), Polynomial.one()).scale(y_j)), Polynomial.zero());
+	}
+	/** Given a set of coordinates, interpolate a polynomial and evaluate it at x = 0. */
+	static combine(coordinates) {
+		if (coordinates.length < 1) throw new Error("At least one coefficient is required");
+		if (hasDuplicates(coordinates.map(({ x }) => x.value))) throw new Error("Coefficients must have unique x values");
+		const quotient = coordinates.reduce((sum, { x: x_j, y: y_j }, j) => {
+			const denominator = x_j.mul(coordinates.filter((_, i) => i !== j).reduce((product, { x: x_i }) => product.mul(x_i.sub(x_j)), GF256.one()));
+			return sum.add(y_j.div(denominator));
+		}, GF256.zero());
+		return coordinates.reduce((product, { x }) => product.mul(x), GF256.one()).mul(quotient);
+	}
+	/** Evaluate the polynomial at x. */
+	evaluate(x) {
+		return this.coefficients.toReversed().reduce((sum, coefficient) => sum.mul(x).add(coefficient), GF256.zero());
+	}
+};
+function toInternalShare(share) {
+	return {
+		index: new GF256(share.index),
+		share: Array.from(share.share, (byte) => new GF256(byte))
+	};
+}
+function toShare(internalShare) {
+	return {
+		index: internalShare.index.value,
+		share: new Uint8Array(internalShare.share.map((byte) => byte.value))
+	};
+}
+/**
+* Sample a random polynomial with the given constant and degree.
+*
+* @param constant The constant term of the polynomial.
+* @param degree The degree of the polynomial.
+* @returns A random polynomial with the given constant and degree.
+*/
+function samplePolynomial(constant, degree) {
+	const randomCoefficients = new Uint8Array(degree);
+	crypto.getRandomValues(randomCoefficients);
+	return Polynomial.fromBytes(new Uint8Array([constant.value, ...randomCoefficients]));
+}
+/**
+* Split a secret into shares.
+*
+* @param secret The secret to split.
+* @param threshold The minimum number of shares required to reconstruct the secret.
+* @param total The total number of shares to generate.
+* @returns The shares.
+*/
+function split(secret, threshold, total) {
+	if (threshold > total || threshold < 1 || total >= GF256_SIZE) throw new Error(`Invalid threshold ${threshold} or total ${total}`);
+	const polynomials = Array.from(secret, (s) => samplePolynomial(new GF256(s), threshold - 1));
+	return Array.from({ length: total }, (_, i) => {
+		const index = new GF256(i + 1);
+		return toShare({
+			index,
+			share: polynomials.map((p) => p.evaluate(index))
+		});
+	});
+}
+/** Validate a set of shares and return them in internal shares representation along with the length of the shares. */
+function validateShares(shares) {
+	if (shares.length < 1) throw new Error("At least one share is required");
+	if (!allEqual(shares.map(({ share }) => share.length))) throw new Error("All shares must have the same length");
+	if (hasDuplicates(shares.map(({ index }) => index))) throw new Error("Shares must have unique indices");
+	const internalShares = shares.map(toInternalShare);
+	return {
+		internalShares,
+		length: internalShares[0].share.length
+	};
+}
+/**
+* Combine shares into a secret. If fewer than the threshold number of shares are provided,
+* the result will be indistinguishable from random.
+*
+* @param shares The shares to combine.
+* @returns The secret.
+*/
+function combine(shares) {
+	const { internalShares, length } = validateShares(shares);
+	return new Uint8Array(Array.from({ length }, (_, i) => Polynomial.combine(internalShares.map(({ index, share }) => ({
+		x: index,
+		y: share[i]
+	}))).value));
+}
+/**
+* Interpolate a polynomial from the given shares.
+*
+* @param shares The shares to interpolate from.
+* @returns A function that evaluates the polynomial at a given x.
+*/
+function interpolate(shares) {
+	const { internalShares, length } = validateShares(shares);
+	const polynomials = Array.from({ length }, (_, i) => Polynomial.interpolate(internalShares.map(({ index, share }) => ({
+		x: index,
+		y: share[i]
+	}))));
+	return (x) => {
+		return new Uint8Array(polynomials.map((p) => p.evaluate(new GF256(x)).value));
+	};
+}
+
+//#endregion
+export { combine, interpolate, split };
+//# sourceMappingURL=shamir.mjs.map