mcl-wasm

What is mcl-wasm?

The mcl-wasm package is a WebAssembly (WASM) implementation of the MCL (Multiprecision Complex Library) which provides cryptographic functionalities, particularly focusing on pairing-based cryptography. It is designed to be used in web applications and Node.js environments.

What are mcl-wasm's main functionalities?

Pairing-based Cryptography

This code demonstrates the use of pairing-based cryptography with the mcl-wasm package. It initializes the BLS12-381 curve, generates random elements in the field, computes points on the elliptic curve, and then performs a pairing operation.

const mcl = require('mcl-wasm');
(async () => {
  await mcl.init(mcl.BLS12_381);
  const a = new mcl.Fr();
  a.setByCSPRNG();
  const b = new mcl.Fr();
  b.setByCSPRNG();
  const P = mcl.mul(mcl.g1(), a);
  const Q = mcl.mul(mcl.g2(), b);
  const ePQ = mcl.pairing(P, Q);
  console.log('e(P, Q) =', ePQ.getStr());
})();

Elliptic Curve Operations

This code demonstrates basic elliptic curve operations such as point addition. It initializes the BLS12-381 curve, creates points on the curve, and adds them together.

const mcl = require('mcl-wasm');
(async () => {
  await mcl.init(mcl.BLS12_381);
  const P = mcl.g1();
  const Q = mcl.g1();
  Q.setStr('1 2');
  const R = mcl.add(P, Q);
  console.log('P + Q =', R.getStr());
})();

Field Arithmetic

This code demonstrates field arithmetic operations such as addition. It initializes the BLS12-381 curve, generates random field elements, and adds them together.

const mcl = require('mcl-wasm');
(async () => {
  await mcl.init(mcl.BLS12_381);
  const a = new mcl.Fr();
  a.setByCSPRNG();
  const b = new mcl.Fr();
  b.setByCSPRNG();
  const c = mcl.add(a, b);
  console.log('a + b =', c.getStr());
})();

Other packages similar to mcl-wasm

elliptic

The elliptic package is a JavaScript library for elliptic curve cryptography. It provides a wide range of elliptic curve operations and is widely used in various cryptographic applications. Compared to mcl-wasm, elliptic does not focus on pairing-based cryptography but offers a broader range of elliptic curve algorithms.

noble-bls12-381

The noble-bls12-381 package is a JavaScript implementation of the BLS12-381 curve, which is used for pairing-based cryptography. It is similar to mcl-wasm in that it focuses on the BLS12-381 curve, but it is implemented purely in JavaScript without relying on WebAssembly.

bls-signatures

The bls-signatures package provides an implementation of BLS (Boneh-Lynn-Shacham) signatures, which are based on pairing-based cryptography. It is similar to mcl-wasm in that it focuses on BLS signatures, but it is more specialized and does not provide the broader range of cryptographic functionalities that mcl-wasm offers.

README

A portable and fast pairing-based cryptography library for Node.js by WebAssembly

Abstract

see mcl

News

• 2024/Sep/18 Add batch inversion for Fr and Fp elements, and batch normalization for G1 and G2 points.
• 2023/Sep/08 improve the performance a little
• 2023/Aug/17 improve the invMod performance
• 2023/Jun/10 add share/recover functions of Fr, G1, G2 for secret sharing.
• 2022/May/08 fix get{X,Y,Z} and get_{a,b}.
• 2021/Dec/15 rewritten by TypeScript (Thanks to asa-taka)
• 2021/Nov/11 unify index.js of Node.js and browser (Thanks to Futa HIRAKOBA)
• 2021/Aug/28 improve performance of {G1,G2}::isValidOrder()
• 2021/Jun/22 add index.d.ts
• 2021/Mar/02 improve performance
• 2020/Nov/10 setup function has changed.

How to use

The version v0.6.0 breaks backward compatibility of the entry point.

• Node.js : const mcl = require('mcl-wasm')
• React : const mcl = require('mcl-wasm')
• HTML : <script src="https://herumi.github.io/mcl-wasm/browser/mcl.js"></script>

for Node.js

node test/test.js

browser demo

ID-based encryption

usages

init

// Ethereum 2.0 spec mode
mcl.init(mcl.BLS12_381)
  .then(() => {
    mcl.setETHserialization(true) // Ethereum serialization
    mcl.setMapToMode(mcl.IRTF) // for G2.setHashOf(msg)
    ...
  })

string conversion

a = new mcl.Fr()
a.setStr('255') // set 255
a.setStr('0xff') // set 0xff = 255
a.setStr('ff', 16) // set ff as hex-string

a.getStr() // '255'
a.getStr(16) // 'ff'

serialization

// byte array serialization
b.deserialize(a.serialize()) // b.isEqualTo(a)
// hex string of serialization()
b.deserializeHexStr(a.serializeToHexStr())

// serialization like Ethereum 2.0 only for BLS12-381
mcl.setETHserialization(true)

deserialization

/*
  it is big cost to to verify the order
  call once after init() if you want to disable it
  cf. sub group problem
*/
mcl.verifyOrderG1(false)
mcl.verifyOrderG2(false)

see test.js

Secret Sharing

shareFr = (cVec: Fr[], id: Fr): Fr
shareG1 = (cVec: G1[], id: Fr): G1
shareG2 = (cVec: G2[], id: Fr): G2

Evaluate the value of the polynomial f(x) whose coefficients cVec[] are vec with x=id. Return f(id).

recoverFr = (idVec: Fr[], yVec: Fr[]): Fr
recoverG1 = (idVec: Fr[], yVec: G1[]): G1
recoverG2 = (idVec: Fr[], yVec: G2[]): G2

Recover the polynomial f(x) through the point (idVec[0], yVec[0]), (idVec[1], yVec[1]), ... and return f(0). Note that the order of arguments is reversed from that of the recover function in bls-eth-wasm.

License

modified new BSD License http://opensource.org/licenses/BSD-3-Clause

History

2019/Jan/31 add Fp.mapToG1

Author

MITSUNARI Shigeo([e-mail])

Sponsors welcome

GitHub Sponsor