use super::*;
impl<N: Network> Record<N, Ciphertext<N>> {
pub fn decrypt(&self, view_key: &ViewKey<N>) -> Result<Record<N, Plaintext<N>>> {
let record_view_key = (self.nonce * **view_key).to_x_coordinate();
self.decrypt_symmetric(&record_view_key)
}
pub fn decrypt_symmetric(&self, record_view_key: &Field<N>) -> Result<Record<N, Plaintext<N>>> {
let num_randomizers = self.num_randomizers()?;
let randomizers = N::hash_many_psd8(&[N::encryption_domain(), *record_view_key], num_randomizers);
self.decrypt_with_randomizers(&randomizers)
}
fn decrypt_with_randomizers(&self, randomizers: &[Field<N>]) -> Result<Record<N, Plaintext<N>>> {
let mut index: usize = 0;
let owner = match self.owner.is_public() {
true => self.owner.decrypt_with_randomizer(&[])?,
false => self.owner.decrypt_with_randomizer(&[randomizers[index]])?,
};
if owner.is_private() {
index += 1;
}
let gates = match self.gates.is_public() {
true => self.gates.decrypt_with_randomizer(&[])?,
false => self.gates.decrypt_with_randomizer(&[randomizers[index]])?,
};
if gates.is_private() {
index += 1;
}
let mut decrypted_data = IndexMap::with_capacity(self.data.len());
for (id, entry, num_randomizers) in self.data.iter().map(|(id, entry)| (id, entry, entry.num_randomizers())) {
let num_randomizers = num_randomizers? as usize;
let randomizers = &randomizers[index..index + num_randomizers];
let entry = match entry {
Entry::Constant(plaintext) => Entry::Constant(plaintext.clone()),
Entry::Public(plaintext) => Entry::Public(plaintext.clone()),
Entry::Private(private) => Entry::Private(Plaintext::from_fields(
&private
.iter()
.zip_eq(randomizers)
.map(|(ciphertext, randomizer)| *ciphertext - randomizer)
.collect::<Vec<_>>(),
)?),
};
if decrypted_data.insert(*id, entry).is_some() {
bail!("Duplicate identifier in record: {}", id);
}
index += num_randomizers;
}
Self::from_plaintext(owner, gates, decrypted_data, self.nonce)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Literal;
use snarkvm_console_account::PrivateKey;
use snarkvm_console_network::Testnet3;
use snarkvm_console_types::Field;
type CurrentNetwork = Testnet3;
const ITERATIONS: u64 = 100;
fn check_encrypt_and_decrypt<N: Network>(
view_key: ViewKey<N>,
owner: Owner<N, Plaintext<N>>,
gates: Balance<N, Plaintext<N>>,
rng: &mut TestRng,
) -> Result<()> {
let randomizer = Scalar::rand(rng);
let record = Record {
owner,
gates,
data: IndexMap::from_iter(
vec![
(Identifier::from_str("a")?, Entry::Private(Plaintext::from(Literal::Field(Field::rand(rng))))),
(Identifier::from_str("b")?, Entry::Private(Plaintext::from(Literal::Scalar(Scalar::rand(rng))))),
]
.into_iter(),
),
nonce: N::g_scalar_multiply(&randomizer),
};
let ciphertext = record.encrypt(randomizer)?;
assert_eq!(record, ciphertext.decrypt(&view_key)?);
Ok(())
}
#[test]
fn test_encrypt_and_decrypt() -> Result<()> {
let mut rng = TestRng::default();
for _ in 0..ITERATIONS {
let private_key = PrivateKey::<CurrentNetwork>::new(&mut rng)?;
let view_key = ViewKey::try_from(&private_key)?;
let address = Address::try_from(&private_key)?;
let owner = Owner::Public(address);
let gates = Balance::Public(U64::new(u64::rand(&mut rng) >> 12));
check_encrypt_and_decrypt::<CurrentNetwork>(view_key, owner, gates, &mut rng)?;
let owner = Owner::Private(Plaintext::from(Literal::Address(address)));
let gates = Balance::Public(U64::new(u64::rand(&mut rng) >> 12));
check_encrypt_and_decrypt::<CurrentNetwork>(view_key, owner, gates, &mut rng)?;
let owner = Owner::Public(address);
let gates = Balance::Private(Plaintext::from(Literal::U64(U64::new(u64::rand(&mut rng) >> 12))));
check_encrypt_and_decrypt::<CurrentNetwork>(view_key, owner, gates, &mut rng)?;
let owner = Owner::Private(Plaintext::from(Literal::Address(address)));
let gates = Balance::Private(Plaintext::from(Literal::U64(U64::new(u64::rand(&mut rng) >> 12))));
check_encrypt_and_decrypt::<CurrentNetwork>(view_key, owner, gates, &mut rng)?;
}
Ok(())
}
}