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
//! Abstract operations exposed by the library. /// Marker trait for the Paillier scheme. pub trait AbstractScheme { /// Underlying arbitrary precision arithmetic type. type BigInteger; } /// Secure generation of fresh key pairs. pub trait KeyGeneration<EK, DK> { /// Generate fresh key pair with currently recommended security level (2048 bit modulus). fn keypair() -> (EK, DK) { Self::keypair_with_modulus_size(2048) } /// Generate fresh key pair with security level specified as the `bit_length` of the modulus. /// /// Currently recommended security level is a minimum of 2048 bits. fn keypair_with_modulus_size(big_length: usize) -> (EK, DK); } /// Marker trait for encryption keys. pub trait EncryptionKey {} /// Marker trait for decryption keys. pub trait DecryptionKey {} /// Encryption of plaintext. pub trait Encryption<EK, PT, CT> { /// Encrypt plaintext `m` under key `ek` into a ciphertext. fn encrypt(ek: &EK, m: &PT) -> CT; } /// Decryption of ciphertext. pub trait Decryption<DK, CT, PT> { /// Decrypt ciphertext `c` using key `dk` into a plaintext. fn decrypt(ek: &DK, c: &CT) -> PT; } /// Addition of two ciphertexts. pub trait Addition<EK, CT1, CT2, CT> { /// Homomorphically combine ciphertexts `c1` and `c2` to obtain a ciphertext containing /// the sum of the two underlying plaintexts, reduced modulus `n` from `ek`. fn add(ek: &EK, c1: &CT1, c2: &CT2) -> CT; } /// Multiplication of ciphertext with plaintext. pub trait Multiplication<EK, CT1, PT2, CT> { /// Homomorphically combine ciphertext `c1` and plaintext `m2` to obtain a ciphertext /// containing the multiplication of the (underlying) plaintexts, reduced modulus `n` from `ek`. fn mul(ek: &EK, c1: &CT1, m2: &PT2) -> CT; } /// Rerandomisation of ciphertext. pub trait Rerandomisation<EK, CT> { /// Rerandomise ciphertext `c` to hide any history of which homomorphic operations were /// used to compute it, making it look exactly like a fresh encryption of the same plaintext. fn rerandomise(ek: &EK, c: &CT) -> CT; } /// Marker trait to avoid conflicting implementations. // Future support for negative traits could void this. pub trait EncodableType {} // Heuristics for what constitutes an encodable type: // impl<T: Into<u64>> EncodableType for T {} impl<T: Into<u64>> EncodableType for Vec<T> {} // impl EncodableType for usize {} // impl EncodableType for u8 {} // impl EncodableType for u16 {} // impl EncodableType for u32 {} impl EncodableType for u64 {} /// Encoding into plaintexts. pub trait Encoder<T> { type Target; /// Encode `T` types into `Target` types. fn encode(&self, x: &T) -> Self::Target; } /// Decoding from plaintexts. pub trait Decoder<T> { type Source; /// Decode `Source` types into `T` types. fn decode(&self, y: &Self::Source) -> T; }