Crates.io | sealy |
lib.rs | sealy |
version | 0.1.1 |
source | src |
created_at | 2024-06-29 23:24:05.945107 |
updated_at | 2024-07-07 13:12:47.032644 |
description | Rust bindings for Microsoft's SEAL Fully Homomorphic Encryption (FHE) library |
homepage | |
repository | https://github.com/marcosfpr/sealy |
max_upload_size | |
id | 1287686 |
size | 21,458,907 |
Microsoft SEAL bindings for Rust and Python
Microsoft SEAL bindings for Rust and Python.
SEALy is a project that aims to create FFI bindings from the famous SEAL library for Rust and Python. The main goal of this project is to provide a simple and fast way to install SEAL for both programming languages.
The SEAL bindings are a continuation from the seal_fhe crate, with the support for the CKKS scheme and the addition of new features like batch encoders, that allow us to overcome the size barriers of the ciphertext tensors and create AI applications easily with high-dimensional encrypted ciphertext.
Currently, this crate is available only for a few architectures. Please, make sure that your operating system is compatible with any build that is working:
System | Support |
---|---|
MacOSX aarch6 | |
Linux x86_64 |
Make sure your OS is supported. If it is, just type:
pip install sealy
If the OS/Platform that you use it is not in the supported list, feel free too try to clone this project and build yourself locally.
cargo add sealy
Here is a simple example of multiplying a ciphertext array to a plaintext array.
from sealy import (BFVEncoder, BfvEncryptionParametersBuilder, BFVEvaluator,
CoefficientModulus, Context, Decryptor, DegreeType,
Encryptor, KeyGenerator, PlainModulus, SecurityLevel)
params = (
BfvEncryptionParametersBuilder()
.with_poly_modulus_degree(DegreeType(8192))
.with_coefficient_modulus(
CoefficientModulus.create(DegreeType(8192), [50, 30, 30, 50, 50])
)
.with_plain_modulus(PlainModulus.batching(DegreeType(8192), 32))
.build()
)
ctx = Context(params, False, SecurityLevel(128))
gen = KeyGenerator(ctx)
encoder = BFVEncoder(ctx)
public_key = gen.create_public_key()
secret_key = gen.secret_key()
encryptor = Encryptor(ctx, public_key)
decryptor = Decryptor(ctx, secret_key)
evaluator = BFVEvaluator(ctx)
plaintext = [1, 2, 3]
factor = [2, 2, 2]
encoded_plaintext = encoder.encode(plaintext)
encoded_factor = encoder.encode(factor)
ciphertext = encryptor.encrypt(encoded_plaintext)
ciphertext_result = evaluator.multiply_plain(ciphertext, encoded_factor)
decrypted = decryptor.decrypt(ciphertext_result)
decoded = encoder.decode(decrypted)
print(decoded[:3]) # [2, 4, 6]
Equivalent code from above's example, written in rust:
use sealy::{
BFVEncoder, BFVEvaluator, BfvEncryptionParametersBuilder, CoefficientModulus, Context,
Decryptor, DegreeType, Encoder, Encryptor, Evaluator, KeyGenerator, PlainModulus,
SecurityLevel,
};
fn main() -> anyhow::Result<()> {
let params = BfvEncryptionParametersBuilder::new()
.set_poly_modulus_degree(DegreeType::D8192)
.set_coefficient_modulus(
CoefficientModulus::create(DegreeType::D8192, &[50, 30, 30, 50, 50]).unwrap(),
)
.set_plain_modulus(PlainModulus::batching(DegreeType::D8192, 32)?)
.build()?;
let ctx = Context::new(¶ms, false, SecurityLevel::TC128)?;
let gen = KeyGenerator::new(&ctx)?;
let encoder = BFVEncoder::new(&ctx)?;
let public_key = gen.create_public_key();
let secret_key = gen.secret_key();
let encryptor = Encryptor::with_public_key(&ctx, &public_key)?;
let decryptor = Decryptor::new(&ctx, &secret_key)?;
let evaluator = BFVEvaluator::new(&ctx)?;
let plaintext: Vec<i64> = vec![1, 2, 3];
let factor = vec![2, 2, 2];
let encoded_plaintext = encoder.encode(&plaintext)?;
let encoded_factor = encoder.encode(&factor)?;
let ciphertext = encryptor.encrypt(&encoded_plaintext)?;
let ciphertext_result = evaluator.multiply_plain(&ciphertext, &encoded_factor)?;
let decrypted = decryptor.decrypt(&ciphertext_result)?;
let decoded = encoder.decode(&decrypted);
println!("{:?}", &decoded.into_iter().take(3).collect::<Vec<_>>()); // [2, 4, 6]
Ok(())
}
The project is in the early stages of development.
See the open issues for a list of issues and proposed features.
OBS: To propose new features or report bugs, check out the correct templates.
Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are greatly appreciated.
git checkout -b feature/AmazingFeature
)git commit -m 'Add some AmazingFeature'
)git push origin feature/AmazingFeature
)