1372 lines
60 KiB
JavaScript
1372 lines
60 KiB
JavaScript
import { deepStrictEqual, notDeepStrictEqual, throws } from 'assert';
|
||
import * as fc from 'fast-check';
|
||
import { readFileSync } from 'fs';
|
||
import { describe, should } from 'micro-should';
|
||
import { wNAF } from '../abstract/curve.js';
|
||
import { bytesToHex, utf8ToBytes } from '../abstract/utils.js';
|
||
import { hash_to_field } from '../abstract/hash-to-curve.js';
|
||
import { bls12_381 as bls } from '../bls12-381.js';
|
||
|
||
import zkVectors from './bls12-381/zkcrypto/converted.json' assert { type: 'json' };
|
||
import pairingVectors from './bls12-381/go_pairing_vectors/pairing.json' assert { type: 'json' };
|
||
const G2_VECTORS = readFileSync('./test/bls12-381/bls12-381-g2-test-vectors.txt', 'utf-8')
|
||
.trim()
|
||
.split('\n')
|
||
.map((l) => l.split(':'));
|
||
// Vectors come from
|
||
// https://github.com/zkcrypto/bls12-381/blob/e501265cd36849a4981fe55e10dc87c38ee2213d/src/hash_to_curve/map_scalar.rs#L20
|
||
const SCALAR_VECTORS = readFileSync('./test/bls12-381/bls12-381-scalar-test-vectors.txt', 'utf-8')
|
||
.trim()
|
||
.split('\n')
|
||
.map((l) => l.split(':'));
|
||
|
||
// @ts-ignore
|
||
const NUM_RUNS = Number(process.env.RUNS_COUNT || 10); // reduce to 1 to shorten test time
|
||
fc.configureGlobal({ numRuns: NUM_RUNS });
|
||
|
||
const { Fp2 } = bls;
|
||
const G1Point = bls.G1.ProjectivePoint;
|
||
const G2Point = bls.G2.ProjectivePoint;
|
||
const G1Aff = (x, y) => G1Point.fromAffine({ x, y });
|
||
const CURVE_ORDER = bls.CURVE.r;
|
||
|
||
const FC_MSG = fc.hexaString({ minLength: 64, maxLength: 64 });
|
||
const FC_MSG_5 = fc.array(FC_MSG, { minLength: 5, maxLength: 5 });
|
||
const FC_BIGINT = fc.bigInt(1n, CURVE_ORDER - 1n);
|
||
const FC_BIGINT_5 = fc.array(FC_BIGINT, { minLength: 5, maxLength: 5 });
|
||
const B_192_40 = '40'.padEnd(192, '0');
|
||
const B_384_40 = '40'.padEnd(384, '0'); // [0x40, 0, 0...]
|
||
|
||
const getPubKey = (priv) => bls.getPublicKey(priv);
|
||
|
||
function equal(a, b, comment) {
|
||
deepStrictEqual(a.equals(b), true, `eq(${comment})`);
|
||
}
|
||
|
||
// Fp
|
||
describe('bls12-381 Fp', () => {
|
||
const Fp = bls.Fp;
|
||
const FC_BIGINT = fc.bigInt(1n, Fp.ORDER - 1n);
|
||
|
||
should('multiply/sqrt', () => {
|
||
let sqr1 = Fp.sqrt(Fp.create(300855555557n));
|
||
deepStrictEqual(
|
||
sqr1 && sqr1.toString(),
|
||
'364533921369419647282142659217537440628656909375169620464770009670699095647614890229414882377952296797827799113624'
|
||
);
|
||
throws(() => Fp.sqrt(Fp.create(72057594037927816n)));
|
||
});
|
||
});
|
||
|
||
// Fp2
|
||
describe('bls12-381 Fp2', () => {
|
||
const Fp = bls.Fp;
|
||
const Fp2 = bls.Fp2;
|
||
const FC_BIGINT = fc.bigInt(1n, Fp.ORDER - 1n);
|
||
const FC_BIGINT_2 = fc.array(FC_BIGINT, { minLength: 2, maxLength: 2 });
|
||
|
||
should('non-equality', () => {
|
||
fc.assert(
|
||
fc.property(FC_BIGINT_2, FC_BIGINT_2, (num1, num2) => {
|
||
const a = Fp2.fromBigTuple([num1[0], num1[1]]);
|
||
const b = Fp2.fromBigTuple([num2[0], num2[1]]);
|
||
deepStrictEqual(Fp2.eql(a, b), num1[0] === num2[0] && num1[1] === num2[1]);
|
||
deepStrictEqual(Fp2.eql(b, a), num1[0] === num2[0] && num1[1] === num2[1]);
|
||
})
|
||
);
|
||
});
|
||
|
||
should('div/x/1=x', () => {
|
||
fc.assert(
|
||
fc.property(FC_BIGINT_2, (num) => {
|
||
const a = Fp2.fromBigTuple([num[0], num[1]]);
|
||
deepStrictEqual(Fp2.div(a, Fp2.fromBigTuple([1n, 0n])), a);
|
||
deepStrictEqual(Fp2.div(a, Fp2.ONE), a);
|
||
deepStrictEqual(Fp2.div(a, a), Fp2.ONE);
|
||
})
|
||
);
|
||
});
|
||
|
||
should('frobenius', () => {
|
||
// expect(Fp2.FROBENIUS_COEFFICIENTS[0].equals(Fp.ONE)).toBe(true);
|
||
// expect(
|
||
// Fp2.FROBENIUS_COEFFICIENTS[1].equals(
|
||
// Fp.ONE.negate().pow(
|
||
// 0x0f81ae6945026025546c75a2a5240311d8ab75fac730cbcacd117de46c663f3fdebb76c445078281bf953ed363fa069bn
|
||
// )
|
||
// )
|
||
// ).toBe(true);
|
||
let a = Fp2.fromBigTuple([
|
||
0x00f8d295b2ded9dcccc649c4b9532bf3b966ce3bc2108b138b1a52e0a90f59ed11e59ea221a3b6d22d0078036923ffc7n,
|
||
0x012d1137b8a6a8374e464dea5bcfd41eb3f8afc0ee248cadbe203411c66fb3a5946ae52d684fa7ed977df6efcdaee0dbn,
|
||
]);
|
||
a = Fp2.frobeniusMap(a, 0);
|
||
deepStrictEqual(
|
||
Fp2.eql(
|
||
a,
|
||
Fp2.fromBigTuple([
|
||
0x00f8d295b2ded9dcccc649c4b9532bf3b966ce3bc2108b138b1a52e0a90f59ed11e59ea221a3b6d22d0078036923ffc7n,
|
||
0x012d1137b8a6a8374e464dea5bcfd41eb3f8afc0ee248cadbe203411c66fb3a5946ae52d684fa7ed977df6efcdaee0dbn,
|
||
])
|
||
),
|
||
true
|
||
);
|
||
a = Fp2.frobeniusMap(a, 1);
|
||
deepStrictEqual(
|
||
Fp2.eql(
|
||
a,
|
||
Fp2.fromBigTuple([
|
||
0x00f8d295b2ded9dcccc649c4b9532bf3b966ce3bc2108b138b1a52e0a90f59ed11e59ea221a3b6d22d0078036923ffc7n,
|
||
0x18d400b280d93e62fcd559cbe77bd8b8b07e9bc405608611a9109e8f3041427e8a411ad149045812228109103250c9d0n,
|
||
])
|
||
),
|
||
true
|
||
);
|
||
a = Fp2.frobeniusMap(a, 1);
|
||
deepStrictEqual(
|
||
Fp2.eql(
|
||
a,
|
||
Fp2.fromBigTuple([
|
||
0x00f8d295b2ded9dcccc649c4b9532bf3b966ce3bc2108b138b1a52e0a90f59ed11e59ea221a3b6d22d0078036923ffc7n,
|
||
0x012d1137b8a6a8374e464dea5bcfd41eb3f8afc0ee248cadbe203411c66fb3a5946ae52d684fa7ed977df6efcdaee0dbn,
|
||
])
|
||
),
|
||
true
|
||
);
|
||
a = Fp2.frobeniusMap(a, 2);
|
||
deepStrictEqual(
|
||
Fp2.eql(
|
||
a,
|
||
Fp2.fromBigTuple([
|
||
0x00f8d295b2ded9dcccc649c4b9532bf3b966ce3bc2108b138b1a52e0a90f59ed11e59ea221a3b6d22d0078036923ffc7n,
|
||
0x012d1137b8a6a8374e464dea5bcfd41eb3f8afc0ee248cadbe203411c66fb3a5946ae52d684fa7ed977df6efcdaee0dbn,
|
||
])
|
||
),
|
||
true
|
||
);
|
||
});
|
||
});
|
||
|
||
// Point
|
||
describe('bls12-381 Point', () => {
|
||
const Fp = bls.Fp;
|
||
const FC_BIGINT = fc.bigInt(1n, Fp.ORDER - 1n);
|
||
const PointG1 = G1Point;
|
||
const PointG2 = G2Point;
|
||
|
||
describe('with Fp coordinates', () => {
|
||
should('Point equality', () => {
|
||
fc.assert(
|
||
fc.property(
|
||
fc.array(FC_BIGINT, { minLength: 3, maxLength: 3 }),
|
||
fc.array(FC_BIGINT, { minLength: 3, maxLength: 3 }),
|
||
([x1, y1, z1], [x2, y2, z2]) => {
|
||
const p1 = new PointG1(Fp.create(x1), Fp.create(y1), Fp.create(z1));
|
||
const p2 = new PointG1(Fp.create(x2), Fp.create(y2), Fp.create(z2));
|
||
equal(p1, p1);
|
||
equal(p2, p2);
|
||
deepStrictEqual(p1.equals(p2), false);
|
||
deepStrictEqual(p2.equals(p1), false);
|
||
}
|
||
)
|
||
);
|
||
});
|
||
should('be placed on curve vector 1', () => {
|
||
const a = PointG1.fromAffine({ x: Fp.create(0n), y: Fp.create(0n) });
|
||
a.assertValidity();
|
||
});
|
||
should('not be placed on curve vector 1', () => {
|
||
const a = PointG1.fromAffine({ x: Fp.create(0n), y: Fp.create(1n) });
|
||
throws(() => a.assertValidity());
|
||
});
|
||
|
||
should('be placed on curve vector 2', () => {
|
||
const a = PointG1.fromAffine({
|
||
x: Fp.create(
|
||
0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bbn
|
||
),
|
||
y: Fp.create(
|
||
0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1n
|
||
),
|
||
});
|
||
a.assertValidity();
|
||
});
|
||
should('be placed on curve vector 3', () => {
|
||
const a = G1Aff(
|
||
Fp.create(
|
||
3971675556538908004130084773503021351583407620890695272226385332452194486153316625183061567093226342405194446632851n
|
||
),
|
||
Fp.create(
|
||
1120750640227410374130508113691552487207139112596221955734902008063040284119210871734388578113045163251615428544022n
|
||
)
|
||
);
|
||
|
||
a.assertValidity();
|
||
});
|
||
should('not be placed on curve vector 3', () => {
|
||
const a = G1Aff(
|
||
Fp.create(
|
||
622186380008502900120948444810967255157373993223369845903602988014033704418470621816206856882891545628885272576827n
|
||
),
|
||
Fp.create(
|
||
1031339409279989180383920781105371089925712739630078633497696569127911841893478548110664124341123041182605140418539n
|
||
)
|
||
);
|
||
throws(() => a.assertValidity());
|
||
});
|
||
should('not be placed on curve vector 2', () => {
|
||
const a = G1Aff(
|
||
Fp.create(
|
||
0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6ban
|
||
),
|
||
Fp.create(
|
||
0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1n
|
||
)
|
||
);
|
||
throws(() => a.assertValidity());
|
||
});
|
||
|
||
should('be doubled and placed on curve vector 1', () => {
|
||
const a = G1Aff(
|
||
Fp.create(
|
||
0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bbn
|
||
),
|
||
Fp.create(
|
||
0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1n
|
||
)
|
||
);
|
||
const double = a.double();
|
||
double.assertValidity();
|
||
equal(
|
||
double,
|
||
G1Aff(
|
||
Fp.create(
|
||
838589206289216005799424730305866328161735431124665289961769162861615689790485775997575391185127590486775437397838n
|
||
),
|
||
Fp.create(
|
||
3450209970729243429733164009999191867485184320918914219895632678707687208996709678363578245114137957452475385814312n
|
||
)
|
||
)
|
||
);
|
||
equal(double, a.multiply(2n));
|
||
equal(double, a.add(a));
|
||
});
|
||
should('be pdoubled and placed on curve vector 2', () => {
|
||
const a = G1Aff(
|
||
Fp.create(
|
||
3971675556538908004130084773503021351583407620890695272226385332452194486153316625183061567093226342405194446632851n
|
||
),
|
||
Fp.create(
|
||
1120750640227410374130508113691552487207139112596221955734902008063040284119210871734388578113045163251615428544022n
|
||
)
|
||
);
|
||
const double = a.double();
|
||
double.assertValidity();
|
||
equal(
|
||
double,
|
||
G1Aff(
|
||
Fp.create(
|
||
2820140907397376715097155275119328764341377106900140435029293933353987248389870417008333350832041425944924730501850n
|
||
),
|
||
Fp.create(
|
||
405067456352079478955518177787903714844851702189644746974501225918909272447622208969148740834643073317421487969112n
|
||
)
|
||
)
|
||
);
|
||
equal(double, a.multiply(2n));
|
||
equal(double, a.add(a));
|
||
});
|
||
should('not validate incorrect point', () => {
|
||
const x =
|
||
499001545268060011619089734015590154568173930614466321429631711131511181286230338880376679848890024401335766847607n;
|
||
const y =
|
||
3934582309586258715640230772291917282844636728991757779640464479794033391537662970190753981664259511166946374555673n;
|
||
|
||
const p = PointG1.fromAffine({ x: Fp.create(x), y: Fp.create(y) });
|
||
throws(() => p.assertValidity());
|
||
});
|
||
});
|
||
|
||
describe('with Fp2 coordinates', () => {
|
||
should('Point equality', () => {
|
||
fc.assert(
|
||
fc.property(
|
||
fc.array(fc.array(FC_BIGINT, { minLength: 2, maxLength: 2 }), {
|
||
minLength: 3,
|
||
maxLength: 3,
|
||
}),
|
||
fc.array(fc.array(FC_BIGINT, { minLength: 2, maxLength: 2 }), {
|
||
minLength: 3,
|
||
maxLength: 3,
|
||
}),
|
||
([x1, y1, z1], [x2, y2, z2]) => {
|
||
const p1 = new PointG2(
|
||
Fp2.fromBigTuple(x1),
|
||
Fp2.fromBigTuple(y1),
|
||
Fp2.fromBigTuple(z1)
|
||
);
|
||
const p2 = new PointG2(
|
||
Fp2.fromBigTuple(x2),
|
||
Fp2.fromBigTuple(y2),
|
||
Fp2.fromBigTuple(z2)
|
||
);
|
||
deepStrictEqual(p1.equals(p1), true);
|
||
deepStrictEqual(p2.equals(p2), true);
|
||
deepStrictEqual(p1.equals(p2), false);
|
||
deepStrictEqual(p2.equals(p1), false);
|
||
}
|
||
)
|
||
);
|
||
});
|
||
// should('be placed on curve vector 1', () => {
|
||
// const a = new PointG2(Fp2.fromBigTuple([0n, 0n]), Fp2.fromBigTuple([0n, 0n]));
|
||
// a.assertValidity();
|
||
// });
|
||
should('be placed on curve vector 2', () => {
|
||
const a = new PointG2(
|
||
Fp2.fromBigTuple([
|
||
0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8n,
|
||
0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7en,
|
||
]),
|
||
Fp2.fromBigTuple([
|
||
0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801n,
|
||
0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79ben,
|
||
]),
|
||
Fp2.fromBigTuple([1n, 0n])
|
||
);
|
||
a.assertValidity();
|
||
});
|
||
should('be placed on curve vector 3', () => {
|
||
const a = PointG2.fromAffine({
|
||
x: Fp2.fromBigTuple([
|
||
233289878585407360737561818812172281900488265436962145913969074168503452745466655442125797664134009339799716079103n,
|
||
1890785404699189181161569277356497622423785178845737858235714310995835974899880469355250933575450045792782146044819n,
|
||
]),
|
||
y: Fp2.fromBigTuple([
|
||
1215754321684097939278683023199690844646077558342794977283698289191570128272085945598449054373022460634252133664610n,
|
||
2751025411942897795042193940345989612527395984463172615380574492034129474560903255212585680112858672276592527763585n,
|
||
]),
|
||
});
|
||
a.assertValidity();
|
||
});
|
||
should('not be placed on curve vector 1', () => {
|
||
const a = new PointG2(
|
||
Fp2.fromBigTuple([0n, 0n]),
|
||
Fp2.fromBigTuple([1n, 0n]),
|
||
Fp2.fromBigTuple([1n, 0n])
|
||
);
|
||
throws(() => a.assertValidity());
|
||
});
|
||
should('not be placed on curve vector 2', () => {
|
||
const a = new PointG2(
|
||
Fp2.fromBigTuple([
|
||
0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4410b647ae3d1770bac0326a805bbefd48056c8c121bdb8n,
|
||
0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7en,
|
||
]),
|
||
Fp2.fromBigTuple([
|
||
0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d229a695160d12c923ac9cc3baca289e193548608b82801n,
|
||
0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79ben,
|
||
]),
|
||
Fp2.fromBigTuple([1n, 0n])
|
||
);
|
||
throws(() => a.assertValidity());
|
||
});
|
||
should('not be placed on curve vector 3', () => {
|
||
const a = new PointG2(
|
||
Fp2.fromBigTuple([
|
||
0x877d52dd65245f8908a03288adcd396f489ef87ae23fe110c5aa48bc208fbd1a0ed403df5b1ac137922b915f1f38ec37n,
|
||
0x0cf8158b9e689553d58194f79863fe02902c5f169f0d4ddf46e23f15bb4f24304a8e26f1e5febc57b750d1c3dc4261d8n,
|
||
]),
|
||
Fp2.fromBigTuple([
|
||
0x065ae9215806e8a55fd2d9ec4af9d2d448599cdb85d9080b2c9b4766434c33d103730c92c30a69d0602a8804c2a7c65fn,
|
||
0x0e9c342d8a6d4b3a1cbd02c7bdc0e0aa304de41a04569ae33184419e66bbc0271c361c973962955ba6405f0e51beb98bn,
|
||
]),
|
||
Fp2.fromBigTuple([
|
||
0x19cbaa4ee4fadc2319939b8db45c6a355bfb3755197ba74eda8534d2a2c1a2592475939877594513c326a90c11705002n,
|
||
0x0c0d89405d4e69986559a56057851733967c50fd0b4ec75e4ce92556ae5d33567e6e1a4eb9d83b4355520ebfe0bef37cn,
|
||
])
|
||
);
|
||
throws(() => a.assertValidity());
|
||
});
|
||
});
|
||
|
||
should('be doubled and placed on curve vector 1', () => {
|
||
const a = new PointG2(
|
||
Fp2.fromBigTuple([
|
||
0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8n,
|
||
0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7en,
|
||
]),
|
||
Fp2.fromBigTuple([
|
||
0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801n,
|
||
0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79ben,
|
||
]),
|
||
Fp2.fromBigTuple([1n, 0n])
|
||
);
|
||
const double = a.double();
|
||
double.assertValidity();
|
||
equal(
|
||
double,
|
||
PointG2.fromAffine({
|
||
x: Fp2.fromBigTuple([
|
||
3419974069068927546093595533691935972093267703063689549934039433172037728172434967174817854768758291501458544631891n,
|
||
1586560233067062236092888871453626466803933380746149805590083683748120990227823365075019078675272292060187343402359n,
|
||
]),
|
||
y: Fp2.fromBigTuple([
|
||
678774053046495337979740195232911687527971909891867263302465188023833943429943242788645503130663197220262587963545n,
|
||
2374407843478705782611042739236452317510200146460567463070514850492917978226342495167066333366894448569891658583283n,
|
||
]),
|
||
})
|
||
);
|
||
equal(double, a.multiply(2n));
|
||
equal(double, a.add(a));
|
||
});
|
||
should('be doubled and placed on curve vector 2', () => {
|
||
const a = PointG2.fromAffine({
|
||
x: Fp2.fromBigTuple([
|
||
233289878585407360737561818812172281900488265436962145913969074168503452745466655442125797664134009339799716079103n,
|
||
1890785404699189181161569277356497622423785178845737858235714310995835974899880469355250933575450045792782146044819n,
|
||
]),
|
||
y: Fp2.fromBigTuple([
|
||
1215754321684097939278683023199690844646077558342794977283698289191570128272085945598449054373022460634252133664610n,
|
||
2751025411942897795042193940345989612527395984463172615380574492034129474560903255212585680112858672276592527763585n,
|
||
]),
|
||
});
|
||
const double = a.double();
|
||
double.assertValidity();
|
||
equal(
|
||
double,
|
||
PointG2.fromAffine({
|
||
x: Fp2.fromBigTuple([
|
||
725284069620738622060750301926991261102335618423691881774095602348039360646278290301007111649920759181128494302803n,
|
||
919264895242212954093039181597172832206919609583188170141409360396089107784684267919047943917330182442049667967832n,
|
||
]),
|
||
y: Fp2.fromBigTuple([
|
||
671406920027112857569775418033910829294759327652470956866749681326509356602892160214948716653598897872184523683037n,
|
||
3055998868118150255613397668970777574660658983679486410738349400795670735303668556065367873243198246660959891663772n,
|
||
]),
|
||
})
|
||
);
|
||
equal(double, a.multiply(2n));
|
||
equal(double, a.add(a));
|
||
});
|
||
const wNAF_VECTORS = [
|
||
0x28b90deaf189015d3a325908c5e0e4bf00f84f7e639b056ff82d7e70b6eede4cn,
|
||
0x13eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n,
|
||
0x23eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n,
|
||
0x33eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n,
|
||
0x43eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n,
|
||
0x53eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n,
|
||
0x63eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000000n,
|
||
];
|
||
describe('wNAF multiplication same as unsafe', () => {
|
||
should('(G1, W=1)', () => {
|
||
let G = PointG1.BASE.negate().negate(); // create new point
|
||
G._setWindowSize(1);
|
||
for (let k of wNAF_VECTORS) {
|
||
deepStrictEqual(G.multiply(k).equals(G.multiplyUnsafe(k)), true);
|
||
}
|
||
});
|
||
should('(G1, W=4)', () => {
|
||
let G = PointG1.BASE.negate().negate();
|
||
G._setWindowSize(4);
|
||
for (let k of wNAF_VECTORS) {
|
||
deepStrictEqual(G.multiply(k).equals(G.multiplyUnsafe(k)), true);
|
||
}
|
||
});
|
||
should('(G1, W=5)', () => {
|
||
let G = PointG1.BASE.negate().negate();
|
||
G._setWindowSize(5);
|
||
for (let k of wNAF_VECTORS) {
|
||
deepStrictEqual(G.multiply(k).equals(G.multiplyUnsafe(k)), true);
|
||
}
|
||
});
|
||
should('(G2, W=1)', () => {
|
||
let G = PointG2.BASE.negate().negate();
|
||
G._setWindowSize(1);
|
||
for (let k of wNAF_VECTORS) {
|
||
deepStrictEqual(G.multiply(k).equals(G.multiplyUnsafe(k)), true);
|
||
}
|
||
});
|
||
should('(G2, W=4)', () => {
|
||
let G = PointG2.BASE.negate().negate();
|
||
G._setWindowSize(4);
|
||
for (let k of wNAF_VECTORS) {
|
||
deepStrictEqual(G.multiply(k).equals(G.multiplyUnsafe(k)), true);
|
||
}
|
||
});
|
||
should('(G2, W=5)', () => {
|
||
let G = PointG2.BASE.negate().negate();
|
||
G._setWindowSize(5);
|
||
for (let k of wNAF_VECTORS) {
|
||
deepStrictEqual(G.multiply(k).equals(G.multiplyUnsafe(k)), true);
|
||
}
|
||
});
|
||
});
|
||
should('PSI cofactor cleaning same as multiplication', () => {
|
||
const points = [
|
||
PointG2.fromAffine({
|
||
x: Fp2.fromBigTuple([
|
||
3241532514922300496112840946857937535679746598786089852337901560508502000671236210655544891931896207857529462155216n,
|
||
1895396002326546958606807865184627576810563909325590769826854838265038910148901969770093629785689196200738594051207n,
|
||
]),
|
||
y: Fp2.fromBigTuple([
|
||
3837310786345067009730271578787473898123345117675361644389016087559904243233782782806882170766697501716660726009081n,
|
||
1677898256818258755710370015632820289344925154952470675147754839082216730170149764842062980567113751550792217387778n,
|
||
]),
|
||
}),
|
||
PointG2.fromAffine({
|
||
x: Fp2.fromBigTuple([
|
||
3953605227375649587553282126565793338489478933421008011676219910137022551750442290689597974472294891051907650111197n,
|
||
2357556650209231585002654467241659159063900268360871707630297623496109598089657193704186795702074478622917895656384n,
|
||
]),
|
||
y: Fp2.fromBigTuple([
|
||
2495601009524620857707705364800595215702994859258454180584354350679476916692161325761009870302795857111988758374874n,
|
||
2636356076845621042340998927146453389877292467744110912831694031602037452225656755036030562878672313329396684758868n,
|
||
]),
|
||
}),
|
||
PointG2.fromAffine({
|
||
x: Fp2.fromBigTuple([
|
||
3194353741003351193683364524319044762011830478765020903432624057794333426495229091698895944358182869251271971124925n,
|
||
3653808358303084112668893108836368862445971143336505524596401519323087809653188999580874561318367165116767192535630n,
|
||
]),
|
||
y: Fp2.fromBigTuple([
|
||
1293147983982604948417085455043456439133874729834486879326988078136905862300347946661594156148773025247657033069058n,
|
||
304385694250536139727810974742746004825746444239830780412067821920180289379490776439208435270467062610041367314353n,
|
||
]),
|
||
}),
|
||
PointG2.fromAffine({
|
||
x: Fp2.fromBigTuple([
|
||
3913848356631365121633829648186849525632038637523196801515536004438620269011326037518995697522336713513734205291154n,
|
||
2892036022910655232784554063257167431129586441456677365843329976181438736451469367386635015809932785607079312857252n,
|
||
]),
|
||
y: Fp2.fromBigTuple([
|
||
2946839687749075245408468852956330519059225766361204396943480879518352257697157665323514637184706466306723801095265n,
|
||
1858741481287683941330484703798096212920693492850150667744795312336588840954530505769251621475693006537257913664280n,
|
||
]),
|
||
}),
|
||
PointG2.fromAffine({
|
||
x: Fp2.fromBigTuple([
|
||
3241532514922300496112840946857937535679746598786089852337901560508502000671236210655544891931896207857529462155216n,
|
||
1895396002326546958606807865184627576810563909325590769826854838265038910148901969770093629785689196200738594051207n,
|
||
]),
|
||
y: Fp2.fromBigTuple([
|
||
3837310786345067009730271578787473898123345117675361644389016087559904243233782782806882170766697501716660726009081n,
|
||
1677898256818258755710370015632820289344925154952470675147754839082216730170149764842062980567113751550792217387778n,
|
||
]),
|
||
}),
|
||
];
|
||
// Use wNAF allow scalars higher than CURVE.r
|
||
const w = wNAF(G2Point, 1);
|
||
for (let p of points) {
|
||
const ours = p.clearCofactor();
|
||
const shouldBe = w.unsafeLadder(p, bls.CURVE.G2.hEff);
|
||
deepStrictEqual(ours.equals(shouldBe), true, 'clearLast');
|
||
}
|
||
});
|
||
});
|
||
|
||
// index.ts
|
||
|
||
// bls.G1.ProjectivePoint.BASE.clearMultiplyPrecomputes();
|
||
// bls.G1.ProjectivePoint.BASE.calcMultiplyPrecomputes(4);
|
||
|
||
describe('bls12-381/basic', () => {
|
||
should('construct point G1 from its uncompressed form (Raw Bytes)', () => {
|
||
// Test Zero
|
||
const g1 = G1Point.fromHex(B_192_40);
|
||
deepStrictEqual(g1.x, G1Point.ZERO.x);
|
||
deepStrictEqual(g1.y, G1Point.ZERO.y);
|
||
// Test Non-Zero
|
||
const x = bls.Fp.create(
|
||
BigInt(
|
||
'0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb'
|
||
)
|
||
);
|
||
const y = bls.Fp.create(
|
||
BigInt(
|
||
'0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'
|
||
)
|
||
);
|
||
|
||
const g1_ = G1Point.fromHex(
|
||
'17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'
|
||
);
|
||
|
||
deepStrictEqual(g1_.x, x);
|
||
deepStrictEqual(g1_.y, y);
|
||
});
|
||
|
||
should('construct point G1 from its uncompressed form (Hex)', () => {
|
||
// Test Zero
|
||
const g1 = G1Point.fromHex(B_192_40);
|
||
|
||
deepStrictEqual(g1.x, G1Point.ZERO.x);
|
||
deepStrictEqual(g1.y, G1Point.ZERO.y);
|
||
// Test Non-Zero
|
||
const x = bls.Fp.create(
|
||
BigInt(
|
||
'0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb'
|
||
)
|
||
);
|
||
const y = bls.Fp.create(
|
||
BigInt(
|
||
'0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'
|
||
)
|
||
);
|
||
|
||
const g1_ = G1Point.fromHex(
|
||
'17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'
|
||
);
|
||
|
||
deepStrictEqual(g1_.x, x);
|
||
deepStrictEqual(g1_.y, y);
|
||
});
|
||
|
||
should('construct point G2 from its uncompressed form (Raw Bytes)', () => {
|
||
// Test Zero
|
||
const g2 = G2Point.fromHex(B_384_40);
|
||
deepStrictEqual(g2.x, G2Point.ZERO.x, 'zero(x)');
|
||
deepStrictEqual(g2.y, G2Point.ZERO.y, 'zero(y)');
|
||
// Test Non-Zero
|
||
const x = Fp2.fromBigTuple([
|
||
BigInt(
|
||
'0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8'
|
||
),
|
||
BigInt(
|
||
'0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e'
|
||
),
|
||
]);
|
||
const y = Fp2.fromBigTuple([
|
||
BigInt(
|
||
'0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'
|
||
),
|
||
BigInt(
|
||
'0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be'
|
||
),
|
||
]);
|
||
|
||
const g2_ = G2Point.fromHex(
|
||
'13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb80606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'
|
||
);
|
||
|
||
deepStrictEqual(g2_.x, x);
|
||
deepStrictEqual(g2_.y, y);
|
||
});
|
||
|
||
should('construct point G2 from its uncompressed form (Hex)', () => {
|
||
// Test Zero
|
||
const g2 = G2Point.fromHex(B_384_40);
|
||
|
||
deepStrictEqual(g2.x, G2Point.ZERO.x);
|
||
deepStrictEqual(g2.y, G2Point.ZERO.y);
|
||
// Test Non-Zero
|
||
const x = Fp2.fromBigTuple([
|
||
BigInt(
|
||
'0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8'
|
||
),
|
||
BigInt(
|
||
'0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e'
|
||
),
|
||
]);
|
||
const y = Fp2.fromBigTuple([
|
||
BigInt(
|
||
'0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'
|
||
),
|
||
BigInt(
|
||
'0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be'
|
||
),
|
||
]);
|
||
|
||
const g2_ = G2Point.fromHex(
|
||
'13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb80606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'
|
||
);
|
||
|
||
deepStrictEqual(g2_.x, x);
|
||
deepStrictEqual(g2_.y, y);
|
||
});
|
||
|
||
should('get uncompressed form of point G1 (Raw Bytes)', () => {
|
||
// Test Zero
|
||
deepStrictEqual(G1Point.ZERO.toHex(false), B_192_40);
|
||
// Test Non-Zero
|
||
const x = bls.Fp.create(
|
||
BigInt(
|
||
'0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb'
|
||
)
|
||
);
|
||
const y = bls.Fp.create(
|
||
BigInt(
|
||
'0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'
|
||
)
|
||
);
|
||
const g1 = G1Point.fromAffine({ x, y });
|
||
deepStrictEqual(
|
||
g1.toHex(false),
|
||
'17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'
|
||
);
|
||
});
|
||
|
||
should('get uncompressed form of point G1 (Hex)', () => {
|
||
// Test Zero
|
||
deepStrictEqual(G1Point.ZERO.toHex(false), B_192_40);
|
||
// Test Non-Zero
|
||
const x = bls.Fp.create(
|
||
BigInt(
|
||
'0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb'
|
||
)
|
||
);
|
||
const y = bls.Fp.create(
|
||
BigInt(
|
||
'0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'
|
||
)
|
||
);
|
||
const g1 = G1Point.fromAffine({ x, y });
|
||
deepStrictEqual(
|
||
g1.toHex(false),
|
||
'17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'
|
||
);
|
||
});
|
||
|
||
should('get uncompressed form of point G2 (Raw Bytes)', () => {
|
||
// Test Zero
|
||
deepStrictEqual(G2Point.ZERO.toHex(false), B_384_40);
|
||
// Test Non-Zero
|
||
const x = Fp2.fromBigTuple([
|
||
BigInt(
|
||
'0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8'
|
||
),
|
||
BigInt(
|
||
'0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e'
|
||
),
|
||
]);
|
||
const y = Fp2.fromBigTuple([
|
||
BigInt(
|
||
'0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'
|
||
),
|
||
BigInt(
|
||
'0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be'
|
||
),
|
||
]);
|
||
const g2 = G2Point.fromAffine({ x, y });
|
||
deepStrictEqual(
|
||
g2.toHex(false),
|
||
'13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb80606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'
|
||
);
|
||
});
|
||
|
||
should('get uncompressed form of point G2 (Hex)', () => {
|
||
// Test Zero
|
||
deepStrictEqual(G2Point.ZERO.toHex(false), B_384_40);
|
||
|
||
// Test Non-Zero
|
||
const x = Fp2.fromBigTuple([
|
||
BigInt(
|
||
'0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8'
|
||
),
|
||
BigInt(
|
||
'0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e'
|
||
),
|
||
]);
|
||
const y = Fp2.fromBigTuple([
|
||
BigInt(
|
||
'0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'
|
||
),
|
||
BigInt(
|
||
'0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be'
|
||
),
|
||
]);
|
||
const g2 = G2Point.fromAffine({ x, y });
|
||
deepStrictEqual(
|
||
g2.toHex(false),
|
||
'13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb80606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'
|
||
);
|
||
});
|
||
|
||
should('compress and decompress G1 points', () => {
|
||
const priv = G1Point.fromPrivateKey(42n);
|
||
const publicKey = priv.toHex(true);
|
||
const decomp = G1Point.fromHex(publicKey);
|
||
deepStrictEqual(publicKey, decomp.toHex(true));
|
||
});
|
||
should('not compress and decompress zero G1 point', () => {
|
||
throws(() => G1Point.fromPrivateKey(0n));
|
||
});
|
||
should('compress and decompress G2 points', () => {
|
||
const priv = G2Point.fromPrivateKey(42n);
|
||
const publicKey = priv.toHex(true);
|
||
const decomp = G2Point.fromHex(publicKey);
|
||
deepStrictEqual(publicKey, decomp.toHex(true));
|
||
});
|
||
should('not compress and decompress zero G2 point', () => {
|
||
throws(() => G2Point.fromPrivateKey(0n));
|
||
});
|
||
const VALID_G1 = new G1Point(
|
||
bls.Fp.create(
|
||
3609742242174788176010452839163620388872641749536604986743596621604118973777515189035770461528205168143692110933639n
|
||
),
|
||
bls.Fp.create(
|
||
1619277690257184054444116778047375363103842303863153349133480657158810226683757397206929105479676799650932070320089n
|
||
),
|
||
bls.Fp.create(1n)
|
||
);
|
||
const VALID_G1_2 = new G1Point(
|
||
bls.Fp.create(
|
||
1206972466279728255044019580914616126536509750250979180256809997983196363639429409634110400978470384566664128085207n
|
||
),
|
||
bls.Fp.create(
|
||
2991142246317096160788653339959532007292638191110818490939476869616372888657136539642598243964263069435065725313423n
|
||
),
|
||
bls.Fp.create(1n)
|
||
);
|
||
|
||
const INVALID_G1 = new G1Point(
|
||
bls.Fp.create(
|
||
499001545268060011619089734015590154568173930614466321429631711131511181286230338880376679848890024401335766847607n
|
||
),
|
||
bls.Fp.create(
|
||
3934582309586258715640230772291917282844636728991757779640464479794033391537662970190753981664259511166946374555673n
|
||
),
|
||
bls.Fp.create(1n)
|
||
);
|
||
|
||
should('aggregate pubkeys', () => {
|
||
const agg = bls.aggregatePublicKeys([VALID_G1, VALID_G1_2]).toAffine();
|
||
deepStrictEqual(
|
||
agg.x,
|
||
2636337749883017793009944726560363863546595464242083394883491066895536780554574413337005575305023872925406746684807n
|
||
);
|
||
deepStrictEqual(
|
||
agg.y,
|
||
2200256264293372104833346444532839112556752874984721583125881868863625579979779052307146195064914375388929781136724n
|
||
);
|
||
});
|
||
|
||
should('not aggregate invalid pubkeys', () => {
|
||
throws(() => bls.aggregatePublicKeys([VALID_G1, INVALID_G1]));
|
||
});
|
||
// should aggregate signatures
|
||
|
||
should(`produce correct signatures (${G2_VECTORS.length} vectors)`, () => {
|
||
for (let vector of G2_VECTORS) {
|
||
const [priv, msg, expected] = vector;
|
||
const sig = bls.sign(msg, priv);
|
||
deepStrictEqual(bytesToHex(sig), expected);
|
||
}
|
||
});
|
||
should(`produce correct scalars (${SCALAR_VECTORS.length} vectors)`, () => {
|
||
const options = {
|
||
p: bls.CURVE.r,
|
||
m: 1,
|
||
expand: undefined,
|
||
};
|
||
for (let vector of SCALAR_VECTORS) {
|
||
const [okmAscii, expectedHex] = vector;
|
||
const expected = BigInt('0x' + expectedHex);
|
||
const okm = utf8ToBytes(okmAscii);
|
||
const scalars = hash_to_field(okm, 1, Object.assign({}, bls.CURVE.htfDefaults, options));
|
||
deepStrictEqual(scalars[0][0], expected);
|
||
}
|
||
});
|
||
});
|
||
|
||
// Pairing
|
||
describe('pairing', () => {
|
||
const { pairing, Fp12 } = bls;
|
||
const G1 = G1Point.BASE;
|
||
const G2 = G2Point.BASE;
|
||
|
||
should('creates negative G1 pairing', () => {
|
||
const p1 = pairing(G1, G2);
|
||
const p2 = pairing(G1.negate(), G2);
|
||
deepStrictEqual(Fp12.mul(p1, p2), Fp12.ONE);
|
||
});
|
||
should('creates negative G2 pairing', () => {
|
||
const p2 = pairing(G1.negate(), G2);
|
||
const p3 = pairing(G1, G2.negate());
|
||
deepStrictEqual(p2, p3);
|
||
});
|
||
should('creates proper pairing output order', () => {
|
||
const p1 = pairing(G1, G2);
|
||
const p2 = Fp12.pow(p1, CURVE_ORDER);
|
||
deepStrictEqual(p2, Fp12.ONE);
|
||
});
|
||
should('G1 billinearity', () => {
|
||
const p1 = pairing(G1, G2);
|
||
const p2 = pairing(G1.multiply(2n), G2);
|
||
deepStrictEqual(Fp12.mul(p1, p1), p2);
|
||
});
|
||
should('should not degenerate', () => {
|
||
const p1 = pairing(G1, G2);
|
||
const p2 = pairing(G1.multiply(2n), G2);
|
||
const p3 = pairing(G1, G2.negate());
|
||
notDeepStrictEqual(p1, p2);
|
||
notDeepStrictEqual(p1, p3);
|
||
notDeepStrictEqual(p2, p3);
|
||
});
|
||
should('G2 billinearity', () => {
|
||
const p1 = pairing(G1, G2);
|
||
const p2 = pairing(G1, G2.multiply(2n));
|
||
deepStrictEqual(Fp12.mul(p1, p1), p2);
|
||
});
|
||
should('proper pairing composite check', () => {
|
||
const p1 = pairing(G1.multiply(37n), G2.multiply(27n));
|
||
const p2 = pairing(G1.multiply(999n), G2);
|
||
deepStrictEqual(p1, p2);
|
||
});
|
||
should('vectors from https://github.com/zkcrypto/pairing', () => {
|
||
const p1 = pairing(G1, G2);
|
||
deepStrictEqual(
|
||
p1,
|
||
Fp12.fromBigTwelve([
|
||
0x1250ebd871fc0a92a7b2d83168d0d727272d441befa15c503dd8e90ce98db3e7b6d194f60839c508a84305aaca1789b6n,
|
||
0x089a1c5b46e5110b86750ec6a532348868a84045483c92b7af5af689452eafabf1a8943e50439f1d59882a98eaa0170fn,
|
||
0x1368bb445c7c2d209703f239689ce34c0378a68e72a6b3b216da0e22a5031b54ddff57309396b38c881c4c849ec23e87n,
|
||
0x193502b86edb8857c273fa075a50512937e0794e1e65a7617c90d8bd66065b1fffe51d7a579973b1315021ec3c19934fn,
|
||
0x01b2f522473d171391125ba84dc4007cfbf2f8da752f7c74185203fcca589ac719c34dffbbaad8431dad1c1fb597aaa5n,
|
||
0x018107154f25a764bd3c79937a45b84546da634b8f6be14a8061e55cceba478b23f7dacaa35c8ca78beae9624045b4b6n,
|
||
0x19f26337d205fb469cd6bd15c3d5a04dc88784fbb3d0b2dbdea54d43b2b73f2cbb12d58386a8703e0f948226e47ee89dn,
|
||
0x06fba23eb7c5af0d9f80940ca771b6ffd5857baaf222eb95a7d2809d61bfe02e1bfd1b68ff02f0b8102ae1c2d5d5ab1an,
|
||
0x11b8b424cd48bf38fcef68083b0b0ec5c81a93b330ee1a677d0d15ff7b984e8978ef48881e32fac91b93b47333e2ba57n,
|
||
0x03350f55a7aefcd3c31b4fcb6ce5771cc6a0e9786ab5973320c806ad360829107ba810c5a09ffdd9be2291a0c25a99a2n,
|
||
0x04c581234d086a9902249b64728ffd21a189e87935a954051c7cdba7b3872629a4fafc05066245cb9108f0242d0fe3efn,
|
||
0x0f41e58663bf08cf068672cbd01a7ec73baca4d72ca93544deff686bfd6df543d48eaa24afe47e1efde449383b676631n,
|
||
])
|
||
);
|
||
});
|
||
should('finalExponentiate is correct', () => {
|
||
const p1 = Fp12.fromBigTwelve([
|
||
690392658038414015999440694435086329841032295415825549843130960252222448232974816207293269712691075396080336239827n,
|
||
1673244384695948045466836192250093912021245353707563547917201356526057153141766171738038843400145227470982267854187n,
|
||
2521701268183363687370344286906817113258663667920912959304741393298699171323721428784215127759799558353547063603791n,
|
||
3390741958986800271255412688995304356725465880212612704138250878957654428361390902500149993094444529404319700338173n,
|
||
2937610222696584007500949263676832694169290902527467459057239718838706247113927802450975619528632522479509319939064n,
|
||
1041774303946777132837448067285334026888352159489566377408630813368450973018459091749907377030858960140758778772908n,
|
||
3864799331679524425952286895114884847547051478975342624231897335512502423735668201254948484826445296416036052803892n,
|
||
3824221261758382083252395717303526902028176893529557070611185581959805652254106523709848773658607700988378551642979n,
|
||
3323164764111867304984970151558732202678135525250230081908783488276670159769559857016787572497867551292231024927968n,
|
||
1011304421692205285006791165988839444878224012950060115964565336021949568250312574884591704110914940911299353851697n,
|
||
2263326825947267463771741379953930448565128050766360539694662323032637428903113943692772437175107441778689006777591n,
|
||
2975309739982292949472410540684863862532494446476557866806093059134361887381947558323102825622690771432446161524562n,
|
||
]);
|
||
deepStrictEqual(
|
||
Fp12.finalExponentiate(p1),
|
||
Fp12.fromBigTwelve([
|
||
0x09d72c189ba2fd4b09b63da857f321b791b45f8ec589858bc6d41c8f4eb05244ad7a22aea1119a958d890a19f6cacedan,
|
||
0x153f579b44547ee81c5d1603571b4776a065e86b4e3da0bba32afedafcca10f0a40005e63c9408785761da689b4b7338n,
|
||
0x00bb1efcca23009c3638ae9ec0ee5153fa94b4edca88c3438029bcd5909e838da44483f0bfb5877609dace3bfa7d4ff3n,
|
||
0x0c0e22bf2d593bc5b7ce484f3ff81a23a0c36725909225c1cf2f277482144951ea3fe425d2a56a91b681e11abc56c7fan,
|
||
0x12c99e5152ab314ca6baec31cddbeff18acdac3a91c0e62de63e029bee76d775e0940408447b0fddad84b8dde9b86deen,
|
||
0x0fe6a726b7d4947bb7bcb22a06dd4a283ce7113e956bcbb0294883046944312a72536fff08166adcfa08dfd65e4c157fn,
|
||
0x176bfe03f017f18f7a2af0f178b5f018434ef3623da77e40d7fc78fca08299f81f6879c69026f4a7ba639463893e0708n,
|
||
0x0282d90ee23efd9a2e0d51af8a2048bbda4517a90a24318a75d0dd6addc29b068d17e7c89a04da84b142996aa29b1516n,
|
||
0x0c2cdf5de0889c4b55752cf839e61a81feaebf97a812c7581c8f66395868b582cbea067c9d435dabb5722913da709bffn,
|
||
0x0741ece37d164288d7a590b3d31d9e6f26ce0797f1b99a77cd0b5eba24eae26afcb8b69f39af06e701ceaabf94c3db5en,
|
||
0x00c9dea49cc3e1c8be938f707bbb0239e8f960fa46617877f90b3212fc3f5890999082b9c2262c8543a278136f34b5dbn,
|
||
0x08f574e635870b8f4ad8c18d162055ab6136db296ad5f25151244e3b1ce0d81389b9d1752a46af018e8fb1ac01b683e1n,
|
||
])
|
||
);
|
||
});
|
||
});
|
||
// hashToCurve
|
||
describe('hash-to-curve', () => {
|
||
// Point G1
|
||
const VECTORS_G1 = [
|
||
{
|
||
msg: utf8ToBytes(''),
|
||
expected:
|
||
'0576730ab036cbac1d95b38dca905586f28d0a59048db4e8778782d89bff856ddef89277ead5a21e2975c4a6e3d8c79e' +
|
||
'1273e568bebf1864393c517f999b87c1eaa1b8432f95aea8160cd981b5b05d8cd4a7cf00103b6ef87f728e4b547dd7ae',
|
||
},
|
||
{
|
||
msg: utf8ToBytes('abc'),
|
||
expected:
|
||
'061daf0cc00d8912dac1d4cf5a7c32fca97f8b3bf3f805121888e5eb89f77f9a9f406569027ac6d0e61b1229f42c43d6' +
|
||
'0de1601e5ba02cb637c1d35266f5700acee9850796dc88e860d022d7b9e7e3dce5950952e97861e5bb16d215c87f030d',
|
||
},
|
||
{
|
||
msg: utf8ToBytes('abcdef0123456789'),
|
||
expected:
|
||
'0fb3455436843e76079c7cf3dfef75e5a104dfe257a29a850c145568d500ad31ccfe79be9ae0ea31a722548070cf98cd' +
|
||
'177989f7e2c751658df1b26943ee829d3ebcf131d8f805571712f3a7527ee5334ecff8a97fc2a50cea86f5e6212e9a57',
|
||
},
|
||
{
|
||
msg: utf8ToBytes(
|
||
'a512_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
|
||
),
|
||
expected:
|
||
'0514af2137c1ae1d78d5cb97ee606ea142824c199f0f25ac463a0c78200de57640d34686521d3e9cf6b3721834f8a038' +
|
||
'047a85d6898416a0899e26219bca7c4f0fa682717199de196b02b95eaf9fb55456ac3b810e78571a1b7f5692b7c58ab6',
|
||
},
|
||
];
|
||
for (let i = 0; i < VECTORS_G1.length; i++) {
|
||
const t = VECTORS_G1[i];
|
||
should(`hashToCurve/G1 Killic (${i})`, () => {
|
||
const p = bls.G1.hashToCurve(t.msg, {
|
||
DST: 'BLS12381G1_XMD:SHA-256_SSWU_RO_TESTGEN',
|
||
});
|
||
deepStrictEqual(p.toHex(false), t.expected);
|
||
});
|
||
}
|
||
|
||
const VECTORS_ENCODE_G1 = [
|
||
{
|
||
msg: utf8ToBytes(''),
|
||
expected:
|
||
'1223effdbb2d38152495a864d78eee14cb0992d89a241707abb03819a91a6d2fd65854ab9a69e9aacb0cbebfd490732c' +
|
||
'0f925d61e0b235ecd945cbf0309291878df0d06e5d80d6b84aa4ff3e00633b26f9a7cb3523ef737d90e6d71e8b98b2d5',
|
||
},
|
||
{
|
||
msg: utf8ToBytes('abc'),
|
||
expected:
|
||
'179d3fd0b4fb1da43aad06cea1fb3f828806ddb1b1fa9424b1e3944dfdbab6e763c42636404017da03099af0dcca0fd6' +
|
||
'0d037cb1c6d495c0f5f22b061d23f1be3d7fe64d3c6820cfcd99b6b36fa69f7b4c1f4addba2ae7aa46fb25901ab483e4',
|
||
},
|
||
{
|
||
msg: utf8ToBytes('abcdef0123456789'),
|
||
expected:
|
||
'15aa66c77eded1209db694e8b1ba49daf8b686733afaa7b68c683d0b01788dfb0617a2e2d04c0856db4981921d3004af' +
|
||
'0952bb2f61739dd1d201dd0a79d74cda3285403d47655ee886afe860593a8a4e51c5b77a22d2133e3a4280eaaaa8b788',
|
||
},
|
||
{
|
||
msg: utf8ToBytes(
|
||
'a512_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
|
||
),
|
||
expected:
|
||
'06328ce5106e837935e8da84bd9af473422e62492930aa5f460369baad9545defa468d9399854c23a75495d2a80487ee' +
|
||
'094bfdfe3e552447433b5a00967498a3f1314b86ce7a7164c8a8f4131f99333b30a574607e301d5f774172c627fd0bca',
|
||
},
|
||
];
|
||
for (let i = 0; i < VECTORS_ENCODE_G1.length; i++) {
|
||
const t = VECTORS_ENCODE_G1[i];
|
||
should(`hashToCurve/G1 (Killic, encodeToCurve) (${i})`, () => {
|
||
const p = bls.G1.encodeToCurve(t.msg, {
|
||
DST: 'BLS12381G1_XMD:SHA-256_SSWU_NU_TESTGEN',
|
||
});
|
||
deepStrictEqual(p.toHex(false), t.expected);
|
||
});
|
||
}
|
||
// Point G2
|
||
const VECTORS_G2 = [
|
||
{
|
||
msg: utf8ToBytes(''),
|
||
expected:
|
||
'0fbdae26f9f9586a46d4b0b70390d09064ef2afe5c99348438a3c7d9756471e015cb534204c1b6824617a85024c772dc' +
|
||
'0a650bd36ae7455cb3fe5d8bb1310594551456f5c6593aec9ee0c03d2f6cb693bd2c5e99d4e23cbaec767609314f51d3' +
|
||
'02e5cf8f9b7348428cc9e66b9a9b36fe45ba0b0a146290c3a68d92895b1af0e1f2d9f889fb412670ae8478d8abd4c5aa' +
|
||
'0d8d49e7737d8f9fc5cef7c4b8817633103faf2613016cb86a1f3fc29968fe2413e232d9208d2d74a89bf7a48ac36f83',
|
||
},
|
||
{
|
||
msg: utf8ToBytes('abc'),
|
||
expected:
|
||
'03578447618463deb106b60e609c6f7cc446dc6035f84a72801ba17c94cd800583b493b948eff0033f09086fdd7f6175' +
|
||
'1953ce6d4267939c7360756d9cca8eb34aac4633ef35369a7dc249445069888e7d1b3f9d2e75fbd468fbcbba7110ea02' +
|
||
'0184d26779ae9d4670aca9b267dbd4d3b30443ad05b8546d36a195686e1ccc3a59194aea05ed5bce7c3144a29ec047c4' +
|
||
'0882ab045b8fe4d7d557ebb59a63a35ac9f3d312581b509af0f8eaa2960cbc5e1e36bb969b6e22980b5cbdd0787fcf4e',
|
||
},
|
||
{
|
||
msg: utf8ToBytes('abcdef0123456789'),
|
||
expected:
|
||
'195fad48982e186ce3c5c82133aefc9b26d55979b6f530992a8849d4263ec5d57f7a181553c8799bcc83da44847bdc8d' +
|
||
'17b461fc3b96a30c2408958cbfa5f5927b6063a8ad199d5ebf2d7cdeffa9c20c85487204804fab53f950b2f87db365aa' +
|
||
'005cdf3d984e3391e7e969276fb4bc02323c5924a4449af167030d855acc2600cf3d4fab025432c6d868c79571a95bef' +
|
||
'174a3473a3af2d0302b9065e895ca4adba4ece6ce0b41148ba597001abb152f852dd9a96fb45c9de0a43d944746f833e',
|
||
},
|
||
{
|
||
msg: utf8ToBytes(
|
||
'a512_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
|
||
),
|
||
expected:
|
||
'123b6bd9feeba26dd4ad00f8bfda2718c9700dc093ea5287d7711844644eb981848316d3f3f57d5d3a652c6cdc816aca' +
|
||
'0a162306f3b0f2bb326f0c4fb0e1fea020019c3af796dcd1d7264f50ddae94cacf3cade74603834d44b9ab3d5d0a6c98' +
|
||
'05483f3b96d9252dd4fc0868344dfaf3c9d145e3387db23fa8e449304fab6a7b6ec9c15f05c0a1ea66ff0efcc03e001a' +
|
||
'15c1d4f1a685bb63ee67ca1fd96155e3d091e852a684b78d085fd34f6091e5249ddddbdcf2e7ec82ce6c04c63647eeb7',
|
||
},
|
||
];
|
||
for (let i = 0; i < VECTORS_G2.length; i++) {
|
||
const t = VECTORS_G2[i];
|
||
should(`hashToCurve/G2 Killic (${i})`, () => {
|
||
const p = bls.G2.hashToCurve(t.msg, {
|
||
DST: 'BLS12381G2_XMD:SHA-256_SSWU_RO_TESTGEN',
|
||
});
|
||
deepStrictEqual(p.toHex(false), t.expected);
|
||
});
|
||
}
|
||
|
||
const VECTORS_ENCODE_G2 = [
|
||
{
|
||
msg: utf8ToBytes(''),
|
||
expected:
|
||
'0d4333b77becbf9f9dfa3ca928002233d1ecc854b1447e5a71f751c9042d000f42db91c1d6649a5e0ad22bd7bf7398b8' +
|
||
'027e4bfada0b47f9f07e04aec463c7371e68f2fd0c738cd517932ea3801a35acf09db018deda57387b0f270f7a219e4d' +
|
||
'0cc76dc777ea0d447e02a41004f37a0a7b1fafb6746884e8d9fc276716ccf47e4e0899548a2ec71c2bdf1a2a50e876db' +
|
||
'053674cba9ef516ddc218fedb37324e6c47de27f88ab7ef123b006127d738293c0277187f7e2f80a299a24d84ed03da7',
|
||
},
|
||
{
|
||
msg: utf8ToBytes('abc'),
|
||
expected:
|
||
'18f0f87b40af67c056915dbaf48534c592524e82c1c2b50c3734d02c0172c80df780a60b5683759298a3303c5d942778' +
|
||
'09349f1cb5b2e55489dcd45a38545343451cc30a1681c57acd4fb0a6db125f8352c09f4a67eb7d1d8242cb7d3405f97b' +
|
||
'10a2ba341bc689ab947b7941ce6ef39be17acaab067bd32bd652b471ab0792c53a2bd03bdac47f96aaafe96e441f63c0' +
|
||
'02f2d9deb2c7742512f5b8230bf0fd83ea42279d7d39779543c1a43b61c885982b611f6a7a24b514995e8a098496b811',
|
||
},
|
||
{
|
||
msg: utf8ToBytes('abcdef0123456789'),
|
||
expected:
|
||
'19808ec5930a53c7cf5912ccce1cc33f1b3dcff24a53ce1cc4cba41fd6996dbed4843ccdd2eaf6a0cd801e562718d163' +
|
||
'149fe43777d34f0d25430dea463889bd9393bdfb4932946db23671727081c629ebb98a89604f3433fba1c67d356a4af7' +
|
||
'04783e391c30c83f805ca271e353582fdf19d159f6a4c39b73acbb637a9b8ac820cfbe2738d683368a7c07ad020e3e33' +
|
||
'04c0d6793a766233b2982087b5f4a254f261003ccb3262ea7c50903eecef3e871d1502c293f9e063d7d293f6384f4551',
|
||
},
|
||
{
|
||
msg: utf8ToBytes(
|
||
'a512_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
|
||
),
|
||
expected:
|
||
'0b8e0094c886487870372eb6264613a6a087c7eb9804fab789be4e47a57b29eb19b1983a51165a1b5eb025865e9fc63a' +
|
||
'0804152cbf8474669ad7d1796ab92d7ca21f32d8bed70898a748ed4e4e0ec557069003732fc86866d938538a2ae95552' +
|
||
'14c80f068ece15a3936bb00c3c883966f75b4e8d9ddde809c11f781ab92d23a2d1d103ad48f6f3bb158bf3e3a4063449' +
|
||
'09e5c8242dd7281ad32c03fe4af3f19167770016255fb25ad9b67ec51d62fade31a1af101e8f6172ec2ee8857662be3a',
|
||
},
|
||
];
|
||
for (let i = 0; i < VECTORS_ENCODE_G2.length; i++) {
|
||
const t = VECTORS_ENCODE_G2[i];
|
||
should(`hashToCurve/G2 (Killic, encodeToCurve) (${i})`, () => {
|
||
const p = bls.G2.encodeToCurve(t.msg, {
|
||
DST: 'BLS12381G2_XMD:SHA-256_SSWU_NU_TESTGEN',
|
||
});
|
||
deepStrictEqual(p.toHex(false), t.expected);
|
||
});
|
||
}
|
||
});
|
||
|
||
describe('verify()', () => {
|
||
should('verify signed message', () => {
|
||
for (let i = 0; i < NUM_RUNS; i++) {
|
||
const [priv, msg] = G2_VECTORS[i];
|
||
const sig = bls.sign(msg, priv);
|
||
const pub = bls.getPublicKey(priv);
|
||
const res = bls.verify(sig, msg, pub);
|
||
deepStrictEqual(res, true, `${priv}-${msg}`);
|
||
}
|
||
});
|
||
should('not verify signature with wrong message', () => {
|
||
for (let i = 0; i < NUM_RUNS; i++) {
|
||
const [priv, msg] = G2_VECTORS[i];
|
||
const invMsg = G2_VECTORS[i + 1][1];
|
||
const sig = bls.sign(msg, priv);
|
||
const pub = bls.getPublicKey(priv);
|
||
const res = bls.verify(sig, invMsg, pub);
|
||
deepStrictEqual(res, false);
|
||
}
|
||
});
|
||
should('not verify signature with wrong key', () => {
|
||
for (let i = 0; i < NUM_RUNS; i++) {
|
||
const [priv, msg] = G2_VECTORS[i];
|
||
const sig = bls.sign(msg, priv);
|
||
const invPriv = G2_VECTORS[i + 1][1].padStart(64, '0');
|
||
const invPub = bls.getPublicKey(invPriv);
|
||
const res = bls.verify(sig, msg, invPub);
|
||
deepStrictEqual(res, false);
|
||
}
|
||
});
|
||
describe('batch', () => {
|
||
should('verify multi-signature', () => {
|
||
fc.assert(
|
||
fc.property(FC_MSG_5, FC_BIGINT_5, (messages, privateKeys) => {
|
||
privateKeys = privateKeys.slice(0, messages.length);
|
||
messages = messages.slice(0, privateKeys.length);
|
||
const publicKey = privateKeys.map(getPubKey);
|
||
const signatures = messages.map((message, i) => bls.sign(message, privateKeys[i]));
|
||
const aggregatedSignature = bls.aggregateSignatures(signatures);
|
||
deepStrictEqual(bls.verifyBatch(aggregatedSignature, messages, publicKey), true);
|
||
})
|
||
);
|
||
});
|
||
should('batch verify multi-signatures', () => {
|
||
fc.assert(
|
||
fc.property(FC_MSG_5, FC_MSG_5, FC_BIGINT_5, (messages, wrongMessages, privateKeys) => {
|
||
privateKeys = privateKeys.slice(0, messages.length);
|
||
messages = messages.slice(0, privateKeys.length);
|
||
wrongMessages = messages.map((a, i) =>
|
||
typeof wrongMessages[i] === 'undefined' ? a : wrongMessages[i]
|
||
);
|
||
const publicKey = privateKeys.map(getPubKey);
|
||
const signatures = messages.map((message, i) => bls.sign(message, privateKeys[i]));
|
||
const aggregatedSignature = bls.aggregateSignatures(signatures);
|
||
deepStrictEqual(
|
||
bls.verifyBatch(aggregatedSignature, wrongMessages, publicKey),
|
||
messages.every((m, i) => m === wrongMessages[i])
|
||
);
|
||
})
|
||
);
|
||
});
|
||
should('not verify multi-signature with wrong public keys', () => {
|
||
fc.assert(
|
||
fc.property(
|
||
FC_MSG_5,
|
||
FC_BIGINT_5,
|
||
FC_BIGINT_5,
|
||
(messages, privateKeys, wrongPrivateKeys) => {
|
||
privateKeys = privateKeys.slice(0, messages.length);
|
||
wrongPrivateKeys = privateKeys.map((a, i) =>
|
||
wrongPrivateKeys[i] !== undefined ? wrongPrivateKeys[i] : a
|
||
);
|
||
messages = messages.slice(0, privateKeys.length);
|
||
const wrongPublicKeys = wrongPrivateKeys.map(getPubKey);
|
||
const signatures = messages.map((message, i) => bls.sign(message, privateKeys[i]));
|
||
const aggregatedSignature = bls.aggregateSignatures(signatures);
|
||
deepStrictEqual(
|
||
bls.verifyBatch(aggregatedSignature, messages, wrongPublicKeys),
|
||
wrongPrivateKeys.every((p, i) => p === privateKeys[i])
|
||
);
|
||
}
|
||
)
|
||
);
|
||
});
|
||
should('verify multi-signature as simple signature', () => {
|
||
fc.assert(
|
||
fc.property(FC_MSG, FC_BIGINT_5, (message, privateKeys) => {
|
||
const publicKey = privateKeys.map(getPubKey);
|
||
const signatures = privateKeys.map((privateKey) => bls.sign(message, privateKey));
|
||
const aggregatedSignature = bls.aggregateSignatures(signatures);
|
||
const aggregatedPublicKey = bls.aggregatePublicKeys(publicKey);
|
||
deepStrictEqual(bls.verify(aggregatedSignature, message, aggregatedPublicKey), true);
|
||
})
|
||
);
|
||
});
|
||
should('not verify wrong multi-signature as simple signature', () => {
|
||
fc.assert(
|
||
fc.property(FC_MSG, FC_MSG, FC_BIGINT_5, (message, wrongMessage, privateKeys) => {
|
||
const publicKey = privateKeys.map(getPubKey);
|
||
const signatures = privateKeys.map((privateKey) => bls.sign(message, privateKey));
|
||
const aggregatedSignature = bls.aggregateSignatures(signatures);
|
||
const aggregatedPublicKey = bls.aggregatePublicKeys(publicKey);
|
||
deepStrictEqual(
|
||
bls.verify(aggregatedSignature, wrongMessage, aggregatedPublicKey),
|
||
message === wrongMessage
|
||
);
|
||
})
|
||
);
|
||
});
|
||
});
|
||
});
|
||
// Deterministic
|
||
describe('bls12-381 deterministic', () => {
|
||
// NOTE: Killic returns all items in reversed order, which looks strange:
|
||
// instead of `Fp2(${this.c0} + ${this.c1}×i)`; it returns `Fp2(${this.c0}×i + ${this.c1})`;
|
||
const killicHex = (lst) =>
|
||
Array.from(lst)
|
||
.reverse()
|
||
.reduce((acc, i) => acc + i);
|
||
|
||
const Fp12 = bls.Fp12;
|
||
|
||
should('Killic based/Pairing', () => {
|
||
const t = bls.pairing(G1Point.BASE, G2Point.BASE);
|
||
deepStrictEqual(
|
||
bytesToHex(Fp12.toBytes(t)),
|
||
killicHex([
|
||
'0f41e58663bf08cf068672cbd01a7ec73baca4d72ca93544deff686bfd6df543d48eaa24afe47e1efde449383b676631',
|
||
'04c581234d086a9902249b64728ffd21a189e87935a954051c7cdba7b3872629a4fafc05066245cb9108f0242d0fe3ef',
|
||
'03350f55a7aefcd3c31b4fcb6ce5771cc6a0e9786ab5973320c806ad360829107ba810c5a09ffdd9be2291a0c25a99a2',
|
||
'11b8b424cd48bf38fcef68083b0b0ec5c81a93b330ee1a677d0d15ff7b984e8978ef48881e32fac91b93b47333e2ba57',
|
||
'06fba23eb7c5af0d9f80940ca771b6ffd5857baaf222eb95a7d2809d61bfe02e1bfd1b68ff02f0b8102ae1c2d5d5ab1a',
|
||
'19f26337d205fb469cd6bd15c3d5a04dc88784fbb3d0b2dbdea54d43b2b73f2cbb12d58386a8703e0f948226e47ee89d',
|
||
'018107154f25a764bd3c79937a45b84546da634b8f6be14a8061e55cceba478b23f7dacaa35c8ca78beae9624045b4b6',
|
||
'01b2f522473d171391125ba84dc4007cfbf2f8da752f7c74185203fcca589ac719c34dffbbaad8431dad1c1fb597aaa5',
|
||
'193502b86edb8857c273fa075a50512937e0794e1e65a7617c90d8bd66065b1fffe51d7a579973b1315021ec3c19934f',
|
||
'1368bb445c7c2d209703f239689ce34c0378a68e72a6b3b216da0e22a5031b54ddff57309396b38c881c4c849ec23e87',
|
||
'089a1c5b46e5110b86750ec6a532348868a84045483c92b7af5af689452eafabf1a8943e50439f1d59882a98eaa0170f',
|
||
'1250ebd871fc0a92a7b2d83168d0d727272d441befa15c503dd8e90ce98db3e7b6d194f60839c508a84305aaca1789b6',
|
||
])
|
||
);
|
||
});
|
||
should('Killic based/Pairing (big)', () => {
|
||
let p1 = G1Point.BASE;
|
||
let p2 = G2Point.BASE;
|
||
for (let v of pairingVectors) {
|
||
deepStrictEqual(
|
||
bytesToHex(Fp12.toBytes(bls.pairing(p1, p2))),
|
||
// Reverse order
|
||
v.match(/.{96}/g).reverse().join('')
|
||
);
|
||
p1 = p1.add(G1Point.BASE);
|
||
p2 = p2.add(G2Point.BASE);
|
||
}
|
||
});
|
||
|
||
should(`zkcrypto/G1/compressed`, () => {
|
||
let p1 = G1Point.ZERO;
|
||
for (let i = 0; i < zkVectors.G1_Compressed.length; i++) {
|
||
const t = zkVectors.G1_Compressed[i];
|
||
const P = G1Point.fromHex(t);
|
||
deepStrictEqual(P.toHex(true), t);
|
||
deepStrictEqual(P.equals(p1), true);
|
||
deepStrictEqual(p1.toHex(true), t);
|
||
p1 = p1.add(G1Point.BASE);
|
||
if (i) {
|
||
deepStrictEqual(G1Point.BASE.multiply(BigInt(i)).toHex(true), t);
|
||
deepStrictEqual(G1Point.BASE.multiplyUnsafe(BigInt(i)).toHex(true), t);
|
||
deepStrictEqual(G1Point.BASE.multiply(BigInt(i)).toHex(true), t);
|
||
}
|
||
}
|
||
});
|
||
should(`zkcrypto/G1/uncompressed`, () => {
|
||
let p1 = G1Point.ZERO;
|
||
for (let i = 0; i < zkVectors.G1_Uncompressed.length; i++) {
|
||
const t = zkVectors.G1_Uncompressed[i];
|
||
const P = G1Point.fromHex(t);
|
||
deepStrictEqual(P.toHex(false), t);
|
||
deepStrictEqual(P.equals(p1), true);
|
||
deepStrictEqual(p1.toHex(false), t);
|
||
p1 = p1.add(G1Point.BASE);
|
||
if (i) {
|
||
deepStrictEqual(G1Point.BASE.multiply(BigInt(i)).toHex(false), t);
|
||
deepStrictEqual(G1Point.BASE.multiplyUnsafe(BigInt(i)).toHex(false), t);
|
||
deepStrictEqual(G1Point.BASE.multiply(BigInt(i)).toHex(false), t);
|
||
}
|
||
}
|
||
});
|
||
should(`zkcrypto/G2/compressed`, () => {
|
||
let p1 = G2Point.ZERO;
|
||
for (let i = 0; i < zkVectors.G2_Compressed.length; i++) {
|
||
const t = zkVectors.G2_Compressed[i];
|
||
const P = G2Point.fromHex(t);
|
||
deepStrictEqual(P.toHex(true), t);
|
||
deepStrictEqual(P.equals(p1), true);
|
||
deepStrictEqual(p1.toHex(true), t);
|
||
p1 = p1.add(G2Point.BASE);
|
||
if (i) {
|
||
let n = BigInt(i);
|
||
deepStrictEqual(G2Point.BASE.multiply(n).toHex(true), t);
|
||
deepStrictEqual(G2Point.BASE.multiplyUnsafe(n).toHex(true), t);
|
||
deepStrictEqual(G2Point.BASE.multiply(n).toHex(true), t);
|
||
}
|
||
}
|
||
});
|
||
should(`zkcrypto/G2/uncompressed`, () => {
|
||
let p1 = G2Point.ZERO;
|
||
for (let i = 0; i < zkVectors.G2_Uncompressed.length; i++) {
|
||
const t = zkVectors.G2_Uncompressed[i];
|
||
const P = G2Point.fromHex(t);
|
||
deepStrictEqual(P.toHex(false), t);
|
||
deepStrictEqual(P.equals(p1), true);
|
||
deepStrictEqual(p1.toHex(false), t);
|
||
p1 = p1.add(G2Point.BASE);
|
||
if (i) {
|
||
deepStrictEqual(G2Point.BASE.multiply(BigInt(i)).toHex(false), t);
|
||
deepStrictEqual(G2Point.BASE.multiplyUnsafe(BigInt(i)).toHex(false), t);
|
||
deepStrictEqual(G2Point.BASE.multiply(BigInt(i)).toHex(false), t);
|
||
}
|
||
}
|
||
});
|
||
});
|
||
|
||
// ESM is broken.
|
||
import url from 'url';
|
||
if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
|
||
should.run();
|
||
}
|
||
|
||
// TODO: merge Fp tests with group tests in basic
|