Add RSA and Schnorr Examples

.github/workflows/criterion_benchs.yml

@@ -13,7 +13,7 @@ permissions:
 jobs:
   criterion_bench:
     name: Criterion benches (Ubuntu)
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     env:
       CARGO_TERM_COLOR: always
     steps:

.github/workflows/iai_benchs_main.yml

@@ -7,7 +7,7 @@ on:
 jobs:
   cache_iai_benchs:
     name: Cache iai benchs of main
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
     - name: Install valgrind
       run: |

.github/workflows/iai_benchs_pr.yml

@@ -11,7 +11,7 @@ concurrency:
 jobs:
   fetch_iai_benchs:
     name: Fetch iai benchmarks
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
     - name: Check cache
       id: cache-iai-results
@@ -53,7 +53,7 @@ jobs:
   run_iai_benchs:
     name: Run iai benchmarks
     needs: fetch_iai_benchs
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
     - name: Install valgrind
       run: |

Cargo.toml

@@ -18,6 +18,9 @@ members = [
     "examples/pinocchio",
     "examples/prove-verify-circom",
     "examples/baby-snark",
+    "examples/schnorr-signature",
+    "examples/rsa",
+
 ]
 exclude = ["ensure-no_std"]
 resolver = "2"

crates/provers/groth16/src/common.rs

@@ -26,7 +26,7 @@ pub type PairingOutput = FieldElement<<Pairing as IsPairing>::OutputField>;
 pub const ORDER_R_MINUS_1_ROOT_UNITY: FrElement = FrElement::from_hex_unchecked("7");
 
 pub fn sample_fr_elem() -> FrElement {
-    let mut rng = rand_chacha::ChaCha20Rng::seed_from_u64(9001);
+    let mut rng = rand_chacha::ChaCha20Rng::from_entropy();
     FrElement::new(U256 {
         limbs: [
             rng.gen::<u64>(),

crates/provers/groth16/src/setup.rs

@@ -47,6 +47,8 @@ struct ToxicWaste {
 }
 
 impl ToxicWaste {
+    /// This will create a new random ToxicWaste from entropy. Bear in mind this is not safe to use.
+    /// A proper ceremony, like Powers of Tau should be used in production to get the randomness.
     pub fn new() -> Self {
         Self {
             tau: sample_fr_elem(),

examples/rsa/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rsa"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[features]
+default = ["alloc"]
+alloc = ["lambdaworks-math/alloc"]
+
+[dependencies]
+num-bigint = "0.4"
+num-traits = "0.2"
+num-integer = "0.1"
+rand = "0.8"
+lambdaworks-math = { workspace = true, features = ["alloc"] }
+hex = "0.4"

examples/rsa/README.md

@@ -0,0 +1,90 @@
+# RSA Implementation
+
+This is an implementation of the RSA cryptographic algorithm in Rust. RSA is one of the first public-key cryptosystems widely used for secure data transmission.
+
+
+## ⚠️ Disclaimer
+
+This implementation is not cryptographically secure due to non-constant time operations and other considerations, so it must not be used in production. It is intended to be just an educational example.
+
+## Overview
+
+RSA is an asymmetric cryptographic algorithm that uses a pair of keys:
+- **Public key**: Used for encryption and is shared openly
+- **Private key**: Used for decryption and must be kept secret
+
+The security of RSA relies on the practical difficulty of factoring the product of two large prime numbers.
+
+## Mathematical Background
+
+### Key Generation
+
+1. Choose two distinct prime numbers $p$ and $q$ (these should be randomly generated, should be sufficiently large, and their magnitudes should not be similar)
+2. Compute $n = p \cdot q$
+3. Calculate Euler's totient function: $\phi(n) = (p-1) \cdot (q-1)$
+4. Choose an integer $e$ such that $1 < e < \phi(n)$ and $\gcd(e, \phi(n)) = 1$
+5. Compute $d$ such that $d \cdot e \equiv 1 \pmod{\phi(n)}$
+
+The public key is $(e, n)$, and the private key is $d$. In practice, $e$ is chosen as a number with low Hamming weight (such as Fermat primes) and $d$ is computed by finding the inverse.
+
+### Encryption and Decryption
+
+- **Encryption**: $c = m^e \pmod{n}$ where $m$ is the message and $c$ is the ciphertext
+- **Decryption**: $m = c^d \pmod{n}$
+
+### PKCS#1 v1.5 Padding
+
+For secure encryption of arbitrary byte data, we implement PKCS#1 v1.5 padding:
+
+```
+00 || 02 || PS || 00 || M
+```
+
+Where:
+- `00`: First byte (block type)
+- `02`: Second byte (block type for encryption)
+- `PS`: Padding string of non-zero random bytes
+- `00`: Separator
+- `M`: Original message
+
+### Basic  Example
+
+```rust
+use rsa::RSA;
+use lambdaworks_math::unsigned_integer::element::UnsignedInteger;
+
+// Create an RSA instance with primes that ensure e < φ(n)
+let p = UnsignedInteger::<16>::from_u64(65539);
+let q = UnsignedInteger::<16>::from_u64(65521);
+let rsa = RSA::<16>::new(p, q)?;
+
+// Encrypt and decrypt a numeric message
+let message = UnsignedInteger::<16>::from_u64(42);
+let ciphertext = rsa.encrypt(&message)?;
+let decrypted = rsa.decrypt(&ciphertext)?;
+
+assert_eq!(message, decrypted);
+```
+
+### Byte Data with Padding
+
+```rust
+use rsa::RSA;
+use lambdaworks_math::unsigned_integer::element::UnsignedInteger;
+
+// Create an RSA instance with primes that ensure e < φ(n)
+let p = UnsignedInteger::<16>::from_u64(65539);
+let q = UnsignedInteger::<16>::from_u64(65521);
+let rsa = RSA::<16>::new(p, q)?;
+
+// Encrypt and decrypt byte data using PKCS#1 v1.5 padding
+let msg_bytes = b"Hello RSA with padding!";
+let cipher_bytes = rsa.encrypt_bytes_pkcs1(msg_bytes)?;
+let plain_bytes = rsa.decrypt_bytes_pkcs1(&cipher_bytes)?;
+
+assert_eq!(msg_bytes.to_vec(), plain_bytes);
+```
+
+---
+
+**Note**: This implementation is for educational purposes. Production systems should use established cryptographic libraries that have undergone security audits.

examples/rsa/src/lib.rs

@@ -0,0 +1,3 @@
+mod rsa;
+
+pub use rsa::{RSAError, RSA};