added sha256t (set to default)

.gitignore

@@ -2,5 +2,6 @@
 Cargo.lock
 *~
 node_modules/
+package-lock.json
 cli/build/test
 cli/build/kana-hash

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 [<salt>]] [--] <input strings...>\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;

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)

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;

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": {

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::<hash::Crc32Checksum, _>(&mut from, &self.salt, &mut output)?,
 	    Algorithm::Crc64 => provide::<hash::Crc64Checksum, _>(&mut from, &self.salt, &mut output)?,
 	    Algorithm::Sha256 => provide::<hash::Sha256Hash, _>(&mut from, &self.salt, &mut output)?,
+	    Algorithm::Sha256Truncated => provide::<hash::Sha256Truncated, _>(&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<Algorithm> 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<u8> for Algorithm
 	    ALGO_CRC32 => Algorithm::Crc32,
 	    ALGO_CRC64 => Algorithm::Crc64,
 	    ALGO_SHA256 => Algorithm::Sha256,
+	    ALGO_SHA256_TRUNCATED => Algorithm::Sha256Truncated,
 	    _ => Self::default(),
 	}
     }

src/hash/mod.rs

@@ -8,3 +8,6 @@ pub use crc64::*;
 
 mod crc32;
 pub use crc32::*;
+
+mod sha256t;
+pub use sha256t::*;

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<T: Read + ?Sized>(input: &mut T, salt: &salt::Salt, done: &mut usize) -> Result<Self, error::Error>
+    {
+	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})
+    }
+}

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<dyn std::error::Error>>
-    {
-	
+	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;

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<usize>; 2] = &[
+    0..=45,
+    46..=91,
+];
+
 pub const KANA_SUB: &[char; 18] = &[
     'ゃ',
     'ゅ',

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::<i8>(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

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::<T>());
+    &std::slice::from_raw_parts(&src[0] as *const u8 as *const T, 1)[0]
+}
+

src/salt.rs

@@ -1,4 +1,3 @@
-use crate::*;
 use malloc_array::*;
 use getrandom::{
     getrandom,