rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #654 from triska/aad

Browse Source 
ADDED: library(crypto): Support for additional authenticated data (AAD).
This commit is contained in:
Mark Thom
2020-08-06 02:40:51 -03:00
committed by GitHub
parent f627b32355 2d3f1e51ec
commit 10ba6fb773
3 changed files with 79 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
src/machine/system_calls.rs
View File

@@ -5394,7 +5394,8 @@ impl MachineState {
self.unify(arg, byte);
}
&SystemClauseType::CryptoDataHash => {
let bytes = self.string_encoding_bytes(1, 2);
let encoding = self.atom_argument_to_string(2);
let bytes = self.string_encoding_bytes(1, &encoding);
let algorithm_str = match self.store(self.deref(self[temp_v!(4)])) {
Addr::Con(h) if self.heap.atom_at(h) => {
@@ -5448,7 +5449,8 @@ impl MachineState {
self.unify(self[temp_v!(3)], ints_list);
}
&SystemClauseType::CryptoDataHKDF => {
let data = self.string_encoding_bytes(1, 2);
let encoding = self.atom_argument_to_string(2);
let data = self.string_encoding_bytes(1, &encoding);
let stub1 = MachineError::functor_stub(clause_name!("crypto_data_hkdf"), 4);
let salt = self.integers_to_bytevec(temp_v!(3), stub1);
let stub2 = MachineError::functor_stub(clause_name!("crypto_data_hkdf"), 4);
@@ -5541,11 +5543,13 @@ impl MachineState {
self.unify(self[temp_v!(4)], ints_list);
}
&SystemClauseType::CryptoDataEncrypt => {
let data = self.string_encoding_bytes(1, 2);
let stub2 = MachineError::functor_stub(clause_name!("crypto_data_encrypt"), 6);
let key = self.integers_to_bytevec(temp_v!(3), stub2);
let stub3 = MachineError::functor_stub(clause_name!("crypto_data_encrypt"), 6);
let iv = self.integers_to_bytevec(temp_v!(4), stub3);
let encoding = self.atom_argument_to_string(3);
let data = self.string_encoding_bytes(1, &encoding);
let aad = self.string_encoding_bytes(2, &encoding);
let stub2 = MachineError::functor_stub(clause_name!("crypto_data_encrypt"), 7);
let key = self.integers_to_bytevec(temp_v!(4), stub2);
let stub3 = MachineError::functor_stub(clause_name!("crypto_data_encrypt"), 7);
let iv = self.integers_to_bytevec(temp_v!(5), stub3);
let unbound_key = aead::UnboundKey::new(&aead::CHACHA20_POLY1305, &key).unwrap();
let nonce = aead::Nonce::try_assume_unique_for_key(&iv).unwrap();
@@ -5553,7 +5557,7 @@ impl MachineState {
let mut in_out = data.clone();
let tag =
match key.seal_in_place_separate_tag(nonce, aead::Aad::empty(), &mut in_out) {
match key.seal_in_place_separate_tag(nonce, aead::Aad::from(aad), &mut in_out) {
Ok(d) => { d }
_ => { self.fail = true; return Ok(()); }
};
@@ -5566,29 +5570,18 @@ impl MachineState {
self.heap.put_complete_string(&buffer)
};
self.unify(self[temp_v!(5)], tag_list);
self.unify(self[temp_v!(6)], complete_string);
self.unify(self[temp_v!(6)], tag_list);
self.unify(self[temp_v!(7)], complete_string);
}
&SystemClauseType::CryptoDataDecrypt => {
let data = self.string_encoding_bytes(1, 2);
let stub1 = MachineError::functor_stub(clause_name!("crypto_data_decrypt"), 6);
let data = self.string_encoding_bytes(1, "octet");
let encoding = self.atom_argument_to_string(5);
let aad = self.string_encoding_bytes(2, &encoding);
let stub1 = MachineError::functor_stub(clause_name!("crypto_data_decrypt"), 7);
let key = self.integers_to_bytevec(temp_v!(3), stub1);
let stub2 = MachineError::functor_stub(clause_name!("crypto_data_decrypt"), 6);
let stub2 = MachineError::functor_stub(clause_name!("crypto_data_decrypt"), 7);
let iv = self.integers_to_bytevec(temp_v!(4), stub2);
let encoding = match self.store(self.deref(self[temp_v!(5)])) {
Addr::Con(h) if self.heap.atom_at(h) => {
if let HeapCellValue::Atom(ref atom, _) = &self.heap[h] {
atom.as_str()
} else {
unreachable!()
}
}
_ => {
unreachable!()
}
};
let unbound_key = aead::UnboundKey::new(&aead::CHACHA20_POLY1305, &key).unwrap();
let nonce = aead::Nonce::try_assume_unique_for_key(&iv).unwrap();
let key = aead::LessSafeKey::new(unbound_key);
@@ -5597,12 +5590,12 @@ impl MachineState {
let complete_string = {
let decrypted_data =
match key.open_in_place(nonce, aead::Aad::empty(), &mut in_out) {
match key.open_in_place(nonce, aead::Aad::from(aad), &mut in_out) {
Ok(d) => { d }
_ => { self.fail = true; return Ok(()); }
};
let buffer = match encoding {
let buffer = match encoding.as_str() {
"octet" => { String::from_iter(decrypted_data.iter().map(|b| *b as char)) }
"utf8" => { match String::from_utf8(decrypted_data.to_vec()) {
Ok(str) => { str }
@@ -5676,7 +5669,7 @@ impl MachineState {
self.unify(self[temp_v!(1)], complete_string);
}
&SystemClauseType::Ed25519KeyPairPublicKey => {
let bytes = self.string_encoding_bytes(1, 2);
let bytes = self.string_encoding_bytes(1, "octet");
let key_pair = match signature::Ed25519KeyPair::from_pkcs8(&bytes) {
Ok(kp) => { kp }
@@ -5688,11 +5681,12 @@ impl MachineState {
self.heap.put_complete_string(&buffer)
};
self.unify(self[temp_v!(3)], complete_string);
self.unify(self[temp_v!(2)], complete_string);
}
&SystemClauseType::Ed25519Sign => {
let key = self.string_encoding_bytes(1, 2);
let data = self.string_encoding_bytes(3, 4);
let key = self.string_encoding_bytes(1, "octet");
let encoding = self.atom_argument_to_string(3);
let data = self.string_encoding_bytes(2, &encoding);
let key_pair = match signature::Ed25519KeyPair::from_pkcs8(&key) {
Ok(kp) => { kp }
@@ -5704,13 +5698,14 @@ impl MachineState {
let sig_list =
Addr::HeapCell(self.heap.to_list(sig.as_ref().iter().map(|b| HeapCellValue::from(Addr::Fixnum(*b as isize)))));
self.unify(self[temp_v!(5)], sig_list);
self.unify(self[temp_v!(4)], sig_list);
}
&SystemClauseType::Ed25519Verify => {
let key = self.string_encoding_bytes(1, 2);
let data = self.string_encoding_bytes(3, 4);
let key = self.string_encoding_bytes(1, "octet");
let encoding = self.atom_argument_to_string(3);
let data = self.string_encoding_bytes(2, &encoding);
let stub = MachineError::functor_stub(clause_name!("ed25519_verify"), 5);
let signature = self.integers_to_bytevec(temp_v!(5), stub);
let signature = self.integers_to_bytevec(temp_v!(4), stub);
let peer_public_key = signature::UnparsedPublicKey::new(&signature::ED25519, &key);
match peer_public_key.verify(&data, &signature) {
@@ -5729,10 +5724,7 @@ impl MachineState {
let result = scalarmult(&scalar, &point).unwrap();
let mut string = String::new();
for c in result[..].iter() {
string.push(*c as char);
}
let string = String::from_iter(result[..].iter().map(|b| *b as char));
let cstr = self.heap.put_complete_string(&string);
self.unify(self[temp_v!(3)], cstr);
}
@@ -5777,32 +5769,18 @@ impl MachineState {
env::remove_var(key);
}
&SystemClauseType::CharsBase64 => {
let mut options = vec![];
for i in 3..5 {
match self.store(self.deref(self[temp_v!(i)])) {
Addr::Con(h) if self.heap.atom_at(h) => {
if let HeapCellValue::Atom(ref atom, _) = &self.heap[h] {
options.push(atom.as_str());
} else {
unreachable!()
}
}
_ => {
unreachable!()
}
};
}
let padding = self.atom_argument_to_string(3);
let charset = self.atom_argument_to_string(4);
let config =
if options[0] == "true" {
if options[1] == "standard" {
if padding == "true" {
if charset == "standard" {
base64::STANDARD
} else {
base64::URL_SAFE
}
} else {
if options[1] == "standard" {
if charset == "standard" {
base64::STANDARD_NO_PAD
} else {
base64::URL_SAFE_NO_PAD
@@ -5815,10 +5793,7 @@ impl MachineState {
match bytes {
Ok(bs) => {
let mut string = String::new();
for c in bs {
string.push(c as char);
}
let string = String::from_iter(bs.iter().map(|b| *b as char));
let cstr = self.heap.put_complete_string(&string);
self.unify(self[temp_v!(1)], cstr);
}
@@ -5874,17 +5849,14 @@ impl MachineState {
}
pub(super)
fn string_encoding_bytes(
fn atom_argument_to_string(
&mut self,
data_arg: usize,
encoding_arg: usize,
) -> Vec<u8> {
let data = self.heap_pstr_iter(self[temp_v!(data_arg)]).to_string();
let encoding_str = match self.store(self.deref(self[temp_v!(encoding_arg)])) {
atom_arg: usize,
) -> String {
match self.store(self.deref(self[temp_v!(atom_arg)])) {
Addr::Con(h) if self.heap.atom_at(h) => {
if let HeapCellValue::Atom(ref atom, _) = &self.heap[h] {
atom.as_str()
atom.as_str().to_string()
} else {
unreachable!()
}
@@ -5892,9 +5864,18 @@ impl MachineState {
_ => {
unreachable!()
}
};
}
}
match encoding_str {
pub(super)
fn string_encoding_bytes(
&mut self,
data_arg: usize,
encoding: &str,
) -> Vec<u8> {
let data = self.heap_pstr_iter(self[temp_v!(data_arg)]).to_string();
match encoding {
"utf8" => { data.into_bytes() }
"octet" => {
let mut buf = vec![];