vhe 0.1.1

ElGamal homomorphic encryption library with verifiable operations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313

//! Integration tests for the ElGamal library

use num_bigint::ToBigUint;
use vhe::{
    Ciphertext, ElGamal, HomomorphicMode, HomomorphicOperations, KeyPair, VerifiableOperations,
};

#[test]
fn test_end_to_end_multiplicative_workflow() {
    // Generate keys using faster method for testing
    let keypair = KeyPair::generate_for_testing(512).expect("Failed to generate keys");
    let elgamal = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Multiplicative);

    // Encrypt multiple values
    let values = vec![2u32, 3u32, 5u32, 7u32];
    let ciphertexts: Vec<Ciphertext> = values
        .iter()
        .map(|v| elgamal.encrypt(&v.to_biguint().unwrap()).unwrap())
        .collect();

    // Perform batch multiplication
    let product_ct = elgamal.homomorphic_batch_operation(&ciphertexts).unwrap();

    // Decrypt result
    let decrypted = elgamal.decrypt(&product_ct, &keypair.private_key).unwrap();

    // Verify result
    let expected = 2u32 * 3 * 5 * 7;
    assert_eq!(decrypted, expected.to_biguint().unwrap());
}

#[test]
fn test_end_to_end_additive_workflow() {
    // Generate keys using faster method for testing
    let keypair = KeyPair::generate_for_testing(512).expect("Failed to generate keys");
    let elgamal = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Additive);

    // Test addition
    let a = 100u32.to_biguint().unwrap();
    let b = 200u32.to_biguint().unwrap();

    let ct_a = elgamal.encrypt(&a).unwrap();
    let ct_b = elgamal.encrypt(&b).unwrap();

    let ct_sum = elgamal.homomorphic_operation(&ct_a, &ct_b).unwrap();
    let sum = elgamal.decrypt(&ct_sum, &keypair.private_key).unwrap();

    assert_eq!(sum, 300u32.to_biguint().unwrap());

    // Test subtraction
    let ct_diff = elgamal.homomorphic_subtract(&ct_b, &ct_a).unwrap();
    let diff = elgamal.decrypt(&ct_diff, &keypair.private_key).unwrap();

    assert_eq!(diff, 100u32.to_biguint().unwrap());

    // Test scalar multiplication
    let scalar = 5u32.to_biguint().unwrap();
    let ct_scaled = elgamal
        .homomorphic_scalar_operation(&ct_a, &scalar)
        .unwrap();
    let scaled = elgamal.decrypt(&ct_scaled, &keypair.private_key).unwrap();

    assert_eq!(scaled, 500u32.to_biguint().unwrap());
}

#[test]
fn test_linear_combination() {
    let keypair = KeyPair::generate_for_testing(512).unwrap();
    let elgamal = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Additive);

    // Create encrypted values
    let values = vec![10u32, 20u32, 30u32];
    let coefficients = vec![2u32, 3u32, 4u32];

    let ciphertexts: Vec<_> = values
        .iter()
        .map(|v| elgamal.encrypt(&v.to_biguint().unwrap()).unwrap())
        .collect();

    let coeff_biguints: Vec<_> = coefficients
        .iter()
        .map(|c| c.to_biguint().unwrap())
        .collect();

    // Compute linear combination: 2*10 + 3*20 + 4*30 = 200
    let result_ct = elgamal
        .homomorphic_linear_combination(&ciphertexts, &coeff_biguints)
        .unwrap();
    let result = elgamal.decrypt(&result_ct, &keypair.private_key).unwrap();

    assert_eq!(result, 200u32.to_biguint().unwrap());
}

#[test]
fn test_verifiable_operations_workflow() {
    let keypair = KeyPair::generate_for_testing(512).unwrap();
    let elgamal = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Additive);

    // Encrypt with proof
    let value = 42u32.to_biguint().unwrap();
    let (ct, proof) = elgamal.encrypt_with_proof(&value, None).unwrap();

    // Verify proof
    assert!(elgamal.verify_encryption_proof(&ct, &value, &proof));

    // Verify with wrong value should fail
    let wrong_value = 43u32.to_biguint().unwrap();
    assert!(!elgamal.verify_encryption_proof(&ct, &wrong_value, &proof));

    // Perform operation with proof
    let value2 = 58u32.to_biguint().unwrap();
    let ct2 = elgamal.encrypt(&value2).unwrap();

    let (result_ct, op_proof) = elgamal.homomorphic_operation_with_proof(&ct, &ct2).unwrap();

    // Verify operation proof
    assert!(elgamal.verify_operation_proof(&ct, &ct2, &result_ct, &op_proof));

    // Verify result
    let result = elgamal.decrypt(&result_ct, &keypair.private_key).unwrap();
    assert_eq!(result, 100u32.to_biguint().unwrap());
}

#[test]
fn test_rerandomization_preserves_plaintext() {
    let keypair = KeyPair::generate_for_testing(512).unwrap();

    for mode in [HomomorphicMode::Multiplicative, HomomorphicMode::Additive] {
        let elgamal = ElGamal::new(keypair.public_key.clone(), mode.clone());
        let plaintext = 999u32.to_biguint().unwrap();

        // Encrypt
        let original = elgamal.encrypt(&plaintext).unwrap();

        // Re-randomize multiple times
        let mut current = original.clone();
        for _ in 0..10 {
            current = elgamal.rerandomize(&current).unwrap();

            // Verify it still decrypts to the same value
            let decrypted = elgamal.decrypt(&current, &keypair.private_key).unwrap();
            assert_eq!(decrypted, plaintext);
        }

        // Verify ciphertext changed
        assert_ne!(original, current);
    }
}

