diff --git a/.babelrc b/.babelrc index 633f93f..353bc18 100644 --- a/.babelrc +++ b/.babelrc @@ -1,3 +1,8 @@ { - "extends": "../../.babelrc" + "extends": "../../.babelrc", + "plugins": [ + "@babel/proposal-class-properties", + "@babel/proposal-object-rest-spread", + "rewire-exports" + ] } diff --git a/.gitignore b/.gitignore index 435d202..6da32d7 100644 --- a/.gitignore +++ b/.gitignore @@ -64,3 +64,4 @@ typings/ dist/ lib/ +benchmark-reports diff --git a/package.json b/package.json index fd73b1d..346c4bb 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@chainsafe/bls", - "version": "0.1.6", + "version": "0.1.7", "description": "Implementation of bls signature verification for ethereum 2.0", "main": "lib/index.js", "types": "lib/index.d.ts", @@ -27,12 +27,15 @@ "lint:fix": "eslint --ext .ts src/ --fix", "pretest": "yarn check-types", "prepublishOnly": "yarn build", - "test:unit": "nyc --cache-dir .nyc_output/.cache -r lcov -e .ts mocha -r ./.babel-register 'test/unit/**/*.test.ts' && nyc report", - "test:spec": "mocha -r ./.babel-register 'test/spec/**/*.test.ts'", + "test:unit": "nyc --cache-dir .nyc_output/.cache -r lcov -e .ts mocha --colors -r ./.babel-register 'test/unit/**/*.test.ts' && nyc report", + "test:spec": "mocha --colors -r ./.babel-register 'test/spec/**/*.test.ts'", + "test:spec-min": "yarn run test:spec", "test": "yarn test:unit && yarn test:spec", - "coverage": "codecov -F bls" + "coverage": "codecov -F bls", + "benchmark": "node -r ./.babel-register test/benchmarks" }, "dependencies": { + "@chainsafe/eth2.0-types": "^0.1.0", "@chainsafe/milagro-crypto-js": "0.1.3", "assert": "^1.4.1", "js-sha256": "^0.9.0", @@ -48,11 +51,12 @@ "@babel/preset-typescript": "^7.3.3", "@babel/register": "^7.0.0", "@babel/runtime": "^7.4.4", + "@chainsafe/benchmark-utils": "^0.1.0", "@chainsafe/eth2.0-spec-test-util": "^0.2.3", "@types/assert": "^1.4.2", "@types/chai": "^4.1.7", "@types/mocha": "^5.2.5", - "@types/node": "^10.12.17", + "@types/node": "^12.7.2", "@typescript-eslint/eslint-plugin": "^1.3.0", "@typescript-eslint/parser": "^1.3.0", "babel-plugin-rewire-exports": "^1.1.0", diff --git a/src/@types/keccak256/index.d.ts b/src/@types/keccak256/index.d.ts deleted file mode 100644 index ab9ee2a..0000000 --- a/src/@types/keccak256/index.d.ts +++ /dev/null @@ -1,5 +0,0 @@ -declare module "keccak256" { - - export default function hash(a: Buffer | (Buffer | string | number)[]): Buffer; - -} diff --git a/src/helpers/g1point.ts b/src/helpers/g1point.ts index 9dcfa74..9d832ca 100644 --- a/src/helpers/g1point.ts +++ b/src/helpers/g1point.ts @@ -1,11 +1,11 @@ import {BIG} from "@chainsafe/milagro-crypto-js/src/big"; import {ECP} from "@chainsafe/milagro-crypto-js/src/ecp"; import ctx from "../ctx"; -import {bytes48} from "../types"; import assert from "assert"; import {calculateYFlag, getModulus} from "./utils"; import * as random from "secure-random"; import {FP_POINT_LENGTH} from "../constants"; +import {BLSPubkey, bytes48} from "@chainsafe/eth2.0-types"; export class G1point { @@ -15,6 +15,50 @@ export class G1point { this.point = point; } + public mul(value: BIG): G1point { + const newPoint = this.point.mul(value); + return new G1point(newPoint); + } + + public add(other: G1point): G1point { + const sum = new ctx.ECP(); + sum.add(this.point); + sum.add(other.point); + sum.affine(); + return new G1point(sum); + } + + public addRaw(other: bytes48): G1point { + return this.add(G1point.fromBytesCompressed(other)); + } + + public equal(other: G1point): boolean { + return this.point.equals(other.point); + } + + public toBytes(): bytes48 { + const buffer = Buffer.alloc(FP_POINT_LENGTH, 0); + this.point.getX().tobytearray(buffer, 0); + return buffer; + } + + public getPoint(): ECP { + return this.point; + } + + public toBytesCompressed(): bytes48 { + const output = this.toBytes(); + const c = true; + const b = this.point.is_infinity(); + const a = !b && calculateYFlag(this.point.getY()); + + const flags = ((a ? 1 << 5 : 0) | (b ? 1 << 6 : 0) | (c ? 1 << 7 : 0)); + const mask = 31; + output[0] &= mask; + output[0] |= flags; + return output; + } + public static fromBytesCompressed(value: bytes48): G1point { assert(value.length === FP_POINT_LENGTH, `Expected g1 compressed input to have ${FP_POINT_LENGTH} bytes`); value = Buffer.from(value); @@ -62,6 +106,14 @@ export class G1point { return new G1point(point); } + public static aggregate(values: bytes48[]): G1point { + return values.map((value) => { + return G1point.fromBytesCompressed(value); + }).reduce((previousValue, currentValue): G1point => { + return previousValue.add(currentValue); + }); + } + public static generator(): G1point { return new G1point(ctx.ECP.generator()); } diff --git a/src/helpers/g2point.ts b/src/helpers/g2point.ts index a011fed..e546288 100644 --- a/src/helpers/g2point.ts +++ b/src/helpers/g2point.ts @@ -1,12 +1,12 @@ import {BIG} from "@chainsafe/milagro-crypto-js/src/big"; import {ECP2} from "@chainsafe/milagro-crypto-js/src/ecp2"; -import {BLSDomain, bytes32, bytes96} from "../types"; -import {sha256} from "js-sha256"; +import {sha256} from 'js-sha256'; import ctx from "../ctx"; import * as random from "secure-random"; import {calculateYFlag, getModulus, padLeft} from "./utils"; import assert from "assert"; import {FP_POINT_LENGTH, G2_HASH_PADDING} from "../constants"; +import {bytes48, Domain, Hash} from "@chainsafe/eth2.0-types"; export class G2point { @@ -16,8 +16,49 @@ export class G2point { this.point = point; } + public add(other: G2point): G2point { + const sum = new ctx.ECP2(); + sum.add(this.point); + sum.add(other.point); + sum.affine(); + return new G2point(sum); + } - public static hashToG2(message: bytes32, domain: BLSDomain): G2point { + public mul(value: BIG): G2point { + const newPoint = this.point.mul(value); + return new G2point(newPoint); + } + + public equal(other: G2point): boolean { + return this.point.equals(other.point); + } + + public getPoint(): ECP2 { + return this.point; + } + + public toBytesCompressed(): bytes48 { + const xReBytes = Buffer.alloc(FP_POINT_LENGTH, 0); + const xImBytes = Buffer.alloc(FP_POINT_LENGTH, 0); + this.point.getX().getA().tobytearray(xReBytes, 0); + this.point.getX().getB().tobytearray(xImBytes, 0); + const c1 = true; + const b1 = this.point.is_infinity(); + const a1 = !b1 && calculateYFlag(this.point.getY().getB()); + + const flags = ((a1 ? 1 << 5 : 0) | (b1 ? 1 << 6 : 0) | (c1 ? 1 << 7 : 0)); + const mask = 31; + xImBytes[0] &= mask; + xImBytes[0] |= flags; + xReBytes[0] &= mask; + + return Buffer.concat([ + xImBytes, + xReBytes + ]); + } + + public static hashToG2(message: Hash, domain: Domain): G2point { const padding = Buffer.alloc(G2_HASH_PADDING, 0); const xReBytes = Buffer.concat([ padding, @@ -53,8 +94,8 @@ export class G2point { return new G2point(G2point.scaleWithCofactor(G2point.normaliseY(point))); } - public static fromCompressedBytes(value: bytes96): G2point { - assert(value.length === 2 * FP_POINT_LENGTH, "Expected signature of 96 bytes"); + public static fromCompressedBytes(value: bytes48): G2point { + assert(value.length === 2 * FP_POINT_LENGTH, 'Expected signature of 96 bytes'); value = Buffer.from(value); const xImBytes = value.slice(0, FP_POINT_LENGTH); const xReBytes = value.slice(FP_POINT_LENGTH); diff --git a/src/index.ts b/src/index.ts index 54f2a68..df664fe 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,11 +1,3 @@ -import { - BLSDomain, - BLSSecretKey, - BLSPubkey, - BLSSignature, - bytes32, - bytes8 -} from "./types"; import {Keypair} from "./keypair"; import {PrivateKey} from "./privateKey"; import {G2point} from "./helpers/g2point"; @@ -14,11 +6,14 @@ import {PublicKey} from "./publicKey"; import {Signature} from "./signature"; import {ElipticCurvePairing} from "./helpers/ec-pairing"; import ctx from "./ctx"; +import {BLSPubkey, BLSSecretKey, BLSSignature, Domain, Hash} from "@chainsafe/eth2.0-types"; + +export {Keypair, PrivateKey, PublicKey, Signature}; /** * Generates new secret and public key */ -function generateKeyPair(): Keypair { +export function generateKeyPair(): Keypair { return Keypair.generate(); } @@ -26,7 +21,7 @@ function generateKeyPair(): Keypair { * Generates public key from given secret. * @param {BLSSecretKey} secretKey */ -function generatePublicKey(secretKey: BLSSecretKey): BLSPubkey { +export function generatePublicKey(secretKey: BLSSecretKey): BLSPubkey { const keypair = new Keypair(PrivateKey.fromBytes(secretKey)); return keypair.publicKey.toBytesCompressed(); } @@ -37,7 +32,7 @@ function generatePublicKey(secretKey: BLSSecretKey): BLSPubkey { * @param messageHash * @param domain */ -function sign(secretKey: BLSSecretKey, messageHash: bytes32, domain: BLSDomain): BLSSignature { +export function sign(secretKey: BLSSecretKey, messageHash: Hash, domain: Domain): BLSSignature { const privateKey = PrivateKey.fromBytes(secretKey); const hash = G2point.hashToG2(messageHash, domain); return privateKey.sign(hash).toBytesCompressed(); @@ -47,7 +42,7 @@ function sign(secretKey: BLSSecretKey, messageHash: bytes32, domain: BLSDomain): * Compines all given signature into one. * @param signatures */ -function aggregateSignatures(signatures: BLSSignature[]): BLSSignature { +export function aggregateSignatures(signatures: BLSSignature[]): BLSSignature { return signatures.map((signature): Signature => { return Signature.fromCompressedBytes(signature); }).reduce((previousValue, currentValue): Signature => { @@ -59,15 +54,11 @@ function aggregateSignatures(signatures: BLSSignature[]): BLSSignature { * Combines all given public keys into single one * @param publicKeys */ -function aggregatePubkeys(publicKeys: BLSPubkey[]): BLSPubkey { +export function aggregatePubkeys(publicKeys: BLSPubkey[]): BLSPubkey { if(publicKeys.length === 0) { return new G1point(new ctx.ECP()).toBytesCompressed(); } - return publicKeys.map((publicKey): G1point => { - return G1point.fromBytesCompressed(publicKey); - }).reduce((previousValue, currentValue): G1point => { - return previousValue.add(currentValue); - }).toBytesCompressed(); + return G1point.aggregate(publicKeys).toBytesCompressed(); } /** @@ -77,11 +68,13 @@ function aggregatePubkeys(publicKeys: BLSPubkey[]): BLSPubkey { * @param signature * @param domain */ -function verify(publicKey: BLSPubkey, messageHash: bytes32, signature: BLSSignature, domain: bytes8): boolean { +export function verify(publicKey: BLSPubkey, messageHash: Hash, signature: BLSSignature, domain: Domain): boolean { try { const key = PublicKey.fromBytes(publicKey); const sig = Signature.fromCompressedBytes(signature); + key.getPoint().getPoint().affine(); + sig.getPoint().getPoint().affine(); const g1Generated = G1point.generator(); const e1 = ElipticCurvePairing.pair(key.getPoint(), G2point.hashToG2(messageHash, domain)); const e2 = ElipticCurvePairing.pair(g1Generated, sig.getPoint()); @@ -98,28 +91,52 @@ function verify(publicKey: BLSPubkey, messageHash: bytes32, signature: BLSSignat * @param signature * @param domain */ -function verifyMultiple( - publicKeys: BLSPubkey[], - messageHashes: bytes32[], - signature: BLSSignature, - domain: bytes8 -): boolean { +export function verifyMultiple(publicKeys: BLSPubkey[], messageHashes: Hash[], signature: BLSSignature, domain: Domain): boolean { if(publicKeys.length === 0 || publicKeys.length != messageHashes.length) { return false; } try { - const g1Generated = G1point.generator(); + const sig = Signature.fromCompressedBytes(signature).getPoint(); + sig.getPoint().affine(); + const eCombined = new ctx.FP12(1); - publicKeys.forEach((publicKey, index): void => { - const g2 = G2point.hashToG2(messageHashes[index], domain); - eCombined.mul( - ElipticCurvePairing.pair( - PublicKey.fromBytes(publicKey).getPoint(), - g2 - ) - ); - }); - const e2 = ElipticCurvePairing.pair(g1Generated, Signature.fromCompressedBytes(signature).getPoint()); + + const reduction = messageHashes.reduce((previous, current, index) => { + if(previous.hash && current.equals(previous.hash)) { + return { + hash: previous.hash, + publicKey: previous.publicKey ? + previous.publicKey.addRaw(publicKeys[index]) + : + G1point.fromBytesCompressed(publicKeys[index]), + }; + } else if(!!previous.hash) { + const g2 = G2point.hashToG2(previous.hash, domain); + eCombined.mul( + ElipticCurvePairing.pair( + previous.publicKey, + g2 + ) + ); + return {hash: current, publicKey: G1point.fromBytesCompressed(publicKeys[index])}; + } else { + return { + hash: current, + publicKey: G1point.fromBytesCompressed(publicKeys[index]) + }; + } + }, {hash: null, publicKey: null}); + + const g2Final = G2point.hashToG2(reduction.hash, domain); + const keyFinal = reduction.publicKey; + eCombined.mul( + ElipticCurvePairing.pair( + keyFinal, + g2Final + ) + ); + + const e2 = ElipticCurvePairing.pair(G1point.generator(), sig); return e2.equals(eCombined); } catch (e) { return false; diff --git a/src/privateKey.ts b/src/privateKey.ts index d2bfe90..329fe2d 100644 --- a/src/privateKey.ts +++ b/src/privateKey.ts @@ -5,7 +5,7 @@ import ctx from "./ctx"; import {padLeft} from "./helpers/utils"; import {G2point} from "./helpers/g2point"; import * as random from "secure-random"; -import {BLSDomain, BLSSecretKey, bytes32} from "./types"; +import {BLSSecretKey, Hash, Domain} from "@chainsafe/eth2.0-types"; export class PrivateKey { @@ -15,9 +15,30 @@ export class PrivateKey { this.value = value; } + public getValue(): BIG { + return this.value; + } + + public sign(message: G2point): G2point { + return message.mul(this.value); + } + + public signMessage(message: Hash, domain: Domain): G2point { + return G2point.hashToG2(message, domain).mul(this.value); + } + + public toBytes(): BLSSecretKey { + const buffer = Buffer.alloc(FP_POINT_LENGTH, 0); + this.value.tobytearray(buffer, 0); + return buffer.slice(FP_POINT_LENGTH - SECRET_KEY_LENGTH); + } + + public toHexString(): string { + return `0x${this.toBytes().toString('hex')}`; + } public static fromBytes(bytes: Uint8Array): PrivateKey { - assert(bytes.length === SECRET_KEY_LENGTH, "Private key should have 32 bytes"); + assert(bytes.length === SECRET_KEY_LENGTH, 'Private key should have 32 bytes'); const value = Buffer.from(bytes); return new PrivateKey( ctx.BIG.frombytearray( @@ -32,7 +53,7 @@ export class PrivateKey { public static fromHexString(value: string): PrivateKey { return PrivateKey.fromBytes( - Buffer.from(value.replace("0x", ""), "hex") + Buffer.from(value.replace('0x', ''), 'hex') ); } @@ -40,26 +61,4 @@ export class PrivateKey { return PrivateKey.fromBytes(random.randomBuffer(SECRET_KEY_LENGTH)); } - public getValue(): BIG { - return this.value; - } - - public sign(message: G2point): G2point { - return message.mul(this.value); - } - - public signMessage(message: bytes32, domain: BLSDomain): G2point { - return G2point.hashToG2(message, domain).mul(this.value); - } - - public toBytes(): BLSSecretKey { - const buffer = Buffer.alloc(FP_POINT_LENGTH, 0); - this.value.tobytearray(buffer, 0); - return buffer.slice(FP_POINT_LENGTH - SECRET_KEY_LENGTH); - } - - public toHexString(): string { - return `0x${this.toBytes().toString("hex")}`; - } - } diff --git a/src/publicKey.ts b/src/publicKey.ts index d8bd967..8b16a0b 100644 --- a/src/publicKey.ts +++ b/src/publicKey.ts @@ -1,6 +1,6 @@ import {G1point} from "./helpers/g1point"; import {PrivateKey} from "./privateKey"; -import {BLSPubkey} from "./types"; +import {BLSPubkey} from "@chainsafe/eth2.0-types"; export class PublicKey { diff --git a/src/signature.ts b/src/signature.ts index 00847ba..5259a17 100644 --- a/src/signature.ts +++ b/src/signature.ts @@ -1,7 +1,7 @@ import {G2point} from "./helpers/g2point"; -import {BLSSignature} from "./types"; import assert from "assert"; import {FP_POINT_LENGTH} from "./constants"; +import {BLSSignature} from "@chainsafe/eth2.0-types"; export class Signature { diff --git a/src/types.ts b/src/types.ts deleted file mode 100644 index 6a6346a..0000000 --- a/src/types.ts +++ /dev/null @@ -1,9 +0,0 @@ -export type bytes8 = Buffer; -export type bytes32 = Buffer; -export type bytes48 = Buffer; -export type bytes96 = Buffer; - -export type BLSDomain = bytes8; -export type BLSPubkey = bytes48; -export type BLSSecretKey = bytes32; -export type BLSSignature = bytes96; diff --git a/test/benchmarks/index.ts b/test/benchmarks/index.ts new file mode 100644 index 0000000..5b03fa5 --- /dev/null +++ b/test/benchmarks/index.ts @@ -0,0 +1,11 @@ +// Import benchmarks +import * as suites from "./suites"; +import {createReportDir, runSuite} from "@chainsafe/benchmark-utils"; +// Create file +const directory: string = createReportDir(); + + +// Run benchmarks +Object.values(suites).forEach((suite) => { + runSuite(suite(directory)); +}); \ No newline at end of file diff --git a/test/benchmarks/suites/index.ts b/test/benchmarks/suites/index.ts new file mode 100644 index 0000000..1648eaf --- /dev/null +++ b/test/benchmarks/suites/index.ts @@ -0,0 +1,5 @@ +// export {verifyInValidSignatureBenchmark} from './verifyInValidSignature'; +// export {verifyValidSignatureBenchmark} from './verifyValidSignature'; +export {verifyValidAggregatedSignature} from './verifyValidAggregatedSignature'; +// export {verifyInvalidAggregatedSignature} from './verifyInvalidAggregatedSignature'; +// export {aggregateSignaturesBenchmark} from './signatureAggregation'; \ No newline at end of file diff --git a/test/benchmarks/suites/signatureAggregation.ts b/test/benchmarks/suites/signatureAggregation.ts new file mode 100644 index 0000000..ad58d51 --- /dev/null +++ b/test/benchmarks/suites/signatureAggregation.ts @@ -0,0 +1,39 @@ +/* eslint-disable @typescript-eslint/no-require-imports,@typescript-eslint/no-var-requires */ + +import {BenchSuite} from "@chainsafe/benchmark-utils"; +import {aggregateSignatures} from "../../../src"; + + +// eslint-disable-next-line @typescript-eslint/no-namespace +declare namespace global { + export let signatures: Buffer[]; + export let aggregateSignatures: Function; +} + +// @ts-ignore +global.require = require; + +global.aggregateSignatures = aggregateSignatures; + +export function aggregateSignaturesBenchmark(dir: string): BenchSuite { + + // Set the function test + const FUNCTION_NAME = "verifyValidSignature"; // PLEASE FILL THIS OUT + + const aggregateSignatures = function (): void { + global.aggregateSignatures(global.signatures); + }; + + return { + testFunctions: [aggregateSignatures], + setup: function() { + global.signatures = []; + const {Keypair} = require("../../../src"); + const {sha256} = require('js-sha256'); + const keypair = Keypair.generate(); + const message = Buffer.from(sha256.arrayBuffer(Math.random().toString(36))); + global.signatures.push(keypair.privateKey.signMessage(Buffer.from(message), Buffer.alloc(8)).toBytesCompressed()); + }, + file: dir + FUNCTION_NAME + ".txt" + }; +} \ No newline at end of file diff --git a/test/benchmarks/suites/verifyInValidSignature.ts b/test/benchmarks/suites/verifyInValidSignature.ts new file mode 100644 index 0000000..6cd4106 --- /dev/null +++ b/test/benchmarks/suites/verifyInValidSignature.ts @@ -0,0 +1,42 @@ +import {BenchSuite} from "@chainsafe/benchmark-utils"; +import {verify} from "../../../src"; + + +// eslint-disable-next-line @typescript-eslint/no-namespace +declare namespace global { + export let domain: Buffer; + export let message: Buffer; + export let signature: Buffer; + export let publicKey: Buffer; + export let verify: Function; +} + +// @ts-ignore +global.require = require; + +global.domain = Buffer.alloc(8); +global.verify = verify; + +export function verifyInValidSignatureBenchmark(dir: string): BenchSuite { + + // Set the function test + const FUNCTION_NAME = "verifyInValidSignature"; // PLEASE FILL THIS OUT + + const verifyInValidSignature = function (): void { + global.verify(global.publicKey, global.message, global.signature, global.domain); + }; + + return { + testFunctions: [verifyInValidSignature], + setup: function() { + const {Keypair} = require("../../../src"); + const {sha256} = require('js-sha256'); + const keypair = Keypair.generate(); + const keypair2 = Keypair.generate(); + global.publicKey = keypair2.publicKey.toBytesCompressed(); + global.message = Buffer.from(sha256.arrayBuffer(Math.random().toString(36))); + global.signature = keypair.privateKey.signMessage(Buffer.from(global.message), global.domain).toBytesCompressed(); + }, + file: dir + FUNCTION_NAME + ".txt" + }; +} \ No newline at end of file diff --git a/test/benchmarks/suites/verifyInvalidAggregatedSignature.ts b/test/benchmarks/suites/verifyInvalidAggregatedSignature.ts new file mode 100644 index 0000000..32e4a33 --- /dev/null +++ b/test/benchmarks/suites/verifyInvalidAggregatedSignature.ts @@ -0,0 +1,48 @@ +import {BenchSuite} from "@chainsafe/benchmark-utils"; +import {aggregateSignatures, verifyMultiple} from "../../../src"; + + +// eslint-disable-next-line @typescript-eslint/no-namespace +declare namespace global { + export let domain: Buffer; + export let messages: Buffer[]; + export let signature: Buffer; + export let publicKeys: Buffer[]; + export let verify: Function; +} + +// @ts-ignore +global.require = require; + +global.domain = Buffer.alloc(8); +global.verify = verifyMultiple; + +export function verifyInvalidAggregatedSignature(dir: string): BenchSuite { + + // Set the function test + const FUNCTION_NAME = "verifyInvalidAggregatedSignature"; // PLEASE FILL THIS OUT + + const verifyInvalidAggregatedSignature = function (): void { + global.verify(global.publicKeys, global.messages, global.signature, global.domain); + }; + + return { + testFunctions: [verifyInvalidAggregatedSignature], + setup: function() { + const {Keypair, aggregateSignatures} = require("../../../src"); + const {sha256} = require('js-sha256'); + const signatures = []; + global.publicKeys = []; + const message = Buffer.from(sha256.arrayBuffer(Math.random().toString(36))); + const message2 = Buffer.from(sha256.arrayBuffer(Math.random().toString(36))); + for(let i = 0; i < 128; i++) { + const keypair = Keypair.generate(); + global.publicKeys.push(keypair.publicKey.toBytesCompressed()); + signatures.push(keypair.privateKey.signMessage(Buffer.from(message), global.domain).toBytesCompressed()); + } + global.messages = global.publicKeys.map(() => message2); + global.signature = aggregateSignatures(signatures); + }, + file: dir + FUNCTION_NAME + ".txt" + }; +} \ No newline at end of file diff --git a/test/benchmarks/suites/verifyValidAggregatedSignature.ts b/test/benchmarks/suites/verifyValidAggregatedSignature.ts new file mode 100644 index 0000000..5bca5f1 --- /dev/null +++ b/test/benchmarks/suites/verifyValidAggregatedSignature.ts @@ -0,0 +1,56 @@ +import {BenchSuite} from "@chainsafe/benchmark-utils"; +import {aggregateSignatures, Keypair, verifyMultiple} from "../../../src"; + + +// eslint-disable-next-line @typescript-eslint/no-namespace +declare namespace global { + export let domain: Buffer; + export let messages: Buffer[]; + export let signature: Buffer; + export let publicKeys: Buffer[]; + export let keypairs: Keypair[]; + export let verify: Function; +} + +// @ts-ignore +global.require = require; + +global.domain = Buffer.alloc(8); +global.verify = verifyMultiple; + +export function verifyValidAggregatedSignature(dir: string): BenchSuite { + + global.publicKeys = []; + global.keypairs = []; + for(let i = 0; i < 128; i++) { + const keypair = Keypair.generate(); + global.keypairs.push(keypair); + global.publicKeys.push(keypair.publicKey.toBytesCompressed()); + } + + // Set the function test + const FUNCTION_NAME = "verifyValidAggregatedSignature"; // PLEASE FILL THIS OUT + + const verifyValidAggregatedSignature = function (): void { + global.verify(global.publicKeys, global.messages, global.signature, global.domain) + }; + + return { + testFunctions: [verifyValidAggregatedSignature], + setup: function() { + const sha256 = require('js-sha256'); + const {aggregateSignatures} = require("../../../src"); + const message = Buffer.from(sha256.arrayBuffer(Math.random().toString(36))); + const signatures = []; + global.messages = []; + global.keypairs.forEach((keypair) => { + signatures.push(keypair.privateKey.signMessage(message, global.domain).toBytesCompressed()); + global.messages.push(message); + }); + global.signature = aggregateSignatures(signatures); + }, + file: dir + FUNCTION_NAME + ".txt", + // profile: true, + name: FUNCTION_NAME, + }; +} \ No newline at end of file diff --git a/test/benchmarks/suites/verifyValidSignature.ts b/test/benchmarks/suites/verifyValidSignature.ts new file mode 100644 index 0000000..a57d766 --- /dev/null +++ b/test/benchmarks/suites/verifyValidSignature.ts @@ -0,0 +1,43 @@ +/* eslint-disable @typescript-eslint/no-require-imports,@typescript-eslint/no-var-requires */ + +import {BenchSuite} from "@chainsafe/benchmark-utils"; +import {verify} from "../../../src"; + + +// eslint-disable-next-line @typescript-eslint/no-namespace +declare namespace global { + export let domain: Buffer; + export let message: Buffer; + export let signature: Buffer; + export let publicKey: Buffer; + export let verify: Function; +} + +// @ts-ignore +global.require = require; + +global.domain = Buffer.alloc(8); +global.verify = verify; + +export function verifyValidSignatureBenchmark(dir: string): BenchSuite { + + // Set the function test + const FUNCTION_NAME = "verifyValidSignature"; // PLEASE FILL THIS OUT + + const verifyValidSignature = function (): void { + global.verify(global.publicKey, global.message, global.signature, global.domain); + }; + + return { + testFunctions: [verifyValidSignature], + setup: function() { + const {Keypair} = require("../../../src"); + const {sha256} = require('js-sha256'); + const keypair = Keypair.generate(); + global.publicKey = keypair.publicKey.toBytesCompressed(); + global.message = Buffer.from(sha256.arrayBuffer(Math.random().toString(36))); + global.signature = keypair.privateKey.signMessage(Buffer.from(global.message), global.domain).toBytesCompressed(); + }, + file: dir + FUNCTION_NAME + ".txt" + }; +} \ No newline at end of file diff --git a/test/spec/aggregate_pubkeys.test.ts b/test/spec/aggregate_pubkeys.test.ts index 775cb60..09a911f 100644 --- a/test/spec/aggregate_pubkeys.test.ts +++ b/test/spec/aggregate_pubkeys.test.ts @@ -1,21 +1,21 @@ import {join} from "path"; import {describeSpecTest} from "@chainsafe/eth2.0-spec-test-util"; import bls from "../../src"; -import {BLSSignature} from "../../src/types"; +import {BLSSignature} from "@chainsafe/eth2.0-types"; describeSpecTest( - join(__dirname, "./spec-tests/tests/bls/aggregate_pubkeys/aggregate_pubkeys.yaml"), - bls.aggregatePubkeys, - ({input}) => { - const sigs: BLSSignature[] = []; - input.forEach((sig: string) => { - sigs.push(Buffer.from(sig.replace('0x', ''), 'hex')) - }); - return [ - sigs - ]; - }, - ({output}) => output, - (result) => `0x${result.toString('hex')}`, - () => false, + join(__dirname, "../../../spec-test-cases/tests/bls/aggregate_pubkeys/aggregate_pubkeys.yaml"), + bls.aggregatePubkeys, + ({input}) => { + const sigs: BLSSignature[] = []; + input.forEach((sig: string) => { + sigs.push(Buffer.from(sig.replace('0x', ''), 'hex')); + }); + return [ + sigs + ]; + }, + ({output}) => output, + (result) => `0x${result.toString('hex')}`, + () => false, ); diff --git a/test/spec/aggregate_sigs.test.ts b/test/spec/aggregate_sigs.test.ts index 7abc949..4a494a2 100644 --- a/test/spec/aggregate_sigs.test.ts +++ b/test/spec/aggregate_sigs.test.ts @@ -1,22 +1,21 @@ import {join} from "path"; import {describeSpecTest} from "@chainsafe/eth2.0-spec-test-util"; import bls from "../../src"; -import {G2point} from "../../src/helpers/g2point"; import {BLSPubkey} from "../../src/types"; describeSpecTest( - join(__dirname, "./spec-tests/tests/bls/aggregate_sigs/aggregate_sigs.yaml"), - bls.aggregateSignatures, - ({input}) => { - const pubKeys: BLSPubkey[] = []; - input.forEach((pubKey: string) => { - pubKeys.push(Buffer.from(pubKey.replace('0x', ''), 'hex')) - }); - return [ - pubKeys - ]; - }, - ({output}) => output, - (result) => `0x${result.toString('hex')}`, - () => false, + join(__dirname, "../../../spec-test-cases/tests/bls/aggregate_sigs/aggregate_sigs.yaml"), + bls.aggregateSignatures, + ({input}) => { + const pubKeys: BLSPubkey[] = []; + input.forEach((pubKey: string) => { + pubKeys.push(Buffer.from(pubKey.replace('0x', ''), 'hex')); + }); + return [ + pubKeys + ]; + }, + ({output}) => output, + (result) => `0x${result.toString('hex')}`, + () => false, ); diff --git a/test/spec/g2_compressed.test.ts b/test/spec/g2_compressed.test.ts index 025d9ae..e0cf37f 100644 --- a/test/spec/g2_compressed.test.ts +++ b/test/spec/g2_compressed.test.ts @@ -4,20 +4,20 @@ import {padLeft} from "../../src/helpers/utils"; import {G2point} from "../../src/helpers/g2point"; describeSpecTest( - join(__dirname, "./spec-tests/tests/bls/msg_hash_g2_compressed/g2_compressed.yaml"), - G2point.hashToG2, - ({input}) => { - const domain = padLeft(Buffer.from(input.domain.replace('0x', ''), 'hex'), 8); - return [ - Buffer.from(input.message.replace('0x', ''), 'hex'), - domain - ]; - }, - ({output}) => { - const xReExpected = padLeft(Buffer.from(output[0].replace('0x', ''), 'hex'), 48); - const xImExpected = padLeft(Buffer.from(output[1].replace('0x', ''), 'hex'), 48); - return '0x' + Buffer.concat([xReExpected, xImExpected]).toString('hex') - }, - (result:G2point) => `0x${result.toBytesCompressed().toString('hex')}`, - () => false, + join(__dirname, "../../../spec-test-cases/tests/bls/msg_hash_g2_compressed/g2_compressed.yaml"), + G2point.hashToG2, + ({input}) => { + const domain = padLeft(Buffer.from(input.domain.replace('0x', ''), 'hex'), 8); + return [ + Buffer.from(input.message.replace('0x', ''), 'hex'), + domain + ]; + }, + ({output}) => { + const xReExpected = padLeft(Buffer.from(output[0].replace('0x', ''), 'hex'), 48); + const xImExpected = padLeft(Buffer.from(output[1].replace('0x', ''), 'hex'), 48); + return '0x' + Buffer.concat([xReExpected, xImExpected]).toString('hex'); + }, + (result: G2point) => `0x${result.toBytesCompressed().toString('hex')}`, + () => false, ); diff --git a/test/spec/g2_uncompressed.test.ts b/test/spec/g2_uncompressed.test.ts index 12896f9..ec9550b 100644 --- a/test/spec/g2_uncompressed.test.ts +++ b/test/spec/g2_uncompressed.test.ts @@ -4,25 +4,25 @@ import {padLeft} from "../../src/helpers/utils"; import {G2point} from "../../src/helpers/g2point"; describeSpecTest( - join(__dirname, "./spec-tests/tests/bls/msg_hash_g2_uncompressed/g2_uncompressed.yaml"), - G2point.hashToG2, - ({input}) => { - const domain = padLeft(Buffer.from(input.domain.replace('0x', ''), 'hex'), 8); - return [ - Buffer.from(input.message.replace('0x', ''), 'hex'), - domain - ]; - }, - ({output}) => { - return '0x' + G2point.fromUncompressedInput( - Buffer.from(output[0][0].replace('0x', ''), 'hex'), - Buffer.from(output[0][1].replace('0x', ''), 'hex'), - Buffer.from(output[1][0].replace('0x', ''), 'hex'), - Buffer.from(output[1][1].replace('0x', ''), 'hex'), - Buffer.from(output[2][0].replace('0x', ''), 'hex'), - Buffer.from(output[2][1].replace('0x', ''), 'hex'), - ).toBytesCompressed().toString('hex'); - }, - (result:G2point) => `0x${result.toBytesCompressed().toString('hex')}`, - () => false, + join(__dirname, "../../../spec-test-cases/tests/bls/msg_hash_g2_uncompressed/g2_uncompressed.yaml"), + G2point.hashToG2, + ({input}) => { + const domain = padLeft(Buffer.from(input.domain.replace('0x', ''), 'hex'), 8); + return [ + Buffer.from(input.message.replace('0x', ''), 'hex'), + domain + ]; + }, + ({output}) => { + return '0x' + G2point.fromUncompressedInput( + Buffer.from(output[0][0].replace('0x', ''), 'hex'), + Buffer.from(output[0][1].replace('0x', ''), 'hex'), + Buffer.from(output[1][0].replace('0x', ''), 'hex'), + Buffer.from(output[1][1].replace('0x', ''), 'hex'), + Buffer.from(output[2][0].replace('0x', ''), 'hex'), + Buffer.from(output[2][1].replace('0x', ''), 'hex'), + ).toBytesCompressed().toString('hex'); + }, + (result: G2point) => `0x${result.toBytesCompressed().toString('hex')}`, + () => false, ); diff --git a/test/spec/priv_to_public.test.ts b/test/spec/priv_to_public.test.ts index d193d0a..75b08f8 100644 --- a/test/spec/priv_to_public.test.ts +++ b/test/spec/priv_to_public.test.ts @@ -3,12 +3,12 @@ import {describeSpecTest} from "@chainsafe/eth2.0-spec-test-util"; import bls from "../../src"; describeSpecTest( - join(__dirname, "./spec-tests/tests/bls/priv_to_pub/priv_to_pub.yaml"), - bls.generatePublicKey, - ({input}) => { - return [Buffer.from(input.replace('0x', ''), 'hex')]; - }, - ({output}) => output, - (result) => `0x${result.toString('hex')}`, - () => false, + join(__dirname, "../../../spec-test-cases/tests/bls/priv_to_pub/priv_to_pub.yaml"), + bls.generatePublicKey, + ({input}) => { + return [Buffer.from(input.replace('0x', ''), 'hex')]; + }, + ({output}) => output, + (result) => `0x${result.toString('hex')}`, + () => false, ); diff --git a/test/spec/sign_message.test.ts b/test/spec/sign_message.test.ts index 446a6c4..1117838 100644 --- a/test/spec/sign_message.test.ts +++ b/test/spec/sign_message.test.ts @@ -4,17 +4,17 @@ import bls from "../../src"; import {padLeft} from "../../src/helpers/utils"; describeSpecTest( - join(__dirname, "./spec-tests/tests/bls/sign_msg/sign_msg.yaml"), - bls.sign, - ({input}) => { - const domain = padLeft(Buffer.from(input.domain.replace('0x', ''), 'hex'), 8); - return [ - Buffer.from(input.privkey.replace('0x', ''), 'hex'), - Buffer.from(input.message.replace('0x', ''), 'hex'), - domain - ]; - }, - ({output}) => output, - (result) => `0x${result.toString('hex')}`, - () => false, + join(__dirname, "../../../spec-test-cases/tests/bls/sign_msg/sign_msg.yaml"), + bls.sign, + ({input}) => { + const domain = padLeft(Buffer.from(input.domain.replace('0x', ''), 'hex'), 8); + return [ + Buffer.from(input.privkey.replace('0x', ''), 'hex'), + Buffer.from(input.message.replace('0x', ''), 'hex'), + domain + ]; + }, + ({output}) => output, + (result) => `0x${result.toString('hex')}`, + () => false, ); diff --git a/test/spec/spec-tests b/test/spec/spec-tests deleted file mode 160000 index 15a1d85..0000000 --- a/test/spec/spec-tests +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 15a1d85125682d3ffc09a1ee9639f46c4a1653f6 diff --git a/test/unit/index.test.ts b/test/unit/index.test.ts index a8416e4..ee819f2 100644 --- a/test/unit/index.test.ts +++ b/test/unit/index.test.ts @@ -1,6 +1,6 @@ import bls from "../../src"; import {Keypair} from "../../src/keypair"; -import { sha256 } from 'js-sha256'; +import {sha256} from 'js-sha256'; import {G2point} from "../../src/helpers/g2point"; import {expect} from "chai"; @@ -65,7 +65,7 @@ describe('test bls', function () { it('should fail verify signature of different message', () => { const keypair = Keypair.generate(); const messageHash = Buffer.from(sha256.arrayBuffer("Test message")); - const messageHash2 = Buffer.from(sha256.arrayBuffer("Test message2")) + const messageHash2 = Buffer.from(sha256.arrayBuffer("Test message2")); const domain = Buffer.from("01", 'hex'); const signature = keypair.privateKey.sign( G2point.hashToG2(messageHash, domain) @@ -117,7 +117,7 @@ describe('test bls', function () { describe('verify multiple', function() { it('should verify aggregated signatures', function () { - this.timeout(5000) + this.timeout(5000); const domain = Buffer.alloc(8, 0); @@ -162,8 +162,48 @@ describe('test bls', function () { expect(result).to.be.true; }); + it('should verify aggregated signatures - same message', function () { + this.timeout(5000); + + + const domain = Buffer.alloc(8, 0); + + const keypair1 = Keypair.generate(); + const keypair2 = Keypair.generate(); + const keypair3 = Keypair.generate(); + const keypair4 = Keypair.generate(); + + const message = Buffer.from("Test1", 'utf-8'); + + const signature1 = keypair1.privateKey.signMessage(message, domain); + const signature2 = keypair2.privateKey.signMessage(message, domain); + const signature3 = keypair3.privateKey.signMessage(message, domain); + const signature4 = keypair4.privateKey.signMessage(message, domain); + + const aggregateSignature = bls.aggregateSignatures([ + signature1.toBytesCompressed(), + signature2.toBytesCompressed(), + signature3.toBytesCompressed(), + signature4.toBytesCompressed(), + ]); + + const result = bls.verifyMultiple( + [ + keypair1.publicKey.toBytesCompressed(), + keypair2.publicKey.toBytesCompressed(), + keypair3.publicKey.toBytesCompressed(), + keypair4.publicKey.toBytesCompressed() + ], + [message, message, message, message], + aggregateSignature, + domain + ); + + expect(result).to.be.true; + }); + it('should fail to verify aggregated signatures - swapped messages', function () { - this.timeout(5000) + this.timeout(5000); const domain = Buffer.alloc(8, 0);