ripemd160.d

   1 // RIPEMD-160, based on the algorithm description
   2 // public domain
   3 // this is around 2 times faster than `std.digest.ripemd`
   4 module iv.ripemd160;
   5
   6 public enum RIPEMD160_BITS = 160;
   7
   8 // Buffer size for RIPEMD-160 hash, in bytes.
   9 public enum RIPEMD160_BYTES = (RIPEMD160_BITS>>3);
  10
  11 // RIPEMD-160 context.
  12 public struct RIPEMD160_Ctx {
  13   uint[RIPEMD160_BYTES>>2] wkbuf = [0x67452301U, 0xefcdab89U, 0x98badcfeU, 0x10325476U, 0xc3d2e1f0U];
  14   ubyte[64] chunkd = 0;
  15   uint chunkpos = 0;
  16   uint total = 0;
  17   uint totalhi = 0;
  18 }
  19
  20
  21 private:
  22 enum RIPEMD160_ROL(string x, string n) = `(((`~x~`)<<(`~n~`))|((`~x~`)>>(32-(`~n~`))))`;
  23
  24 template RIPEMD160_PRIM(string bop, string x, string y, string z) {
  25        static if (bop == "F") enum RIPEMD160_PRIM = `((`~x~`)^(`~y~`)^(`~z~`))`;
  26   else static if (bop == "G") enum RIPEMD160_PRIM = `(((`~x~`)&(`~y~`))|(~(`~x~`)&(`~z~`)))`;
  27   else static if (bop == "H") enum RIPEMD160_PRIM = `(((`~x~`)|~(`~y~`))^(`~z~`))`;
  28   else static if (bop == "I") enum RIPEMD160_PRIM = `(((`~x~`)&(`~z~`))|((`~y~`)&~(`~z~`)))`;
  29   else static if (bop == "J") enum RIPEMD160_PRIM = `((`~x~`)^((`~y~`)|~(`~z~`)))`;
  30   else static assert(0, "invalid bop");
  31 }
  32
  33 enum RIPEMD160_BOP(string bop, string addconst, string a, string b, string c, string d, string e, string x, string s) =
  34   `(`~a~`) += `~RIPEMD160_PRIM!(bop, b, c, d)~`+(`~x~`)+`~addconst~`;`~
  35   `(`~a~`) = `~RIPEMD160_ROL!(a, s)~`+(`~e~`);`~
  36   `(`~c~`) = `~RIPEMD160_ROL!(c, "10")~`;`;
  37
  38 enum RIPEMD160_FF(string a, string b, string c, string d, string e, string x, string s) = RIPEMD160_BOP!("F", "0U", a, b, c, d, e, x, s);
  39 enum RIPEMD160_GG(string a, string b, string c, string d, string e, string x, string s) = RIPEMD160_BOP!("G", "0x5a827999U", a, b, c, d, e, x, s);
  40 enum RIPEMD160_HH(string a, string b, string c, string d, string e, string x, string s) = RIPEMD160_BOP!("H", "0x6ed9eba1U", a, b, c, d, e, x, s);
  41 enum RIPEMD160_II(string a, string b, string c, string d, string e, string x, string s) = RIPEMD160_BOP!("I", "0x8f1bbcdcU", a, b, c, d, e, x, s);
  42 enum RIPEMD160_JJ(string a, string b, string c, string d, string e, string x, string s) = RIPEMD160_BOP!("J", "0xa953fd4eU", a, b, c, d, e, x, s);
  43 enum RIPEMD160_FFF(string a, string b, string c, string d, string e, string x, string s) = RIPEMD160_BOP!("F", "0U", a, b, c, d, e, x, s);
  44 enum RIPEMD160_GGG(string a, string b, string c, string d, string e, string x, string s) = RIPEMD160_BOP!("G", "0x7a6d76e9U", a, b, c, d, e, x, s);
  45 enum RIPEMD160_HHH(string a, string b, string c, string d, string e, string x, string s) = RIPEMD160_BOP!("H", "0x6d703ef3U", a, b, c, d, e, x, s);
  46 enum RIPEMD160_III(string a, string b, string c, string d, string e, string x, string s) = RIPEMD160_BOP!("I", "0x5c4dd124U", a, b, c, d, e, x, s);
  47 enum RIPEMD160_JJJ(string a, string b, string c, string d, string e, string x, string s) = RIPEMD160_BOP!("J", "0x50a28be6U", a, b, c, d, e, x, s);
  48
  49
  50 static void ripemd160_compress (uint *wkbuf/*[RIPEMD160_BYTES>>2]*/, const uint* X) nothrow @trusted @nogc {
  51   uint aa = wkbuf[0];
  52   uint bb = wkbuf[1];
  53   uint cc = wkbuf[2];
  54   uint dd = wkbuf[3];
  55   uint ee = wkbuf[4];
  56   uint aaa = wkbuf[0];
  57   uint bbb = wkbuf[1];
  58   uint ccc = wkbuf[2];
  59   uint ddd = wkbuf[3];
  60   uint eee = wkbuf[4];
  61
  62   // round 1
  63   mixin(RIPEMD160_FF!("aa", "bb", "cc", "dd", "ee", "X[ 0]", "11"));
  64   mixin(RIPEMD160_FF!("ee", "aa", "bb", "cc", "dd", "X[ 1]", "14"));
  65   mixin(RIPEMD160_FF!("dd", "ee", "aa", "bb", "cc", "X[ 2]", "15"));
  66   mixin(RIPEMD160_FF!("cc", "dd", "ee", "aa", "bb", "X[ 3]", "12"));
  67   mixin(RIPEMD160_FF!("bb", "cc", "dd", "ee", "aa", "X[ 4]", " 5"));
  68   mixin(RIPEMD160_FF!("aa", "bb", "cc", "dd", "ee", "X[ 5]", " 8"));
  69   mixin(RIPEMD160_FF!("ee", "aa", "bb", "cc", "dd", "X[ 6]", " 7"));
  70   mixin(RIPEMD160_FF!("dd", "ee", "aa", "bb", "cc", "X[ 7]", " 9"));
  71   mixin(RIPEMD160_FF!("cc", "dd", "ee", "aa", "bb", "X[ 8]", "11"));
  72   mixin(RIPEMD160_FF!("bb", "cc", "dd", "ee", "aa", "X[ 9]", "13"));
  73   mixin(RIPEMD160_FF!("aa", "bb", "cc", "dd", "ee", "X[10]", "14"));
  74   mixin(RIPEMD160_FF!("ee", "aa", "bb", "cc", "dd", "X[11]", "15"));
  75   mixin(RIPEMD160_FF!("dd", "ee", "aa", "bb", "cc", "X[12]", " 6"));
  76   mixin(RIPEMD160_FF!("cc", "dd", "ee", "aa", "bb", "X[13]", " 7"));
  77   mixin(RIPEMD160_FF!("bb", "cc", "dd", "ee", "aa", "X[14]", " 9"));
  78   mixin(RIPEMD160_FF!("aa", "bb", "cc", "dd", "ee", "X[15]", " 8"));
  79
  80   // round 2
  81   mixin(RIPEMD160_GG!("ee", "aa", "bb", "cc", "dd", "X[ 7]", " 7"));
  82   mixin(RIPEMD160_GG!("dd", "ee", "aa", "bb", "cc", "X[ 4]", " 6"));
  83   mixin(RIPEMD160_GG!("cc", "dd", "ee", "aa", "bb", "X[13]", " 8"));
  84   mixin(RIPEMD160_GG!("bb", "cc", "dd", "ee", "aa", "X[ 1]", "13"));
  85   mixin(RIPEMD160_GG!("aa", "bb", "cc", "dd", "ee", "X[10]", "11"));
  86   mixin(RIPEMD160_GG!("ee", "aa", "bb", "cc", "dd", "X[ 6]", " 9"));
  87   mixin(RIPEMD160_GG!("dd", "ee", "aa", "bb", "cc", "X[15]", " 7"));
  88   mixin(RIPEMD160_GG!("cc", "dd", "ee", "aa", "bb", "X[ 3]", "15"));
  89   mixin(RIPEMD160_GG!("bb", "cc", "dd", "ee", "aa", "X[12]", " 7"));
  90   mixin(RIPEMD160_GG!("aa", "bb", "cc", "dd", "ee", "X[ 0]", "12"));
  91   mixin(RIPEMD160_GG!("ee", "aa", "bb", "cc", "dd", "X[ 9]", "15"));
  92   mixin(RIPEMD160_GG!("dd", "ee", "aa", "bb", "cc", "X[ 5]", " 9"));
  93   mixin(RIPEMD160_GG!("cc", "dd", "ee", "aa", "bb", "X[ 2]", "11"));
  94   mixin(RIPEMD160_GG!("bb", "cc", "dd", "ee", "aa", "X[14]", " 7"));
  95   mixin(RIPEMD160_GG!("aa", "bb", "cc", "dd", "ee", "X[11]", "13"));
  96   mixin(RIPEMD160_GG!("ee", "aa", "bb", "cc", "dd", "X[ 8]", "12"));
  97
  98   // round 3
  99   mixin(RIPEMD160_HH!("dd", "ee", "aa", "bb", "cc", "X[ 3]", "11"));
 100   mixin(RIPEMD160_HH!("cc", "dd", "ee", "aa", "bb", "X[10]", "13"));
 101   mixin(RIPEMD160_HH!("bb", "cc", "dd", "ee", "aa", "X[14]", " 6"));
 102   mixin(RIPEMD160_HH!("aa", "bb", "cc", "dd", "ee", "X[ 4]", " 7"));
 103   mixin(RIPEMD160_HH!("ee", "aa", "bb", "cc", "dd", "X[ 9]", "14"));
 104   mixin(RIPEMD160_HH!("dd", "ee", "aa", "bb", "cc", "X[15]", " 9"));
 105   mixin(RIPEMD160_HH!("cc", "dd", "ee", "aa", "bb", "X[ 8]", "13"));
 106   mixin(RIPEMD160_HH!("bb", "cc", "dd", "ee", "aa", "X[ 1]", "15"));
 107   mixin(RIPEMD160_HH!("aa", "bb", "cc", "dd", "ee", "X[ 2]", "14"));
 108   mixin(RIPEMD160_HH!("ee", "aa", "bb", "cc", "dd", "X[ 7]", " 8"));
 109   mixin(RIPEMD160_HH!("dd", "ee", "aa", "bb", "cc", "X[ 0]", "13"));
 110   mixin(RIPEMD160_HH!("cc", "dd", "ee", "aa", "bb", "X[ 6]", " 6"));
 111   mixin(RIPEMD160_HH!("bb", "cc", "dd", "ee", "aa", "X[13]", " 5"));
 112   mixin(RIPEMD160_HH!("aa", "bb", "cc", "dd", "ee", "X[11]", "12"));
 113   mixin(RIPEMD160_HH!("ee", "aa", "bb", "cc", "dd", "X[ 5]", " 7"));
 114   mixin(RIPEMD160_HH!("dd", "ee", "aa", "bb", "cc", "X[12]", " 5"));
 115
 116   // round 4
 117   mixin(RIPEMD160_II!("cc", "dd", "ee", "aa", "bb", "X[ 1]", "11"));
 118   mixin(RIPEMD160_II!("bb", "cc", "dd", "ee", "aa", "X[ 9]", "12"));
 119   mixin(RIPEMD160_II!("aa", "bb", "cc", "dd", "ee", "X[11]", "14"));
 120   mixin(RIPEMD160_II!("ee", "aa", "bb", "cc", "dd", "X[10]", "15"));
 121   mixin(RIPEMD160_II!("dd", "ee", "aa", "bb", "cc", "X[ 0]", "14"));
 122   mixin(RIPEMD160_II!("cc", "dd", "ee", "aa", "bb", "X[ 8]", "15"));
 123   mixin(RIPEMD160_II!("bb", "cc", "dd", "ee", "aa", "X[12]", " 9"));
 124   mixin(RIPEMD160_II!("aa", "bb", "cc", "dd", "ee", "X[ 4]", " 8"));
 125   mixin(RIPEMD160_II!("ee", "aa", "bb", "cc", "dd", "X[13]", " 9"));
 126   mixin(RIPEMD160_II!("dd", "ee", "aa", "bb", "cc", "X[ 3]", "14"));
 127   mixin(RIPEMD160_II!("cc", "dd", "ee", "aa", "bb", "X[ 7]", " 5"));
 128   mixin(RIPEMD160_II!("bb", "cc", "dd", "ee", "aa", "X[15]", " 6"));
 129   mixin(RIPEMD160_II!("aa", "bb", "cc", "dd", "ee", "X[14]", " 8"));
 130   mixin(RIPEMD160_II!("ee", "aa", "bb", "cc", "dd", "X[ 5]", " 6"));
 131   mixin(RIPEMD160_II!("dd", "ee", "aa", "bb", "cc", "X[ 6]", " 5"));
 132   mixin(RIPEMD160_II!("cc", "dd", "ee", "aa", "bb", "X[ 2]", "12"));
 133
 134   // round 5
 135   mixin(RIPEMD160_JJ!("bb", "cc", "dd", "ee", "aa", "X[ 4]", " 9"));
 136   mixin(RIPEMD160_JJ!("aa", "bb", "cc", "dd", "ee", "X[ 0]", "15"));
 137   mixin(RIPEMD160_JJ!("ee", "aa", "bb", "cc", "dd", "X[ 5]", " 5"));
 138   mixin(RIPEMD160_JJ!("dd", "ee", "aa", "bb", "cc", "X[ 9]", "11"));
 139   mixin(RIPEMD160_JJ!("cc", "dd", "ee", "aa", "bb", "X[ 7]", " 6"));
 140   mixin(RIPEMD160_JJ!("bb", "cc", "dd", "ee", "aa", "X[12]", " 8"));
 141   mixin(RIPEMD160_JJ!("aa", "bb", "cc", "dd", "ee", "X[ 2]", "13"));
 142   mixin(RIPEMD160_JJ!("ee", "aa", "bb", "cc", "dd", "X[10]", "12"));
 143   mixin(RIPEMD160_JJ!("dd", "ee", "aa", "bb", "cc", "X[14]", " 5"));
 144   mixin(RIPEMD160_JJ!("cc", "dd", "ee", "aa", "bb", "X[ 1]", "12"));
 145   mixin(RIPEMD160_JJ!("bb", "cc", "dd", "ee", "aa", "X[ 3]", "13"));
 146   mixin(RIPEMD160_JJ!("aa", "bb", "cc", "dd", "ee", "X[ 8]", "14"));
 147   mixin(RIPEMD160_JJ!("ee", "aa", "bb", "cc", "dd", "X[11]", "11"));
 148   mixin(RIPEMD160_JJ!("dd", "ee", "aa", "bb", "cc", "X[ 6]", " 8"));
 149   mixin(RIPEMD160_JJ!("cc", "dd", "ee", "aa", "bb", "X[15]", " 5"));
 150   mixin(RIPEMD160_JJ!("bb", "cc", "dd", "ee", "aa", "X[13]", " 6"));
 151
 152   // parallel round 1
 153   mixin(RIPEMD160_JJJ!("aaa", "bbb", "ccc", "ddd", "eee", "X[ 5]", " 8"));
 154   mixin(RIPEMD160_JJJ!("eee", "aaa", "bbb", "ccc", "ddd", "X[14]", " 9"));
 155   mixin(RIPEMD160_JJJ!("ddd", "eee", "aaa", "bbb", "ccc", "X[ 7]", " 9"));
 156   mixin(RIPEMD160_JJJ!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 0]", "11"));
 157   mixin(RIPEMD160_JJJ!("bbb", "ccc", "ddd", "eee", "aaa", "X[ 9]", "13"));
 158   mixin(RIPEMD160_JJJ!("aaa", "bbb", "ccc", "ddd", "eee", "X[ 2]", "15"));
 159   mixin(RIPEMD160_JJJ!("eee", "aaa", "bbb", "ccc", "ddd", "X[11]", "15"));
 160   mixin(RIPEMD160_JJJ!("ddd", "eee", "aaa", "bbb", "ccc", "X[ 4]", " 5"));
 161   mixin(RIPEMD160_JJJ!("ccc", "ddd", "eee", "aaa", "bbb", "X[13]", " 7"));
 162   mixin(RIPEMD160_JJJ!("bbb", "ccc", "ddd", "eee", "aaa", "X[ 6]", " 7"));
 163   mixin(RIPEMD160_JJJ!("aaa", "bbb", "ccc", "ddd", "eee", "X[15]", " 8"));
 164   mixin(RIPEMD160_JJJ!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 8]", "11"));
 165   mixin(RIPEMD160_JJJ!("ddd", "eee", "aaa", "bbb", "ccc", "X[ 1]", "14"));
 166   mixin(RIPEMD160_JJJ!("ccc", "ddd", "eee", "aaa", "bbb", "X[10]", "14"));
 167   mixin(RIPEMD160_JJJ!("bbb", "ccc", "ddd", "eee", "aaa", "X[ 3]", "12"));
 168   mixin(RIPEMD160_JJJ!("aaa", "bbb", "ccc", "ddd", "eee", "X[12]", " 6"));
 169
 170   // parallel round 2
 171   mixin(RIPEMD160_III!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 6]", " 9"));
 172   mixin(RIPEMD160_III!("ddd", "eee", "aaa", "bbb", "ccc", "X[11]", "13"));
 173   mixin(RIPEMD160_III!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 3]", "15"));
 174   mixin(RIPEMD160_III!("bbb", "ccc", "ddd", "eee", "aaa", "X[ 7]", " 7"));
 175   mixin(RIPEMD160_III!("aaa", "bbb", "ccc", "ddd", "eee", "X[ 0]", "12"));
 176   mixin(RIPEMD160_III!("eee", "aaa", "bbb", "ccc", "ddd", "X[13]", " 8"));
 177   mixin(RIPEMD160_III!("ddd", "eee", "aaa", "bbb", "ccc", "X[ 5]", " 9"));
 178   mixin(RIPEMD160_III!("ccc", "ddd", "eee", "aaa", "bbb", "X[10]", "11"));
 179   mixin(RIPEMD160_III!("bbb", "ccc", "ddd", "eee", "aaa", "X[14]", " 7"));
 180   mixin(RIPEMD160_III!("aaa", "bbb", "ccc", "ddd", "eee", "X[15]", " 7"));
 181   mixin(RIPEMD160_III!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 8]", "12"));
 182   mixin(RIPEMD160_III!("ddd", "eee", "aaa", "bbb", "ccc", "X[12]", " 7"));
 183   mixin(RIPEMD160_III!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 4]", " 6"));
 184   mixin(RIPEMD160_III!("bbb", "ccc", "ddd", "eee", "aaa", "X[ 9]", "15"));
 185   mixin(RIPEMD160_III!("aaa", "bbb", "ccc", "ddd", "eee", "X[ 1]", "13"));
 186   mixin(RIPEMD160_III!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 2]", "11"));
 187
 188   // parallel round 3
 189   mixin(RIPEMD160_HHH!("ddd", "eee", "aaa", "bbb", "ccc", "X[15]", " 9"));
 190   mixin(RIPEMD160_HHH!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 5]", " 7"));
 191   mixin(RIPEMD160_HHH!("bbb", "ccc", "ddd", "eee", "aaa", "X[ 1]", "15"));
 192   mixin(RIPEMD160_HHH!("aaa", "bbb", "ccc", "ddd", "eee", "X[ 3]", "11"));
 193   mixin(RIPEMD160_HHH!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 7]", " 8"));
 194   mixin(RIPEMD160_HHH!("ddd", "eee", "aaa", "bbb", "ccc", "X[14]", " 6"));
 195   mixin(RIPEMD160_HHH!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 6]", " 6"));
 196   mixin(RIPEMD160_HHH!("bbb", "ccc", "ddd", "eee", "aaa", "X[ 9]", "14"));
 197   mixin(RIPEMD160_HHH!("aaa", "bbb", "ccc", "ddd", "eee", "X[11]", "12"));
 198   mixin(RIPEMD160_HHH!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 8]", "13"));
 199   mixin(RIPEMD160_HHH!("ddd", "eee", "aaa", "bbb", "ccc", "X[12]", " 5"));
 200   mixin(RIPEMD160_HHH!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 2]", "14"));
 201   mixin(RIPEMD160_HHH!("bbb", "ccc", "ddd", "eee", "aaa", "X[10]", "13"));
 202   mixin(RIPEMD160_HHH!("aaa", "bbb", "ccc", "ddd", "eee", "X[ 0]", "13"));
 203   mixin(RIPEMD160_HHH!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 4]", " 7"));
 204   mixin(RIPEMD160_HHH!("ddd", "eee", "aaa", "bbb", "ccc", "X[13]", " 5"));
 205
 206   // parallel round 4
 207   mixin(RIPEMD160_GGG!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 8]", "15"));
 208   mixin(RIPEMD160_GGG!("bbb", "ccc", "ddd", "eee", "aaa", "X[ 6]", " 5"));
 209   mixin(RIPEMD160_GGG!("aaa", "bbb", "ccc", "ddd", "eee", "X[ 4]", " 8"));
 210   mixin(RIPEMD160_GGG!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 1]", "11"));
 211   mixin(RIPEMD160_GGG!("ddd", "eee", "aaa", "bbb", "ccc", "X[ 3]", "14"));
 212   mixin(RIPEMD160_GGG!("ccc", "ddd", "eee", "aaa", "bbb", "X[11]", "14"));
 213   mixin(RIPEMD160_GGG!("bbb", "ccc", "ddd", "eee", "aaa", "X[15]", " 6"));
 214   mixin(RIPEMD160_GGG!("aaa", "bbb", "ccc", "ddd", "eee", "X[ 0]", "14"));
 215   mixin(RIPEMD160_GGG!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 5]", " 6"));
 216   mixin(RIPEMD160_GGG!("ddd", "eee", "aaa", "bbb", "ccc", "X[12]", " 9"));
 217   mixin(RIPEMD160_GGG!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 2]", "12"));
 218   mixin(RIPEMD160_GGG!("bbb", "ccc", "ddd", "eee", "aaa", "X[13]", " 9"));
 219   mixin(RIPEMD160_GGG!("aaa", "bbb", "ccc", "ddd", "eee", "X[ 9]", "12"));
 220   mixin(RIPEMD160_GGG!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 7]", " 5"));
 221   mixin(RIPEMD160_GGG!("ddd", "eee", "aaa", "bbb", "ccc", "X[10]", "15"));
 222   mixin(RIPEMD160_GGG!("ccc", "ddd", "eee", "aaa", "bbb", "X[14]", " 8"));
 223
 224   // parallel round 5
 225   mixin(RIPEMD160_FFF!("bbb", "ccc", "ddd", "eee", "aaa", "X[12] ", " 8"));
 226   mixin(RIPEMD160_FFF!("aaa", "bbb", "ccc", "ddd", "eee", "X[15] ", " 5"));
 227   mixin(RIPEMD160_FFF!("eee", "aaa", "bbb", "ccc", "ddd", "X[10] ", "12"));
 228   mixin(RIPEMD160_FFF!("ddd", "eee", "aaa", "bbb", "ccc", "X[ 4] ", " 9"));
 229   mixin(RIPEMD160_FFF!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 1] ", "12"));
 230   mixin(RIPEMD160_FFF!("bbb", "ccc", "ddd", "eee", "aaa", "X[ 5] ", " 5"));
 231   mixin(RIPEMD160_FFF!("aaa", "bbb", "ccc", "ddd", "eee", "X[ 8] ", "14"));
 232   mixin(RIPEMD160_FFF!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 7] ", " 6"));
 233   mixin(RIPEMD160_FFF!("ddd", "eee", "aaa", "bbb", "ccc", "X[ 6] ", " 8"));
 234   mixin(RIPEMD160_FFF!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 2] ", "13"));
 235   mixin(RIPEMD160_FFF!("bbb", "ccc", "ddd", "eee", "aaa", "X[13] ", " 6"));
 236   mixin(RIPEMD160_FFF!("aaa", "bbb", "ccc", "ddd", "eee", "X[14] ", " 5"));
 237   mixin(RIPEMD160_FFF!("eee", "aaa", "bbb", "ccc", "ddd", "X[ 0] ", "15"));
 238   mixin(RIPEMD160_FFF!("ddd", "eee", "aaa", "bbb", "ccc", "X[ 3] ", "13"));
 239   mixin(RIPEMD160_FFF!("ccc", "ddd", "eee", "aaa", "bbb", "X[ 9] ", "11"));
 240   mixin(RIPEMD160_FFF!("bbb", "ccc", "ddd", "eee", "aaa", "X[11] ", "11"));
 241
 242   // combine results
 243   ddd += cc+wkbuf[1]; // final result for wkbuf[0]
 244   wkbuf[1] = wkbuf[2]+dd+eee;
 245   wkbuf[2] = wkbuf[3]+ee+aaa;
 246   wkbuf[3] = wkbuf[4]+aa+bbb;
 247   wkbuf[4] = wkbuf[0]+bb+ccc;
 248   wkbuf[0] = ddd;
 249 }
 250
 251
 252 // ////////////////////////////////////////////////////////////////////////// //
 253 public void ripemd160_init (ref RIPEMD160_Ctx ctx) nothrow @trusted @nogc {
 254   import core.stdc.string : memset;
 255   memset(cast(void*)&ctx, 0, RIPEMD160_Ctx.sizeof);
 256   ctx.wkbuf.ptr[0] = 0x67452301U;
 257   ctx.wkbuf.ptr[1] = 0xefcdab89U;
 258   ctx.wkbuf.ptr[2] = 0x98badcfeU;
 259   ctx.wkbuf.ptr[3] = 0x10325476U;
 260   ctx.wkbuf.ptr[4] = 0xc3d2e1f0U;
 261 }
 262
 263
 264 // ////////////////////////////////////////////////////////////////////////// //
 265 public void ripemd160_putbyte (ref RIPEMD160_Ctx ctx, in ubyte b) nothrow @trusted @nogc {
 266   pragma(inline, true);
 267   version(BigEndian) {
 268     (cast(uint*)ctx.chunkd.ptr)[ctx.chunkpos>>2] |= (cast(uint)b)<<((ctx.chunkpos&0x03U)<<3);
 269   } else {
 270     ctx.chunkd.ptr[ctx.chunkpos] = b;
 271   }
 272   if (++ctx.chunkpos == 64U) {
 273     ripemd160_compress(ctx.wkbuf.ptr, cast(const uint*)ctx.chunkd.ptr);
 274     version(BigEndian) {
 275       import core.stdc.string : memset;
 276       memset(ctx.chunkd.ptr, 0, ctx.chunkd.sizeof);
 277     }
 278     ctx.chunkpos = 0U;
 279   }
 280 }
 281
 282
 283 // ////////////////////////////////////////////////////////////////////////// //
 284 public void ripemd160_put (ref RIPEMD160_Ctx ctx, const(void)[] data) nothrow @trusted @nogc {
 285   if (data.length == 0) return;
 286   static if ((void*).sizeof <= 4) {
 287     if (ctx.total+data.length <= ctx.total) ++ctx.totalhi;
 288     ctx.total += data.length;
 289   } else {
 290     if (ctx.total+cast(uint)data.length <= ctx.total) ++ctx.totalhi;
 291     ctx.total += cast(uint)data.length;
 292     ctx.totalhi += cast(uint)(data.length>>32);
 293   }
 294   const(ubyte)* b = cast(const(ubyte)*)data.ptr;
 295   usize datasize = data.length;
 296   version(BigEndian) {
 297     while (datasize--) ripemd160_putbyte(ctx, *b++);
 298   } else {
 299     // process full chunks, if possible
 300     if (ctx.chunkpos == 0 && datasize >= cast(usize)64) {
 301       do {
 302         ripemd160_compress(ctx.wkbuf.ptr, cast(const uint*)b);
 303         b += 64;
 304       } while ((datasize -= cast(usize)64) >= cast(usize)64);
 305       if (datasize == 0) return;
 306     }
 307     // we can use `memcpy()` here
 308     import core.stdc.string : memcpy, memset;
 309     uint left = 64U-ctx.chunkpos;
 310     if (cast(usize)left > datasize) left = cast(uint)datasize;
 311     memcpy(ctx.chunkd.ptr+ctx.chunkpos, b, cast(usize)left);
 312     if ((ctx.chunkpos += left) == 64U) {
 313       ripemd160_compress(ctx.wkbuf.ptr, cast(const uint*)ctx.chunkd.ptr);
 314       b += left;
 315       datasize -= cast(usize)left;
 316       while (datasize >= cast(usize)64) {
 317         ripemd160_compress(ctx.wkbuf.ptr, cast(const uint*)b);
 318         b += 64;
 319         datasize -= 64;
 320       }
 321       if ((ctx.chunkpos = cast(uint)datasize) != 0) memcpy(ctx.chunkd.ptr, b, datasize);
 322     } else {
 323       // this is invariant
 324       version(none) {
 325         datasize -= cast(usize)left;
 326         if (datasize) assert(0);
 327       }
 328     }
 329   }
 330 }
 331
 332
 333 // ////////////////////////////////////////////////////////////////////////// //
 334 public ubyte[RIPEMD160_BYTES] ripemd160_finish (const ref RIPEMD160_Ctx ctx) nothrow @trusted @nogc {
 335   import core.stdc.string : memcpy, memset;
 336
 337   RIPEMD160_Ctx rctx = void;
 338   memcpy(cast(void*)&rctx, cast(void*)&ctx, RIPEMD160_Ctx.sizeof);
 339
 340   // padding with `1` bit
 341   ripemd160_putbyte(ref rctx, 0x80);
 342   // length in bits goes into two last dwords
 343   version(BigEndian) {
 344     if (64U-rctx.chunkpos < 8U) {
 345       while (rctx.chunkpos) ripemd160_putbyte(&rctx, 0);
 346       ripemd160_compress(rctx.wkbuf.ptr, cast(const uint*)rctx.chunkd.ptr);
 347       memset(rctx.chunkd.ptr, 0, rctx.chunkd.sizeof);
 348     }
 349     // chunk is guaranteed to be properly cleared here
 350     immutable uint t0 = ctx.total<<3;
 351     rctx.chunkd.ptr[56U] = t0&0xffU;
 352     rctx.chunkd.ptr[57U] = (t0>>8)&0xffU;
 353     rctx.chunkd.ptr[58U] = (t0>>16)&0xffU;
 354     rctx.chunkd.ptr[59U] = (t0>>24)&0xffU;
 355     immutable uint t1 = (ctx.total>>29)|(ctx.totalhi<<3);
 356     rctx.chunkd.ptr[60U] = t1&0xffU;
 357     rctx.chunkd.ptr[61U] = (t1>>8)&0xffU;
 358     rctx.chunkd.ptr[62U] = (t1>>16)&0xffU;
 359     rctx.chunkd.ptr[63U] = (t1>>24)&0xffU;
 360   } else {
 361     uint left = 64U-rctx.chunkpos;
 362     if (left < 8U) {
 363       if (left) memset(rctx.chunkd.ptr+64U-left, 0, left);
 364       ripemd160_compress(rctx.wkbuf.ptr, cast(const uint*)rctx.chunkd.ptr);
 365       left = 64U;
 366     }
 367     left -= 8U;
 368     if (left) memset(rctx.chunkd.ptr+64U-8U-left, 0, left);
 369     (cast(uint*)rctx.chunkd.ptr)[14] = ctx.total<<3;
 370     (cast(uint*)rctx.chunkd.ptr)[15] = (ctx.total>>29)|(ctx.totalhi<<3);
 371   }
 372   ripemd160_compress(rctx.wkbuf.ptr, cast(const uint*)rctx.chunkd);
 373
 374   ubyte[RIPEMD160_BYTES] hash = void;
 375   memcpy(hash.ptr, cast(void*)rctx.wkbuf.ptr, RIPEMD160_BYTES);
 376   return hash;
 377 }
 378
 379
 380 public int ripemd160_canput (const ref RIPEMD160_Ctx ctx, in usize datasize) pure nothrow @trusted @nogc {
 381   static if ((void*).sizeof <= 4) {
 382     return (ctx.totalhi < 0x1fffffffU+(ctx.total+datasize > ctx.total));
 383   } else {
 384     // totally untested
 385     immutable uint lo = cast(uint)datasize;
 386     immutable uint hi = cast(uint)(datasize>>32);
 387     if (ctx.totalhi+hi >= 0x20000000U) return 0;
 388     return ((hi+ctx.totalhi) < 0x1fffffffU+(ctx.total+lo > ctx.total));
 389   }
 390 }
 391
 392
 393 version(unittest_ripemd160)
 394 unittest {
 395   static void selftest_str (const(void)[] str, string res) {
 396     import core.stdc.stdio : snprintf;
 397     import core.stdc.string : memcmp;
 398     assert(res.length == RIPEMD160_BYTES*2);
 399
 400     RIPEMD160_Ctx ctx;
 401     ubyte[RIPEMD160_BYTES] hash;
 402     char[RIPEMD160_BYTES*2+2] hhex;
 403
 404     ripemd160_init(ref ctx);
 405     ripemd160_put(ref ctx, str[]);
 406     hash = ripemd160_finish(ref ctx);
 407     foreach (immutable c; 0..RIPEMD160_BYTES) snprintf(hhex.ptr+c*2, 3, "%02x", hash[c]);
 408
 409     if (memcmp(hhex.ptr, res.ptr, RIPEMD160_BYTES*2) != 0) {
 410       import core.stdc.stdio : stderr, fprintf;
 411       fprintf(stderr, "FAILURE!\n");
 412       fprintf(stderr, "string  : %.*s\n", cast(uint)str.length, str.ptr);
 413       fprintf(stderr, "result  : %s\n", hhex.ptr);
 414       fprintf(stderr, "expected: %.*s\n", cast(uint)res.length, res.ptr);
 415       assert(0);
 416     }
 417   }
 418
 419
 420   static void selftest (void) {
 421     selftest_str("", "9c1185a5c5e9fc54612808977ee8f548b2258d31");
 422     selftest_str("abcdefghijklmnopqrstuvwxyz", "f71c27109c692c1b56bbdceb5b9d2865b3708dbc");
 423
 424     selftest_str("a", "0bdc9d2d256b3ee9daae347be6f4dc835a467ffe");
 425     selftest_str("abc", "8eb208f7e05d987a9b044a8e98c6b087f15a0bfc");
 426     selftest_str("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "12a053384a9c0c88e405a06c27dcf49ada62eb2b");
 427     selftest_str("message digest", "5d0689ef49d2fae572b881b123a85ffa21595f36");
 428     selftest_str("abcdefghijklmnopqrstuvwxyz", "f71c27109c692c1b56bbdceb5b9d2865b3708dbc");
 429     selftest_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", "b0e20b6e3116640286ed3a87a5713079b21f5189");
 430     selftest_str("1234567890123456789012345678901234567890"~"1234567890123456789012345678901234567890", "9b752e45573d4b39f4dbd3323cab82bf63326bfb");
 431
 432     selftest_str(
 433       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"~
 434       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"~
 435       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"~
 436       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"~
 437       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"~
 438       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"~
 439       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"~
 440       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
 441       , "160dd118d84b2ceff71261ab78fb9239e257c8d3");
 442
 443     // 160 zero bits
 444     char[160/8] zero = 0;
 445     selftest_str(zero[], "5c00bd4aca04a9057c09b20b05f723f2e23deb65");
 446
 447     selftest_str("Alice", "b417ed99b95ce21448b7d789c50009e4f088e3a7");
 448     selftest_str("Miriel", "c95659db5eb45fe56023c073e96ca597347860d9");
 449   }
 450
 451   selftest();
 452 }