From f5c2f6f9e9d98870eaf8b6c0dc0ae06e8fed8376 Mon Sep 17 00:00:00 2001
From: Markus Triska <triska@metalevel.at>
Date: Tue, 19 May 2020 10:50:33 +0200
Subject: [PATCH] ADDED: Support for SHA-3 algorithms in crypto_data_hash/3

---
 Cargo.toml                         |  1 +
 src/prolog/lib/crypto.pl           | 19 +++++++++++--------
 src/prolog/machine/system_calls.rs | 21 +++++++++++++++++++--
 3 files changed, 31 insertions(+), 10 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 3f48283c..6e5c657e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,3 +36,4 @@ rustyline = "6.0.0"
 unicode_reader = "1.0.0"
 ring = "0.16.13"
 ripemd160 = "0.8.0"
+sha3 = "0.8.2"
diff --git a/src/prolog/lib/crypto.pl b/src/prolog/lib/crypto.pl
index 909127d4..9881afba 100644
--- a/src/prolog/lib/crypto.pl
+++ b/src/prolog/lib/crypto.pl
@@ -159,10 +159,10 @@ crypto_random_byte(B) :- '$crypto_random_byte'(B).
 
      - algorithm(+A)
        where A is one of ripemd160, sha256, sha384, sha512,
-       sha512_256, or a variable. If A is a variable, then it is
-       unified with the default algorithm, which is an algorithm that
-       is considered cryptographically secure at the time of this
-       writing.
+       sha512_256, sha3_224, sha3_256, sha3_384, sha3_512, or a
+       variable. If A is a variable, then it is unified with the
+       default algorithm, which is an algorithm that is considered
+       cryptographically secure at the time of this writing.
      - encoding(+Encoding)
        The default encoding is utf8. The alternative is octet,
        to treat the input as a list of raw bytes.
@@ -215,6 +215,10 @@ hash_algorithm(sha256).
 hash_algorithm(sha512).
 hash_algorithm(sha384).
 hash_algorithm(sha512_256).
+hash_algorithm(sha3_224).
+hash_algorithm(sha3_256).
+hash_algorithm(sha3_384).
+hash_algorithm(sha3_512).
 
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -230,10 +234,9 @@ hash_algorithm(sha512_256).
    Admissible options are:
 
      - algorithm(+Algorithm)
-       A hashing algorithm as specified to crypto_data_hash/3. The
-       default is a cryptographically secure algorithm. If you
-       specify a variable, then it is unified with the algorithm
-       that was used, which is a cryptographically secure algorithm.
+       One of sha256, sha384 or sha512. If you specify a variable,
+       then it is unified with the algorithm that was used, which is a
+       cryptographically secure algorithm by default.
      - info(+Info)
        Optional context and application specific information,
        specified as a list of bytes or characters. The default is [].
diff --git a/src/prolog/machine/system_calls.rs b/src/prolog/machine/system_calls.rs
index 6160e7dd..9643aac5 100644
--- a/src/prolog/machine/system_calls.rs
+++ b/src/prolog/machine/system_calls.rs
@@ -42,6 +42,7 @@ use crate::crossterm::terminal::{enable_raw_mode, disable_raw_mode};
 use ring::rand::{SecureRandom, SystemRandom};
 use ring::{digest,hkdf,pbkdf2,aead,error};
 use ripemd160::{Ripemd160, Digest};
+use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512};
 
 pub fn get_key() -> KeyEvent {
     let key;
@@ -5219,7 +5220,23 @@ impl MachineState {
                 };
 
                 let ints_list =
-                        if algorithm_str == "ripemd160" {
+                        if algorithm_str == "sha3_224" {
+                             let mut context = Sha3_224::new();
+                             context.input(&bytes);
+                             Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::Integer(Rc::new(Integer::from(*b))))))
+                        } else if algorithm_str == "sha3_256" {
+                             let mut context = Sha3_256::new();
+                             context.input(&bytes);
+                             Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::Integer(Rc::new(Integer::from(*b))))))
+                        } else if algorithm_str == "sha3_384" {
+                             let mut context = Sha3_384::new();
+                             context.input(&bytes);
+                             Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::Integer(Rc::new(Integer::from(*b))))))
+                        } else if algorithm_str == "sha3_512" {
+                             let mut context = Sha3_512::new();
+                             context.input(&bytes);
+                             Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::Integer(Rc::new(Integer::from(*b))))))
+                        } else if algorithm_str == "ripemd160" {
                              let mut context = Ripemd160::new();
                              context.input(&bytes);
                              Addr::HeapCell(self.heap.to_list(context.result().as_ref().iter().map(|b| HeapCellValue::Integer(Rc::new(Integer::from(*b))))))
@@ -5278,7 +5295,7 @@ impl MachineState {
                                   "sha256" =>     { hkdf::HKDF_SHA256 }
                                   "sha384" =>     { hkdf::HKDF_SHA384 }
                                   "sha512" =>     { hkdf::HKDF_SHA512 }
-                                  _ =>            { unreachable!() }
+                                  _ =>            { self.fail = true; return Ok(()); }
                                };
                              let salt = hkdf::Salt::new(digest_alg, &salt);
                              let mut bytes : Vec<u8> = Vec::new();
-- 
2.54.0