sealy 0.2.0

Rust bindings for Microsoft's SEAL Fully Homomorphic Encryption (FHE) library
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

use sealy::{
	BFVEncoder, BFVEncryptionParametersBuilder, BFVEvaluator, CoefficientModulusFactory, Context,
	Decryptor, DegreeType, EncryptionParameters, Encryptor, Evaluator, KeyGenerator,
	PlainModulusFactory, SecurityLevel,
};

fn main() -> anyhow::Result<()> {
	// generate keypair to encrypt and decrypt data.
	let degree = DegreeType::D8192;
	let bit_size = 60;
	let security_level = SecurityLevel::TC128;

	let expand_mod_chain = false;
	let encryption_parameters: EncryptionParameters = BFVEncryptionParametersBuilder::new()
		.set_poly_modulus_degree(DegreeType::D8192)
		.set_coefficient_modulus(CoefficientModulusFactory::bfv(degree, security_level)?)
		.set_plain_modulus(PlainModulusFactory::batching(degree, bit_size)?)
		.build()?;

	let ctx = Context::new(&encryption_parameters, expand_mod_chain, security_level)?;

	let key_gen = KeyGenerator::new(&ctx)?;
	let encoder = BFVEncoder::new(&ctx)?;

	let public_key = key_gen.create_public_key();
	let private_key = key_gen.secret_key();

	let encryptor = Encryptor::with_public_and_secret_key(&ctx, &public_key, &private_key)?;
	let decryptor = Decryptor::new(&ctx, &private_key)?;

	let evaluator = BFVEvaluator::new(&ctx)?;

	let x = 5000001231231313;
	let y = 1000123123132131;

	let x_encoded = encoder.encode_i64(&[x])?;
	let y_encoded = encoder.encode_i64(&[y])?;

	let x_enc = encryptor.encrypt(&x_encoded)?;
	let y_enc = encryptor.encrypt(&y_encoded)?;

	let sum = evaluator.add(&x_enc, &y_enc)?;
	let sum_dec = decryptor.decrypt(&sum)?;
	let sum_dec = encoder.decode_i64(&sum_dec)?;

	let truth = x + y;
	let result = sum_dec.first().unwrap();
	assert_eq!(result, &truth);

	println!("truth: {:?}", truth);
	println!("sum: {:?}", result);

	Ok(())
}