Crates.io | blstrs |

lib.rs | blstrs |

version | 0.6.2 |

source | src |

created_at | 2020-10-08 20:20:12.180753 |

updated_at | 2023-09-05 20:16:12.495187 |

description | High performance implementation of BLS12 381 |

homepage | |

repository | https://github.com/filecoin-project/blstrs |

max_upload_size | |

id | 297385 |

size | 343,341 |

https://docs.rs/blstrs

`blstrs`

Implementation of BLS12-381 pairing-friendly elliptic curve construction, using the blst library as backend.

Most important section, the name is pronounced `blasters`

.

Due to the assembly based nature of the implementation in `blst`

, currently only the following architectures are supported

`x86_64`

,`aarch64`

.

To enable portable features when building the blst dependency, use the 'portable' feature: `--features portable`

.

```
$ cargo bench --features __private_bench
```

BLS12 curves are parameterized by a value *x* such that the base field modulus *q* and subgroup *r* can be computed by:

- q = (x - 1)
^{2}((x^{4}- x^{2}+ 1) / 3) + x - r = (x
^{4}- x^{2}+ 1)

Given primes *q* and *r* parameterized as above, we can easily construct an elliptic curve over the prime field F_{q} which contains a subgroup of order *r* such that *r* | (*q*^{12} - 1), giving it an embedding degree of 12. Instantiating its sextic twist over an extension field F_{q2} gives rise to an efficient bilinear pairing function between elements of the order *r* subgroups of either curves, into an order *r* multiplicative subgroup of F_{q12}.

In zk-SNARK schemes, we require F_{r} with large 2^{n} roots of unity for performing efficient fast-fourier transforms. As such, guaranteeing that large 2^{n} | (r - 1), or equivalently that *x* has a large 2^{n} factor, gives rise to BLS12 curves suitable for zk-SNARKs.

Due to recent research, it is estimated by many that *q* should be approximately 384 bits to target 128-bit security. Conveniently, *r* is approximately 256 bits when *q* is approximately 384 bits, making BLS12 curves ideal for 128-bit security. It also makes them ideal for many zk-SNARK applications, as the scalar field can be used for keying material such as embedded curve constructions.

Many curves match our descriptions, but we require some extra properties for efficiency purposes:

*q*should be smaller than 2^{383}, and*r*should be smaller than 2^{255}, so that the most significant bit is unset when using 64-bit or 32-bit limbs. This allows for cheap reductions.- F
_{q12}is typically constructed using towers of extension fields. As a byproduct of research for BLS curves of embedding degree 24, we can identify subfamilies of BLS12 curves (for our purposes, where x mod 72 = {16, 64}) that produce efficient extension field towers and twisting isomorphisms. - We desire
*x*of small Hamming weight, to increase the performance of the pairing function.

The BLS12-381 construction is instantiated by `x = -0xd201000000010000`

, which produces the largest `q`

and smallest Hamming weight of `x`

that meets the above requirements. This produces:

- q =
`0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab`

(381 bits) - r =
`0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001`

(255 bits)

Our extension field tower is constructed as follows:

- F
_{q2}is constructed as F_{q}(u) / (u^{2}- β) where β = -1. - F
_{q6}is constructed as F_{q2}(v) / (v^{3}- ξ) where ξ = u + 1 - F
_{q12}is constructed as F_{q6}(w) / (w^{2}- γ) where γ = v

Now, we instantiate the elliptic curve E(F_{q}) : y^{2} = x^{3} + 4, and the elliptic curve E'(F_{q2}) : y^{2} = x^{3} + 4(u + 1).

The group G_{1} is the *r* order subgroup of E, which has cofactor (x - 1)^{2} / 3. The group G_{2} is the *r* order subgroup of E', which has cofactor (x^{8} - 4x^{7} + 5x^{6} - 4x^{4} + 6x^{3} - 4x^{2} - 4x + 13) / 9.

The generators of G_{1} and G_{2} are computed by finding the lexicographically smallest valid `x`

-coordinate, and its lexicographically smallest `y`

-coordinate and scaling it by the cofactor such that the result is not the point at infinity.

```
x = 3685416753713387016781088315183077757961620795782546409894578378688607592378376318836054947676345821548104185464507
y = 1339506544944476473020471379941921221584933875938349620426543736416511423956333506472724655353366534992391756441569
```

```
x = 3059144344244213709971259814753781636986470325476647558659373206291635324768958432433509563104347017837885763365758*u + 352701069587466618187139116011060144890029952792775240219908644239793785735715026873347600343865175952761926303160
y = 927553665492332455747201965776037880757740193453592970025027978793976877002675564980949289727957565575433344219582*u + 1985150602287291935568054521177171638300868978215655730859378665066344726373823718423869104263333984641494340347905
```