This repository has been archived on 2023-04-09. You can view files and clone it, but cannot push or open issues or pull requests.
chainsafe-bls/test/unit/index.test.ts

148 lines
5.4 KiB
TypeScript
Raw Normal View History

2020-11-05 20:55:25 +00:00
import {expect} from "chai";
2020-11-20 19:03:17 +00:00
import {IBls} from "../../src/interface";
2020-11-20 12:27:30 +00:00
import {getN, randomMessage} from "../util";
import {hexToBytes} from "../../src/helpers";
2020-12-02 23:15:39 +00:00
import {maliciousVerifyMultipleSignaturesData} from "../data/malicious-signature-test-data";
export function runIndexTests(bls: IBls): void {
2020-11-20 12:27:30 +00:00
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
function getRandomData() {
2020-11-30 18:01:13 +00:00
const sk = bls.SecretKey.fromKeygen();
const pk = sk.toPublicKey();
const msg = randomMessage();
2020-11-25 16:09:44 +00:00
const sig = sk.sign(msg);
return {sk, pk, msg, sig};
}
describe("verify", () => {
2019-09-17 20:03:24 +00:00
it("should verify signature", () => {
const {pk, msg, sig} = getRandomData();
const pkHex = pk.toHex();
const isValid = bls.verify(pk.toBytes(), msg, sig.toBytes());
expect(isValid, "fail verify").to.be.true;
2019-08-05 15:48:26 +00:00
// Make sure to not modify original pubkey when verifying
expect(pk.toHex()).to.be.equal(pkHex, "pubkey modified when verifying");
2019-08-05 15:48:26 +00:00
});
2019-09-17 20:03:24 +00:00
it("should fail verify empty signature", () => {
const {pk, msg} = getRandomData();
const emptySig = Buffer.alloc(96);
const isValid = bls.verify(pk.toBytes(), msg, emptySig);
expect(isValid).to.be.false;
2019-08-05 15:48:26 +00:00
});
2019-09-17 20:03:24 +00:00
it("should fail verify signature of different message", () => {
const {pk, sig} = getRandomData();
const msg2 = randomMessage();
const isValid = bls.verify(pk.toBytes(), msg2, sig.toBytes());
expect(isValid).to.be.false;
2019-08-05 15:48:26 +00:00
});
2019-09-17 20:03:24 +00:00
it("should fail verify signature signed by different key", () => {
const {msg, sig} = getRandomData();
const {pk: pk2} = getRandomData();
const isValid = bls.verify(pk2.toBytes(), msg, sig.toBytes());
expect(isValid).to.be.false;
2019-08-05 15:48:26 +00:00
});
});
describe("verify multiple", () => {
2020-11-20 12:27:30 +00:00
it("should verify aggregated signatures", () => {
2020-11-30 18:01:13 +00:00
const sks = getN(4, () => bls.SecretKey.fromKeygen());
const msgs = getN(2, () => randomMessage());
const pks = sks.map((sk) => sk.toPublicKey());
2019-08-05 15:48:26 +00:00
2020-11-25 16:09:44 +00:00
const sigs = [sks[0].sign(msgs[0]), sks[1].sign(msgs[0]), sks[2].sign(msgs[1]), sks[3].sign(msgs[1])];
2019-08-05 15:48:26 +00:00
const aggPubkeys = [
2020-11-30 18:01:13 +00:00
bls.aggregatePublicKeys([pks[0], pks[1]].map((pk) => pk.toBytes())),
bls.aggregatePublicKeys([pks[2], pks[3]].map((pk) => pk.toBytes())),
];
2019-08-05 15:48:26 +00:00
const aggSig = bls.aggregateSignatures(sigs.map((sig) => sig.toBytes()));
2019-08-05 15:48:26 +00:00
expect(bls.verifyMultiple(aggPubkeys, msgs, aggSig), "should be valid").to.be.true;
expect(bls.verifyMultiple(aggPubkeys.reverse(), msgs, aggSig), "should fail - swaped pubkeys").to.be.false;
});
2019-08-05 15:48:26 +00:00
it("should verify aggregated signatures - same message", () => {
const n = 4;
const msg = randomMessage();
2020-11-30 18:01:13 +00:00
const sks = getN(n, () => bls.SecretKey.fromKeygen());
const pks = sks.map((sk) => sk.toPublicKey());
2020-11-25 16:09:44 +00:00
const sigs = sks.map((sk) => sk.sign(msg));
2019-08-05 15:48:26 +00:00
const aggregateSignature = bls.aggregateSignatures(sigs.map((sig) => sig.toBytes()));
2019-08-05 15:48:26 +00:00
const isValid = bls.verifyMultiple(
pks.map((pk) => pk.toBytes()),
getN(4, () => msg), // Same message n times
2020-11-19 00:23:34 +00:00
aggregateSignature
2019-08-28 13:57:26 +00:00
);
expect(isValid).to.be.true;
2019-08-05 15:48:26 +00:00
});
2019-09-17 20:03:24 +00:00
it("should fail to verify aggregated signatures - no public keys", () => {
const sig = Buffer.alloc(96);
const msg1 = randomMessage();
const msg2 = randomMessage();
2019-08-05 15:48:26 +00:00
const isValid = bls.verifyMultiple([], [msg2, msg1], sig);
expect(isValid).to.be.false;
2019-08-05 15:48:26 +00:00
});
});
describe("verifyMultipleSignatures", () => {
it("Should verify multiple signatures", () => {
const n = 4;
const dataArr = getN(n, () => {
const sk = bls.SecretKey.fromKeygen();
const pk = sk.toPublicKey();
const msg = randomMessage();
const sig = sk.sign(msg);
return {pk, msg, sig};
});
const pks = dataArr.map((data) => data.pk);
const msgs = dataArr.map((data) => data.msg);
const sigs = dataArr.map((data) => data.sig);
expect(
bls.verifyMultipleSignatures(
pks.map((pk) => pk.toBytes()),
msgs,
sigs.map((sig) => sig.toBytes())
)
).to.equal(true, "functional (bytes serialized) interface failed");
expect(bls.Signature.verifyMultipleSignatures(pks, msgs, sigs)).to.equal(true, "class interface failed");
});
it("Test fails correctly against a malicous signature", async () => {
2020-12-02 23:15:39 +00:00
const pks = maliciousVerifyMultipleSignaturesData.pks.map(hexToBytes);
const msgs = maliciousVerifyMultipleSignaturesData.msgs.map(hexToBytes);
const sigs = maliciousVerifyMultipleSignaturesData.sigs.map(hexToBytes);
maliciousVerifyMultipleSignaturesData.manipulated.forEach((isManipulated, i) => {
expect(bls.verify(pks[i], msgs[i], sigs[i])).to.equal(
!isManipulated,
isManipulated ? "Manipulated signature should not verify" : "Ok signature should verify"
);
});
// This method (AggregateVerify in BLS spec lingo) should verify
const dangerousAggSig = bls.aggregateSignatures(sigs);
expect(bls.verifyMultiple(pks, msgs, dangerousAggSig)).to.equal(
true,
"Malicious signature should be validated with bls.verifyMultiple"
);
// This method is expected to catch the malicious signature and not verify
expect(bls.verifyMultipleSignatures(pks, msgs, sigs)).to.equal(
false,
"Malicous signature should not validate with bls.verifyMultipleSignatures"
);
});
});
2020-11-20 19:03:17 +00:00
}