#[test]
fn test_proof_of_knowledge() {
    let keypair = KeyPair::generate_for_testing(512).unwrap();
    let elgamal = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Multiplicative);

    // Prove knowledge of private key
    let proof = elgamal.prove_knowledge_of_dlog(
        keypair.private_key.secret_exponent(),
        keypair.public_key.generator(),
        keypair.public_key.public_component(),
    );

    // Verify proof
    assert!(elgamal.verify_knowledge_of_dlog(
        &proof,
        keypair.public_key.generator(),
        keypair.public_key.public_component()
    ));
}

#[test]
fn test_division_in_multiplicative_mode() {
    let keypair = KeyPair::generate_for_testing(512).unwrap();
    let elgamal = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Multiplicative);

    let a = 84u32.to_biguint().unwrap();
    let b = 12u32.to_biguint().unwrap();

    let ct_a = elgamal.encrypt(&a).unwrap();
    let ct_b = elgamal.encrypt(&b).unwrap();

    let ct_quotient = elgamal.homomorphic_divide(&ct_a, &ct_b).unwrap();
    let decrypted = elgamal.decrypt(&ct_quotient, &keypair.private_key).unwrap();

    // In modular arithmetic, division is multiplication by inverse
    let b_inv = vhe::utils::mod_inverse(&b, keypair.public_key.modulus()).unwrap();
    let expected = (a * b_inv) % keypair.public_key.modulus();

    assert_eq!(decrypted, expected);
}

#[test]
fn test_key_validation() {
    use vhe::PublicKey;

    // Valid key should pass
    let keypair = KeyPair::generate_for_testing(512).unwrap();
    assert!(keypair.public_key.validate().is_ok());

    // Invalid keys should fail
    let invalid_key = PublicKey::new(
        2u32.to_biguint().unwrap(),
        1u32.to_biguint().unwrap(),
        1u32.to_biguint().unwrap(),
    );
    assert!(invalid_key.validate().is_err());
}

#[test]
fn test_mode_mismatch_prevention() {
    let keypair = KeyPair::generate_for_testing(512).unwrap();

    let elgamal_mult = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Multiplicative);

    let elgamal_add = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Additive);

    // Encrypt in multiplicative mode
    let value = 42u32.to_biguint().unwrap();
    let ct_mult = elgamal_mult.encrypt(&value).unwrap();

    // Try to decrypt with additive mode (should fail)
    assert!(elgamal_add.decrypt(&ct_mult, &keypair.private_key).is_err());

    // Try homomorphic operation with mixed modes (should fail)
    let ct_add = elgamal_add.encrypt(&value).unwrap();
    assert!(elgamal_mult
        .homomorphic_operation(&ct_mult, &ct_add)
        .is_err());
}

#[test]
fn test_large_scale_operations() {
    let keypair = KeyPair::generate_for_testing(512).unwrap();
    let elgamal = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Additive);

    // Encrypt and sum 100 values
    let values: Vec<_> = (1..=100).collect();
    let ciphertexts: Vec<_> = values
        .iter()
        .map(|v| elgamal.encrypt(&v.to_biguint().unwrap()).unwrap())
        .collect();

    let sum_ct = elgamal.homomorphic_batch_operation(&ciphertexts).unwrap();
    let sum = elgamal.decrypt(&sum_ct, &keypair.private_key).unwrap();

    // Sum of 1 to 100 = 5050
    assert_eq!(sum, 5050u32.to_biguint().unwrap());
}

#[test]
fn test_verifiable_rerandomization() {
    let keypair = KeyPair::generate_for_testing(512).unwrap();
    let elgamal = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Multiplicative);

    let plaintext = 123u32.to_biguint().unwrap();
    let original = elgamal.encrypt(&plaintext).unwrap();

    // Re-randomize with proof
    let (rerandomized, proof) = elgamal.rerandomize_with_proof(&original).unwrap();

    // Verify proof
    assert!(elgamal.verify_rerandomization_proof(&original, &rerandomized, &proof));

    // Verify both decrypt to same value
    let dec1 = elgamal.decrypt(&original, &keypair.private_key).unwrap();
    let dec2 = elgamal
        .decrypt(&rerandomized, &keypair.private_key)
        .unwrap();
    assert_eq!(dec1, dec2);
    assert_eq!(dec1, plaintext);
}

#[test]
fn test_error_handling() {
    use vhe::ElGamalError;

    let keypair = KeyPair::generate_for_testing(512).unwrap();
    let elgamal = ElGamal::new(keypair.public_key.clone(), HomomorphicMode::Additive);

    // Test plaintext too large for additive mode
    let large_value = 10_000_000u32.to_biguint().unwrap();
    match elgamal.encrypt(&large_value) {
        Err(ElGamalError::PlaintextTooLargeForAdditive { .. }) => (),
        _ => panic!("Expected PlaintextTooLargeForAdditive error"),
    }

    // Test empty batch operation
    let empty_cts: Vec<Ciphertext> = vec![];
    match elgamal.homomorphic_batch_operation(&empty_cts) {
        Err(ElGamalError::EmptyBatch) => (),
        _ => panic!("Expected EmptyBatch error"),
    }
}

#[test]
fn test_safe_prime_generation() {
    // Test that safe prime generation works (using lenient generation for 512-bit)
    let keypair = KeyPair::load_or_generate(512);
    assert!(
        keypair.is_ok(),
        "Safe prime generation should work with lenient mode"
    );

    let keypair = keypair.unwrap();
    assert!(keypair.public_key.validate().is_ok());

    // Check that the bit size is within acceptable range (504-520 bits)
    let bit_size = keypair.public_key.bit_size();
    assert!(
        bit_size >= 504 && bit_size <= 520,
        "Bit size should be near 512, got {}",
        bit_size
    );
}