ハッシュ関数

// $ cargo +nightly run --release
//
#![feature(test)]
extern crate test;

use std::fs;
use std::io;
use std::io::prelude::*;
use test::stats::Summary;

enum Secure {
  None,
  Broken(&'static str),
  Weak(&'static str),
  Fine,
}

fn main() {
  #[cfg(debug_assertions)]
  std::compile_error!("ERROR: リリースビルドで実行してください.");
  let summaries = &[
    bench("CRC32", bench_crc32, Secure::None),
    bench("MurmurHash64A", bench_murmur64a, Secure::None),
    bench("MurmurHash3-128 (x64)", bench_murmur3_x64_128, Secure::None),
    bench("aHash", bench_ahash, Secure::None),
    bench("MD2", bench_md2, Secure::Broken("preimage attack")),
    bench("MD5", bench_md5, Secure::Broken("collision attack")),
    bench("MD6", bench_md6, Secure::Fine),
    bench("SHA-1", bench_sha1, Secure::Broken("collision attack")),
    bench("RIPEMD-160", bench_ripemd_160, Secure::Weak("length extension attack")),
    bench("RIPEMD-320", bench_ripemd_320, Secure::Weak("length extension attack")),
    bench("Whirlpool", bench_whirlpool, Secure::Weak("length extension attack")),
    bench("SHA-224", bench_sha_224, Secure::Weak("length extension attack")),
    bench("SHA-256", bench_sha_256, Secure::Weak("length extension attack")),
    bench("SHA-386", bench_sha_384, Secure::Weak("length extension attack")),
    bench("SHA-512", bench_sha_512, Secure::Weak("length extension attack")),
    bench("SHA-512/224", bench_sha_512_224, Secure::Fine),
    bench("SHA-512/256", bench_sha_512_256, Secure::Fine),
    bench("SHA3-224", bench_sha3_224, Secure::Fine),
    bench("SHA3-256", bench_sha3_256, Secure::Fine),
    bench("SHA3-384", bench_sha3_384, Secure::Fine),
    bench("SHA3-512", bench_sha3_512, Secure::Fine),
    bench("SHAKE128", bench_shake128, Secure::Fine),
    bench("SHAKE256", bench_shake256, Secure::Fine),
    bench("Keccak-256", bench_keccak_256, Secure::Fine),
    bench("Keccak-512", bench_keccak_512, Secure::Fine),
    bench("BLAKE2b", bench_blake2b, Secure::Fine),
    bench("BLAKE2s", bench_blake2s, Secure::Fine),
    bench("BLAKE3", bench_blake3, Secure::Fine),
    bench("SipHash", bench_siphash64, Secure::Fine),
    bench("SipHash128", bench_siphash128, Secure::Fine),
    bench("HighwayHash64", bench_highwayhash64, Secure::Fine),
    bench("HighwayHash128", bench_highwayhash128, Secure::Fine),
    bench("HighwayHash256", bench_highwayhash256, Secure::Fine),
  ][..];

  let arch = std::env::consts::ARCH;
  let os = std::env::consts::OS;
  let file_name = format!("hash-performance_{}-{}.xml", os, arch);

  let file = fs::File::create(file_name).unwrap();
  let mut writer = io::BufWriter::new(file);
  writer.write(b"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n").unwrap();
  writer.write(format!("<table id=\"tbl1_{}-{}\" class=\"wikitable\">\n", os, arch).as_bytes()).unwrap();
  writer.write("  <tr><th>アルゴリズム</th><th>算出時間  [μsec/1MB] (±95%信頼区間)</th><th>出力サイズ \\(k\\)</th><th class=\"text-center\">🔒</th></tr>\n".as_bytes()).unwrap();
  for (name, secure, summary, result, hex) in summaries.iter() {
    let security = match secure {
      Secure::Fine => "🌞".to_string(),
      Secure::Weak(reason) => format!("<span title=\"{}\">⛅</span>", reason),
      Secure::Broken(reason) => format!("<span title=\"{}\">☔</span>", reason),
      Secure::None => "".to_string(),
    };
    writer.write(format!("  <tr title=\"{}\">\
    <th>{}</th>\
    <td class=\"number\">{} (±{:.1}%)</td>\
    <td class=\"number\">{}-bit ({}B)</td>\
    <td class=\"text-center\">{}</td>\
  </tr>\n",
                         hex, name, comma(summary.mean / 1000.0, 3), 1.96 * summary.std_dev_pct, result.len() * 8, result.len(), security).as_bytes()
    ).unwrap();
  }
  writer.write("<caption><span class=\"table-label\">Table 1</span>. アルゴリズムの公開されているハッシュ関数のパフォーマンス。</caption>\n".as_bytes()).unwrap();
  writer.write(b"</table>\n").unwrap();
}

fn comma(value: f64, place_after_the_decimal_point: usize) -> String {
  let n = format!("{:.*}", place_after_the_decimal_point, value);
  let (mut n, digits) = match n.find('.') {
    Some(i) => (n[0..i].to_string(), n[i + 1..].to_string()),
    None => (n, "".to_string())
  };
  for i in (1..n.len() - 2).rev().step_by(3) {
    n.insert(i, ',');
  }
  format!("{}.{}", n, digits)
}

fn bench(name: &'static str, b: fn(&[u8]) -> Vec<u8>, secure: Secure) -> (&'static str, Secure, Summary, Vec<u8>, String) {
  let buffer: Vec<u8> = (0..(1024 * 1024)).map(|_| 0u8).collect();
  let result = b(&buffer);
  let summary = test::bench::iter(&mut || b(&buffer));
  let hex: String = result.iter().map(|i| format!("{:02X}", i)).collect();
  let short_hex = if hex.len() > 16 { hex[0..16].to_string() } else { hex.to_string() };
  println!("{:<11}: {:>9} (±{:.1}%) {}-bits: {}", name, comma(summary.mean / 1000.0, 3), 1.96 * summary.std_dev_pct, result.len() * 8, short_hex);
  (name, secure, summary, result, hex)
}

macro_rules! bench {
  ($id:ident, $package:path, $name:ident) => {
    fn $id(buffer: &[u8]) -> Vec<u8> {
      use $package::{$name, Digest};
      let mut hasher = $name::new();
      hasher.update(buffer);
      hasher.finalize().to_vec()
    }
  }
}

bench!(bench_md2, md2, Md2);
bench!(bench_md5, md5, Md5);
bench!(bench_sha1, sha1, Sha1);

bench!(bench_whirlpool, whirlpool, Whirlpool);
bench!(bench_ripemd_160, ripemd, Ripemd160);
bench!(bench_ripemd_320, ripemd, Ripemd320);

bench!(bench_sha_224, sha2, Sha224);
bench!(bench_sha_256, sha2, Sha256);
bench!(bench_sha_384, sha2, Sha384);
bench!(bench_sha_512, sha2, Sha512);
bench!(bench_sha_512_224, sha2, Sha512_224);
bench!(bench_sha_512_256, sha2, Sha512_256);

bench!(bench_sha3_224, sha3, Sha3_224);
bench!(bench_sha3_256, sha3, Sha3_256);
bench!(bench_sha3_384, sha3, Sha3_384);
bench!(bench_sha3_512, sha3, Sha3_512);
bench!(bench_keccak_256, sha3, Keccak256);
bench!(bench_keccak_512, sha3, Keccak512);

bench!(bench_blake2b, blake2, Blake2b512);
bench!(bench_blake2s, blake2, Blake2s256);

fn bench_ahash(buffer: &[u8]) -> Vec<u8> {
  use std::hash::Hasher;
  use ahash::AHasher;
  let mut hasher = AHasher::default();
  hasher.write(buffer);
  hasher.finish().to_le_bytes().to_vec()
}

fn bench_md6(buffer: &[u8]) -> Vec<u8> {
  let mut result = [0; 64];
  md6::hash(512, buffer, &mut result).unwrap();
  result.to_vec()
}

fn bench_siphash64(buffer: &[u8]) -> Vec<u8> {
  use siphasher::sip::SipHasher;
  use std::hash::Hasher;
  let mut hasher = SipHasher::new();
  hasher.write(buffer);
  hasher.finish().to_le_bytes().to_vec()
}

fn bench_siphash128(buffer: &[u8]) -> Vec<u8> {
  use siphasher::sip128::{SipHasher, Hasher128};
  use std::hash::Hasher;
  let mut hasher = SipHasher::new();
  hasher.write(buffer);
  hasher.finish128().as_bytes().to_vec()
}

fn bench_highwayhash64(buffer: &[u8]) -> Vec<u8> {
  use highway::{HighwayHasher, HighwayHash, Key};
  let res = HighwayHasher::new(Key([0, 0, 0, 0])).hash64(buffer);
  res.to_le_bytes().to_vec()
}

fn bench_highwayhash128(buffer: &[u8]) -> Vec<u8> {
  use highway::{HighwayHasher, HighwayHash, Key};
  let res = HighwayHasher::new(Key([0, 0, 0, 0])).hash128(buffer);
  let mut result = Vec::with_capacity(2 * 8);
  result.append(&mut res[0].to_le_bytes().to_vec());
  result.append(&mut res[1].to_le_bytes().to_vec());
  result
}

fn bench_highwayhash256(buffer: &[u8]) -> Vec<u8> {
  use highway::{HighwayHasher, HighwayHash, Key};
  let res = HighwayHasher::new(Key([0, 0, 0, 0])).hash256(buffer);
  let mut result = Vec::with_capacity(4 * 8);
  result.append(&mut res[0].to_le_bytes().to_vec());
  result.append(&mut res[1].to_le_bytes().to_vec());
  result.append(&mut res[2].to_le_bytes().to_vec());
  result.append(&mut res[3].to_le_bytes().to_vec());
  result
}

fn bench_blake3(buffer: &[u8]) -> Vec<u8> {
  let mut hasher = blake3::Hasher::new();
  hasher.update(buffer);
  hasher.finalize().as_bytes().to_vec()
}

fn bench_murmur64a(buffer: &[u8]) -> Vec<u8> {
  murmurhash64::murmur_hash64a(buffer, 0).to_le_bytes().to_vec()
}

fn bench_murmur3_x64_128(buffer: &[u8]) -> Vec<u8> {
  murmur3::murmur3_x64_128(&mut std::io::Cursor::new(buffer), 0).unwrap().to_le_bytes().to_vec()
}

fn bench_crc32(buffer: &[u8]) -> Vec<u8> {
  let crc: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_CKSUM);
  crc.checksum(buffer).to_le_bytes().to_vec()
}

macro_rules! bench_shake {
  ($id:ident, $name:ident) => {
    fn $id(buffer: &[u8]) -> Vec<u8> {
      use sha3::digest::{Update, ExtendableOutput, XofReader};
      let mut hasher = sha3::$name::default();
      hasher.update(buffer);
      let mut reader = hasher.finalize_xof();
      let mut ret = [0u8; 512 / 8];
      XofReader::read(&mut reader, &mut ret);
      ret.to_vec()
    }
  }
}

bench_shake!(bench_shake128, Shake128);
bench_shake!(bench_shake256, Shake256);

[package]
name = "hash-pfm-rs"
version = "0.1.0"
authors = ["TAKAMI Torao <koiroha@gmail.com>"]
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
md2 = "0.10"
md-5 = "0.10"
md6 = "2.0"
sha-1 = "0.10"
sha2 = "0.10"
sha3 = "0.10"
whirlpool = "0.10"
ripemd = "0.1"
blake2 = "0.10"
blake3 = "1.4"
murmur3 = "0.5"
murmurhash64 = "0.3"
ahash = "0.8"
siphasher = "1.0"
highway = "1.1"
crc = "3.0"