RELIC Cryptographic Meta-Toolkit

RELIC provides a wide range of cryptographic primitives and protocols, including:

Arithmetic

• Multiple-precision integer arithmetic
• Prime and Binary field arithmetic
• Elliptic curves over prime and binary fields (NIST curves and pairing-friendly curves)
• Bilinear maps and related extension fields

Protocols

• Standard Protocols: RSA, Rabin, ECDSA, ECMQV, ECSS (Schnorr), ECIES, Sakai-Ohgishi-Kasahara ID-based authenticated key agreement, Boneh-Lynn-Schacham (BLS), Boneh-Boyen short signatures, Paillier and Benaloh homomorphic encryption systems.
• Pairing Delegation:
  • Pairing delegation protocols (with public and private inputs).
  • Batch pairing delegation protocols (with public inputs).

Detailed instructions for building the RELIC library are maintained in the project Wiki.

For users working with pairing delegation protocols:

• To verify implementations, check the output of the test_cp testing binary.
• To evaluate performance, check the output of the bench_cp benchmarking binary.
• In bench_cp output, sequential versions are prefixed with cp_amore_* (1) and batch versions are prefixed with cp_amore_* (AGGS).
• You can adjust the number of pairings in the batch version by modifying the AGGS parameter directly in the source code.

Before performing any cryptographic operations, you must initialize the RELIC core using core_init(). This function returns RLC_OK on success or an error code on failure. When finished with the library, call core_clean() to release global resources. Failure to initialize the core will result in errors during subsequent API calls.

if (core_init() != RLC_OK) {
    // Handle error
    return 1;
}

// ... perform cryptographic operations ...

core_clean();

Use pc_param_set_any() to set the public parameters for the cryptographic operations. This is a required step after core_init() and before performing cryptographic tasks like key generation or signing.

if (pc_param_set_any() != RLC_OK) {
    core_clean();
    return 1;
}

⚠️ WARNING

RELIC is considered alpha-quality software.

• Correctness & Security: Implementations may not be correct or secure and may include patented algorithms.
• Configuration Risk: There are many configuration options that can make the library insecure.
• Side-Channels: Side-channel and fault injection attacks are generally not considered unless explicitly noted.
• API Stability: Backward API compatibility with early versions is not guaranteed.

Use at your own risk.

RELIC is dual-licensed under Apache 2.0 and LGPL 2.1-or-above. Users may choose either license for their use case.

SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1

Note on derived works: Since version 0.3.3, static linking and changes made to the configuration or build system are explicitly exempted from being classified as derived works. Refer to the individual LICENSE files for full legal details.

The cp_mklhs_ver function performs a full verification of an authenticated computation. It checks the signature sig against the computed result res, the secret key/parameters t, the database, region acronyms, labels, function values, and public keys.

// Returns true if the signature is valid for the computation
bool isValid = cp_mklhs_ver(sig, res, t, DATABASE, acs, labels, f, flen, pk, num_states);

To generate a key pair for a signer, use cp_mklhs_gen. This function takes a secret key (sk) and populates a public key (pk).

// sk is the secret key, pk is the public key
cp_mklhs_gen(sk, pk);

For optimized verification, cp_mklhs_onv can be used when precomputed values cs are available. This is typically faster than a standard verification.

// Verifies using precomputed values cs
bool isValid = cp_mklhs_onv(sig, res, t, DATABASE, acs, cs, ft, pk, num_states);

In authenticated computation scenarios, cp_mklhs_fun can be used to compute a value t based on a set of messages m and a function f (represented as an array of values).

// t is the result, m is the messages, f is the function values
cp_mklhs_fun(t, m, f, length);

To use a specific curve (such as Tweedledum), use ec_param_set_any(). This function configures the global elliptic curve context. If it returns RLC_ERR, the curve could not be set.

if (ec_param_set_any() == RLC_ERR) {
    // Handle error
}