/* * Copyright (c) 2012-2020 MIRACL UK Ltd. * * This file is part of MIRACL Core * (see https://github.com/miracl/core). * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const HASH384_H0: u64 = 0xcbbb9d5dc1059ed8; const HASH384_H1: u64 = 0x629a292a367cd507; const HASH384_H2: u64 = 0x9159015a3070dd17; const HASH384_H3: u64 = 0x152fecd8f70e5939; const HASH384_H4: u64 = 0x67332667ffc00b31; const HASH384_H5: u64 = 0x8eb44a8768581511; const HASH384_H6: u64 = 0xdb0c2e0d64f98fa7; const HASH384_H7: u64 = 0x47b5481dbefa4fa4; const HASH384_K: [u64; 80] = [ 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817, ]; pub struct HASH384 { length: [u64; 2], h: [u64; 8], w: [u64; 80], } impl HASH384 { fn s(n: u64, x: u64) -> u64 { ((x) >> n) | ((x) << (64 - n)) } fn r(n: u64, x: u64) -> u64 { (x) >> n } fn ch(x: u64, y: u64, z: u64) -> u64 { (x & y) ^ (!(x) & z) } fn maj(x: u64, y: u64, z: u64) -> u64 { (x & y) ^ (x & z) ^ (y & z) } fn sig0(x: u64) -> u64 { HASH384::s(28, x) ^ HASH384::s(34, x) ^ HASH384::s(39, x) } fn sig1(x: u64) -> u64 { HASH384::s(14, x) ^ HASH384::s(18, x) ^ HASH384::s(41, x) } fn theta0(x: u64) -> u64 { HASH384::s(1, x) ^ HASH384::s(8, x) ^ HASH384::r(7, x) } fn theta1(x: u64) -> u64 { HASH384::s(19, x) ^ HASH384::s(61, x) ^ HASH384::r(6, x) } pub fn as_bytes(&self,array: &mut [u8]) { let mut ptr=0; for i in 0..2 { let mut t=self.length[i]; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=t as u8; ptr+=1; } for i in 0..8 { let mut t=self.h[i]; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=t as u8; ptr+=1; } for i in 0..80 { let mut t=self.w[i]; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=(t%256) as u8; t/=256; ptr+=1; array[ptr]=t as u8; ptr+=1; } } pub fn from_bytes(&mut self,array: &[u8]) { let mut ptr=0; for i in 0..2 { let mut t=array[ptr+7] as u64; t=256*t+(array[ptr+6] as u64); t=256*t+(array[ptr+5] as u64); t=256*t+(array[ptr+4] as u64); t=256*t+(array[ptr+3] as u64); t=256*t+(array[ptr+2] as u64); t=256*t+(array[ptr+1] as u64); t=256*t+(array[ptr] as u64); self.length[i]=t; ptr+=8; } for i in 0..8 { let mut t=array[ptr+7] as u64; t=256*t+(array[ptr+6] as u64); t=256*t+(array[ptr+5] as u64); t=256*t+(array[ptr+4] as u64); t=256*t+(array[ptr+3] as u64); t=256*t+(array[ptr+2] as u64); t=256*t+(array[ptr+1] as u64); t=256*t+(array[ptr] as u64); self.h[i]=t; ptr+=8; } for i in 0..80 { let mut t=array[ptr+7] as u64; t=256*t+(array[ptr+6] as u64); t=256*t+(array[ptr+5] as u64); t=256*t+(array[ptr+4] as u64); t=256*t+(array[ptr+3] as u64); t=256*t+(array[ptr+2] as u64); t=256*t+(array[ptr+1] as u64); t=256*t+(array[ptr] as u64); self.w[i]=t; ptr+=8; } } fn transform(&mut self) { /* basic transformation step */ for j in 16..80 { self.w[j] = HASH384::theta1(self.w[j - 2]) .wrapping_add(self.w[j - 7]) .wrapping_add(HASH384::theta0(self.w[j - 15])) .wrapping_add(self.w[j - 16]); } let mut a = self.h[0]; let mut b = self.h[1]; let mut c = self.h[2]; let mut d = self.h[3]; let mut e = self.h[4]; let mut f = self.h[5]; let mut g = self.h[6]; let mut hh = self.h[7]; for j in 0..80 { /* 64 times - mush it up */ let t1 = hh .wrapping_add(HASH384::sig1(e)) .wrapping_add(HASH384::ch(e, f, g)) .wrapping_add(HASH384_K[j]) .wrapping_add(self.w[j]); let t2 = HASH384::sig0(a).wrapping_add(HASH384::maj(a, b, c)); hh = g; g = f; f = e; e = d.wrapping_add(t1); d = c; c = b; b = a; a = t1.wrapping_add(t2); } self.h[0] = self.h[0].wrapping_add(a); self.h[1] = self.h[1].wrapping_add(b); self.h[2] = self.h[2].wrapping_add(c); self.h[3] = self.h[3].wrapping_add(d); self.h[4] = self.h[4].wrapping_add(e); self.h[5] = self.h[5].wrapping_add(f); self.h[6] = self.h[6].wrapping_add(g); self.h[7] = self.h[7].wrapping_add(hh); } /* Initialise Hash function */ pub fn init(&mut self) { /* initialise */ for i in 0..64 { self.w[i] = 0 } self.length[0] = 0; self.length[1] = 0; self.h[0] = HASH384_H0; self.h[1] = HASH384_H1; self.h[2] = HASH384_H2; self.h[3] = HASH384_H3; self.h[4] = HASH384_H4; self.h[5] = HASH384_H5; self.h[6] = HASH384_H6; self.h[7] = HASH384_H7; } pub fn new() -> HASH384 { let mut nh = HASH384 { length: [0; 2], h: [0; 8], w: [0; 80], }; nh.init(); nh } pub fn new_copy(hh: &HASH384) -> HASH384 { let mut nh = HASH384 { length: [0; 2], h: [0; 8], w: [0; 80], }; nh.length[0]=hh.length[0]; nh.length[1]=hh.length[1]; for i in 0..80 { nh.w[i] = hh.w[i]; } for i in 0..8 { nh.h[i] = hh.h[i]; } nh } /* process a single byte */ pub fn process(&mut self, byt: u8) { /* process the next message byte */ let cnt = ((self.length[0] / 64) % 16) as usize; self.w[cnt] <<= 8; self.w[cnt] |= byt as u64; self.length[0] += 8; if self.length[0] == 0 { self.length[1] += 1; self.length[0] = 0 } if (self.length[0] % 1024) == 0 { self.transform() } } /* process an array of bytes */ pub fn process_array(&mut self, b: &[u8]) { for i in 0..b.len() { self.process(b[i]) } } /* process a 32-bit integer */ pub fn process_num(&mut self, n: i32) { self.process(((n >> 24) & 0xff) as u8); self.process(((n >> 16) & 0xff) as u8); self.process(((n >> 8) & 0xff) as u8); self.process((n & 0xff) as u8); } /* Generate 32-byte Hash */ pub fn hash(&mut self) -> [u8; 48] { /* pad message and finish - supply digest */ let mut digest: [u8; 48] = [0; 48]; let len0 = self.length[0]; let len1 = self.length[1]; self.process(0x80); while (self.length[0] % 1024) != 896 { self.process(0) } self.w[14] = len1; self.w[15] = len0; self.transform(); for i in 0..48 { /* convert to bytes */ digest[i] = ((self.h[i / 8] >> (8 * (7 - i % 8))) & 0xff) as u8; } self.init(); digest } pub fn continuing_hash(&self) -> [u8; 48] { let mut sh=HASH384::new_copy(self); sh.hash() } } //09330c33f71147e8 3d192fc782cd1b47 53111b173b3b05d2 2fa08086e3b0f712 fcc7c71a557e2db9 66c3e9fa91746039 /* fn main() { let s = String::from("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); let test = s.into_bytes(); let mut sh=HASH384::new(); for i in 0..test.len(){ sh.process(test[i]); } let digest=sh.hash(); for i in 0..48 {print!("{:02x}",digest[i])} } */