From b926ac7c39bcc28e611610e4f70c44992aa208a2 Mon Sep 17 00:00:00 2001 From: Avril Date: Wed, 24 Jun 2020 12:56:27 +0100 Subject: [PATCH] added sha256t (set to default) --- .gitignore | 1 + cli/src/main.c | 8 ++++++- include/khash.h | 1 + node/kana.js | 1 + node/package.json | 2 +- src/ctx.rs | 7 +++++- src/hash/mod.rs | 3 +++ src/hash/sha256t.rs | 53 +++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 12 +++------- src/map.rs | 8 +++++++ src/mnemonic.rs | 16 +++++++++----- src/reinterpret.rs | 7 ++++++ src/salt.rs | 1 - 13 files changed, 102 insertions(+), 18 deletions(-) create mode 100644 src/hash/sha256t.rs diff --git a/.gitignore b/.gitignore index 4eb686f..cb5a10d 100644 --- a/.gitignore +++ b/.gitignore @@ -2,5 +2,6 @@ Cargo.lock *~ node_modules/ +package-lock.json cli/build/test cli/build/kana-hash diff --git a/cli/src/main.c b/cli/src/main.c index 515c0dd..a94d4f8 100644 --- a/cli/src/main.c +++ b/cli/src/main.c @@ -66,10 +66,11 @@ static int _main(int argc, char** argv, khash_ctx ctx) { printf("kana-hash cli\n"); printf("Usage: khash [--algo ALGO] [--salt SALT-TYPE []] [--] \n"); - printf(" --algo: Specify the algorithm. (default crc64)\n"); + printf(" --algo: Specify the algorithm. (default sha256 truncated)\n"); printf(" ALGO: 3: crc32.\n"); printf(" ALGO: 6: crc64.\n"); printf(" ALGO: s: sha256.\n"); + printf(" ALGO: t: truncated (64bit) sha256.\n"); printf(" --salt: Specify the salt.\n"); printf(" SALT_TYPE: D: default embedded.\n"); printf(" : N: no salt.\n"); @@ -93,8 +94,13 @@ static int _main(int argc, char** argv, khash_ctx ctx) ctx.algo = KHASH_ALGO_CRC64; break; case 's': + case 'S': ctx.algo = KHASH_ALGO_SHA256; break; + case 'T': + case 't': + ctx.algo = KHASH_ALGO_SHA256_TRUNCATED; + break; default: fprintf(stderr, "ALGO: unknow algorithm key `%c'\n", *argv[1]); return 1; diff --git a/include/khash.h b/include/khash.h index 3f35e23..59d7acd 100644 --- a/include/khash.h +++ b/include/khash.h @@ -17,6 +17,7 @@ extern "C" { #define KHASH_ALGO_CRC32 ((uint8_t)1) #define KHASH_ALGO_CRC64 ((uint8_t)2) #define KHASH_ALGO_SHA256 ((uint8_t)3) +#define KHASH_ALGO_SHA256_TRUNCATED ((uint8_t)4) /* SHA256 truncated to 64 bits */ /// No salt #define KHASH_SALT_TYPE_NONE ((uint8_t)0) diff --git a/node/kana.js b/node/kana.js index 8d36527..4006503 100644 --- a/node/kana.js +++ b/node/kana.js @@ -90,6 +90,7 @@ Kana.ALGO_DEFAULT = 0; Kana.ALGO_CRC32 = 1; Kana.ALGO_CRC64 = 2; Kana.ALGO_SHA256 = 3; +Kana.ALGO_SHA256_TRUNCATED = 4; Kana.SALT_NONE = 0; Kana.SALT_DEFAULT = 1; diff --git a/node/package.json b/node/package.json index 4e5a2d4..e1e1e84 100644 --- a/node/package.json +++ b/node/package.json @@ -1,6 +1,6 @@ { "name": "kana-hash", - "version": "1.0.0", + "version": "1.1.0", "description": "Kana hashes", "main": "index.js", "scripts": { diff --git a/src/ctx.rs b/src/ctx.rs index 8ae8ebb..b77a8d9 100644 --- a/src/ctx.rs +++ b/src/ctx.rs @@ -11,13 +11,14 @@ pub enum Algorithm Crc32, Crc64, Sha256, + Sha256Truncated, } impl Default for Algorithm { fn default() -> Self { - Self::Crc64 + Self::Sha256Truncated } } @@ -62,6 +63,7 @@ impl Context Algorithm::Crc32 => provide::(&mut from, &self.salt, &mut output)?, Algorithm::Crc64 => provide::(&mut from, &self.salt, &mut output)?, Algorithm::Sha256 => provide::(&mut from, &self.salt, &mut output)?, + Algorithm::Sha256Truncated => provide::(&mut from, &self.salt, &mut output)?, }.into_boxed_slice(); Ok((output, bytes)) @@ -111,6 +113,7 @@ pub const ALGO_DEFAULT: u8 = 0; pub const ALGO_CRC32: u8 = 1; pub const ALGO_CRC64: u8 = 2; pub const ALGO_SHA256: u8 = 3; +pub const ALGO_SHA256_TRUNCATED: u8 = 4; /// FFI context #[derive(Debug)] @@ -130,6 +133,7 @@ impl From for u8 Algorithm::Crc32 => ALGO_CRC32, Algorithm::Crc64 => ALGO_CRC64, Algorithm::Sha256 => ALGO_SHA256, + Algorithm::Sha256Truncated => ALGO_SHA256_TRUNCATED, } } } @@ -141,6 +145,7 @@ impl From for Algorithm ALGO_CRC32 => Algorithm::Crc32, ALGO_CRC64 => Algorithm::Crc64, ALGO_SHA256 => Algorithm::Sha256, + ALGO_SHA256_TRUNCATED => Algorithm::Sha256Truncated, _ => Self::default(), } } diff --git a/src/hash/mod.rs b/src/hash/mod.rs index dca4925..7148f04 100644 --- a/src/hash/mod.rs +++ b/src/hash/mod.rs @@ -8,3 +8,6 @@ pub use crc64::*; mod crc32; pub use crc32::*; + +mod sha256t; +pub use sha256t::*; diff --git a/src/hash/sha256t.rs b/src/hash/sha256t.rs new file mode 100644 index 0000000..cc36479 --- /dev/null +++ b/src/hash/sha256t.rs @@ -0,0 +1,53 @@ +use super::*; +use crate::{ + array, + provider::ByteProvider, +}; + +pub const SHA256_TRUNCATE: usize = 8; +mod __static_assert +{ + use super::*; + const _IS_LESS_THAN_OR_EQ_SHA256_SIZE: &'static [()] = &[(); SHA256_SIZE - SHA256_TRUNCATE]; +} + + +use std::fmt; +impl fmt::Display for Sha256Truncated +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result + { + write!(f, "Sha256Truncated[->{}] (", SHA256_TRUNCATE)?; + for byte in self.hash.iter() + { + write!(f, "{:02x}", *byte)?; + } + write!(f, ")") + } +} + +#[repr(C)] +#[repr(packed)] +#[derive(Copy,Clone,Debug,PartialEq,Eq,Hash)] +pub struct Sha256Truncated +{ + hash: [u8; SHA256_TRUNCATE], +} + + +impl ByteProvider for hash::Sha256Truncated +{ + fn bytes(&self) -> &[u8] + { + &self.hash[..] + } + + fn compute(input: &mut T, salt: &salt::Salt, done: &mut usize) -> Result + { + let (ok, sha) = Sha256Hash::compute(input, salt)?; + let mut hash = [0u8; SHA256_TRUNCATE]; + array::copy_slice(&mut hash, sha.bytes()); + *done = ok; + Ok(Self{hash}) + } +} diff --git a/src/lib.rs b/src/lib.rs index 12af60b..1328d85 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -15,18 +15,12 @@ mod tests { #[test] fn it_works() -> Result<(), error::Error> { - let input = b"lolis are super ultra mega cute"; + let input = b"lolis are super ultra mega cute!"; let context = ctx::Context::default(); let kana = generate(&context, input)?; println!("kana: {}", kana); - assert_eq!(kana, "ワイトひはぇトョ"); - Ok(()) - } - #[test] - fn ffi() -> Result<(), Box> - { - + assert_eq!(kana, "もッちゅゆをヌョ"); Ok(()) } } @@ -36,7 +30,7 @@ pub const BUFFER_SIZE: usize = 4096; mod array; mod reinterpret; mod ext; -use ext::*; +//use ext::*; mod group; //unused mod sixteen; use sixteen::Bit16IterExt; diff --git a/src/map.rs b/src/map.rs index b609afe..c3c1f65 100644 --- a/src/map.rs +++ b/src/map.rs @@ -1,3 +1,5 @@ +use std::ops::RangeInclusive; + pub const KANA: &[char; 92] = &[ 'あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', 'け', 'こ', @@ -20,6 +22,12 @@ pub const KANA: &[char; 92] = &[ 'ヤ', 'ユ', 'ヨ', 'ワ', 'ン', 'ヲ', ]; + +pub const KANA_SIGN: &[RangeInclusive; 2] = &[ + 0..=45, + 46..=91, +]; + pub const KANA_SUB: &[char; 18] = &[ 'ゃ', 'ゅ', diff --git a/src/mnemonic.rs b/src/mnemonic.rs index 9af8820..4d6aba5 100644 --- a/src/mnemonic.rs +++ b/src/mnemonic.rs @@ -16,18 +16,24 @@ impl Digest { pub fn new(from: &[u8]) -> Self { let mut d = Self::default(); + if from.len() == 0 { + return d; + } - let oneesan = usize::from(from[0]) % map::KANA.len(); - d.0 = Some(map::KANA[oneesan]); - if from[1] > 0 { - if let Some(imoutos) = map::sub(oneesan) { + let sign0 = unsafe { *reinterpret::value::(from) < 0 }; + let range = &map::KANA_SIGN[sign0 as usize]; + let kana = &map::KANA[range.clone()]; + let oneesan = usize::from(from[0]) % kana.len(); + d.0 = Some(kana[oneesan]); + if from.len() > 1 { + if let Some(imoutos) = map::sub(range.start()+oneesan) { if let Some(imouto) = imoutos[usize::from(from[1]) % map::KANA_SUB.len()] { d.1 = Some(imouto); return d; } } - let from = [from[1], 0]; + let from = [from[1]]; d.1 = Self::new(&from[..]).0; } d diff --git a/src/reinterpret.rs b/src/reinterpret.rs index 1441d45..98e39bd 100644 --- a/src/reinterpret.rs +++ b/src/reinterpret.rs @@ -11,3 +11,10 @@ pub unsafe fn bytes_mut<'a, T>(src: &'a mut T) -> &'a mut [u8] { std::slice::from_raw_parts_mut(src as *mut T as *mut u8, std::mem::size_of_val(src)) } + +pub unsafe fn value<'a, T>(src: &[u8]) -> &'a T +{ + assert!(src.len() >= std::mem::size_of::()); + &std::slice::from_raw_parts(&src[0] as *const u8 as *const T, 1)[0] +} + diff --git a/src/salt.rs b/src/salt.rs index 948b335..457b4dd 100644 --- a/src/salt.rs +++ b/src/salt.rs @@ -1,4 +1,3 @@ -use crate::*; use malloc_array::*; use getrandom::{ getrandom,