Ethereum: Implementing BLS Verification using the precompile altbn_128 contract

I can provide an article on implementing BLSC (Blind Signatures using the NIST Curve) verification using the alt_bn128 precompile contract.

Implementing BLS Verification Using the alt_bn128 Precompile Contract

Blind signatures (BSs) are a type of cryptographic primitive that enables secure and anonymous communication. In this article, we will explore how to implement BS verification using the alt_bn128 precompile contract on Ethereum.

What is BLSC?

Before diving into the implementation, let’s quickly review what BLSC is. BSs are based on the NIST Curve (BNP), which consists of three components:

• Signature: The signer uses the private key to compute a signature.

• Verification

  : The verifier uses the public key and the signed message to verify the authenticity and integrity of the data.

• Encryption: Encrypted data is protected by a shared secret.

Alt_bn128 Contract Overview

The alt_bn128 precompile contract is an implementation of BNP (NIST Curve) using the 256-bit NIST Curve security parameter. It provides a set of functions for signing, verifying, and encrypting messages.

Here is a high-level overview of the contract:

• sign(): Signing function that computes a signature from a private key.

• verify(): Verification function that verifies a message signed with a public key.

• encrypt() (not implemented): Encryption function that protects an encrypted message with a shared secret.

• decompress() (not implemented): Decryption function that unprotects an encrypted message.

Implementing BLS Verification using the Precompilation Contract alt_bn128

To implement BLSC verification, we need to provide a way for the verifier to communicate with the signer and compute the signature. Here is an example implementation:

pragma solidity ^0.8.0;
contract BLSVerifier {
// Precompilation contract functions
function verify(
uint256[2] memory signature,
uint256[4] memory pubkey,
uint256[2] memory message) public view returns (bool, bytes memory) {
// Compute the signature using the public key and the signed message
address signerAddress = payable(msg.sender);
bytes32 messageHash = keccak256(abi.encodePacked(message));
bytes32 signatureHash = keccak256(abi.encodePacked(signature));
uint256 signatureLength = 64;
bytes memory signature = abi.encodePacked(messageHash, signatureHash, uint160(signatureLength));
// Sign the signed message using the private key
bytes32 signatureHash2 = keccak256(abi.encodePacked(signerAddress, signature));
bytes memory sig = abi.encodePacked(signatureHash, signatureHash2);
// Verify the signature using the public key and the signed message
address verifierAddress = payable(msg.sender);
bytes32 verifierMessageHash = keccak256(abi.encodePacked(message));
bytes32 verifierSigHash = keccak256(abi.encodePacked(verifierMessageHash, sig));
uint256 verifierSigLength = 64;
bytes memory verifierSig = abi.encodePacked(verifierMessageHash, verifierSigHash, uint160(verifierSigLength));
// Return the verification result
return (verify(verifierSig), abi.encodePacked(verifierSig));
}
}

In this example implementation:

• We first compute the signature using the public key and the signed message.

• We then sign the signed message using the private key of the signer’s address.

• We verify the signature using the public key and the signed message, again using the verifier’s address.

• The verify function returns a boolean value indicating whether the verification was successful (i.e. true) or false (i.e. false).