git.sesse.net Git - freerainbowtables/blob - Client Applications/rcracki_mt/md4.cpp

   1 /*
   2  * rcracki_mt is a multithreaded implementation and fork of the original
   3  * RainbowCrack
   4  *
   5  * Copyright Bitweasil
   6  * Copyright 2009, 2010 Daniël Niggebrugge <niggebrugge@fox-it.com>
   7  * Copyright 2009, 2010 James Nobis <frt@quelrod.net>
   8  *
   9  * This file is part of rcracki_mt.
  10  *
  11  * rcracki_mt is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation, either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * rcracki_mt is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with rcracki_mt.  If not, see <http://www.gnu.org/licenses/>.
  23  *
  24  * This code implements the MD4 message-digest algorithm.
  25  * "Just the reference implementation, single stage. Hardly "optimized." Though a good bit faster than libssl's MD4, as it isn't doing nearly the same amount of work." - Bitweasil
  26  *
  27  * little bit optimized (or at least attempted) for NTLM (unicode) by neinbrucke
  28  */
  29
  30
  31 //#include <cstdlib>
  32 //#include <cstring>
  33 #include "md4.h"
  34
  35 /* MD4 Defines as per RFC reference implementation */
  36 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  37 #define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
  38 #define H(x, y, z) ((x) ^ (y) ^ (z))
  39 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
  40 #define FF(a, b, c, d, x, s) { \
  41                 (a) += F ((b), (c), (d)) + (x); \
  42                 (a) = ROTATE_LEFT ((a), (s)); \
  43         }
  44 #define GG(a, b, c, d, x, s) { \
  45                 (a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; \
  46                 (a) = ROTATE_LEFT ((a), (s)); \
  47         }
  48 #define HH(a, b, c, d, x, s) { \
  49                 (a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; \
  50                 (a) = ROTATE_LEFT ((a), (s)); \
  51         }
  52 #define S11 3
  53 #define S12 7
  54 #define S13 11
  55 #define S14 19
  56 #define S21 3
  57 #define S22 5
  58 #define S23 9
  59 #define S24 13
  60 #define S31 3
  61 #define S32 9
  62 #define S33 11
  63 #define S34 15
  64 /* End MD4 Defines */
  65
  66 void MD4_NEW( unsigned char * pData, int length, unsigned char * pDigest)
  67 {
  68         // access data as 4-byte word
  69         #define uData                           ((UINT4 *)pData)
  70         #define uDigest                         ((UINT4 *)pDigest)
  71
  72         // pad word and append bit at appropriate location
  73         #define MD4_pad_w0()            (0x00000080)
  74         #define MD4_pad_w1(data)        (((data) & 0x000000FF) | 0x00008000)
  75         #define MD4_pad_w2(data)        (((data) & 0x0000FFFF) | 0x00800000)
  76         #define MD4_pad_w3(data)        (((data) & 0x00FFFFFF) | 0x80000000)
  77
  78         // For the hash working space
  79         //__attribute__((aligned(16))) UINT4 data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  80         //__declspec(align(16)) UINT4 data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  81         UINT4 data[MD4_DIGEST_LENGTH] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  82
  83         // For the output result
  84         UINT4 a,b,c,d;
  85
  86         switch (length)
  87         {
  88                 case 0:
  89                 {
  90                         data[ 0] = MD4_pad_w0();
  91
  92                         data[14] = 0;
  93                 }
  94                 break;
  95                 case 1:
  96                 {
  97                         data[ 0] = MD4_pad_w1(uData[0]);
  98
  99                         data[14] = 1 << 3;
 100                 }
 101                 break;
 102                 case 2:
 103                 {
 104                         data[ 0] = MD4_pad_w2(uData[0]);
 105
 106                         data[14] = 2 << 3;
 107                 }
 108                 break;
 109                 case 3:
 110                 {
 111                         data[ 0] = MD4_pad_w3(uData[0]);
 112
 113                         data[14] = 3 << 3;
 114                 }
 115                 break;
 116                 case 4:
 117                 {
 118                         data[ 0] = uData[0];
 119                         data[ 1] = MD4_pad_w0();
 120
 121                         data[14] = 4 << 3;
 122                 }
 123                 break;
 124                 case 5:
 125                 {
 126                         data[ 0] = uData[0];
 127                         data[ 1] = MD4_pad_w1(uData[1]);
 128
 129                         data[14] = 5 << 3;
 130                 }
 131                 break;
 132                 case 6:
 133                 {
 134                         data[ 0] = uData[0];
 135                         data[ 1] = MD4_pad_w2(uData[1]);
 136
 137                         data[14] = 6 << 3;
 138                 }
 139                 break;
 140                 case 7:
 141                 {
 142                         data[ 0] = uData[0];
 143                         data[ 1] = MD4_pad_w3(uData[1]);
 144
 145                         data[14] = 7 << 3;
 146                 }
 147                 break;
 148                 case 8:
 149                 {
 150                         data[ 0] = uData[0];
 151                         data[ 1] = uData[1];
 152                         data[ 2] = MD4_pad_w0();
 153
 154                         data[14] = 8 << 3;
 155                 }
 156                 break;
 157                 case 9:
 158                 {
 159                         data[ 0] = uData[0];
 160                         data[ 1] = uData[1];
 161                         data[ 2] = MD4_pad_w1(uData[2]);
 162
 163                         data[14] = 9 << 3;
 164                 }
 165                 break;
 166                 case 10:
 167                 {
 168                         data[ 0] = uData[0];
 169                         data[ 1] = uData[1];
 170                         data[ 2] = MD4_pad_w2(uData[2]);
 171
 172                         data[14] = 10 << 3;
 173                 }
 174                 break;
 175                 case 11:
 176                 {
 177                         data[ 0] = uData[0];
 178                         data[ 1] = uData[1];
 179                         data[ 2] = MD4_pad_w3(uData[2]);
 180
 181                         data[14] = 11 << 3;
 182                 }
 183                 break;
 184                 case 12:
 185                 {
 186                         data[ 0] = uData[0];
 187                         data[ 1] = uData[1];
 188                         data[ 2] = uData[2];
 189                         data[ 3] = MD4_pad_w0();
 190
 191                         data[14] = 12 << 3;
 192                 }
 193                 break;
 194                 case 13:
 195                 {
 196                         data[ 0] = uData[0];
 197                         data[ 1] = uData[1];
 198                         data[ 2] = uData[2];
 199                         data[ 3] = MD4_pad_w1(uData[3]);
 200
 201                         data[14] = 13 << 3;
 202                 }
 203                 break;
 204                 case 14:
 205                 {
 206                         data[ 0] = uData[0];
 207                         data[ 1] = uData[1];
 208                         data[ 2] = uData[2];
 209                         data[ 3] = MD4_pad_w2(uData[3]);
 210
 211                         data[14] = 14 << 3;
 212                 }
 213                 break;
 214                 case 15:
 215                 {
 216                         data[ 0] = uData[0];
 217                         data[ 1] = uData[1];
 218                         data[ 2] = uData[2];
 219                         data[ 3] = MD4_pad_w3(uData[3]);
 220
 221                         data[14] = 15 << 3;
 222                 }
 223                 break;
 224
 225                 default:
 226                 {
 227                         length = length % 32; // lenght >= 32 not suported
 228
 229                         int word = length >> 2;
 230
 231                         int i = 0;
 232                         while (i < word) {
 233                                 data[i] = uData[i];
 234                                 i++;
 235                         }
 236
 237                         switch (length & 0x3) {
 238                                 case 0:
 239                                 {
 240                                         data[word] = MD4_pad_w0();
 241                                 }
 242                                 break;
 243                                 case 1:
 244                                 {
 245                                         data[word] = MD4_pad_w1(uData[word]);
 246                                 }
 247                                 break;
 248                                 case 2:
 249                                 {
 250                                         data[word] = MD4_pad_w2(uData[word]);
 251                                 }
 252                                 break;
 253                                 case 3:
 254                                 {
 255                                         data[word] = MD4_pad_w3(uData[word]);
 256                                 }
 257                                 break;
 258                         }
 259
 260                         data[14] = length << 3;
 261                 }
 262                 break;
 263         }
 264
 265         a = 0x67452301;
 266         b = 0xefcdab89;
 267         c = 0x98badcfe;
 268         d = 0x10325476;
 269
 270         /* Round 1 */
 271         FF (a, b, c, d, data[ 0], S11); /* 1 */
 272         FF (d, a, b, c, data[ 1], S12); /* 2 */
 273         FF (c, d, a, b, data[ 2], S13); /* 3 */
 274         FF (b, c, d, a, data[ 3], S14); /* 4 */
 275         FF (a, b, c, d, data[ 4], S11); /* 5 */
 276         FF (d, a, b, c, data[ 5], S12); /* 6 */
 277         FF (c, d, a, b, data[ 6], S13); /* 7 */
 278         FF (b, c, d, a, data[ 7], S14); /* 8 */
 279         FF (a, b, c, d,        0, S11); /* 9 */
 280         FF (d, a, b, c,        0, S12); /* 10 */
 281         FF (c, d, a, b,        0, S13); /* 11 */
 282         FF (b, c, d, a,        0, S14); /* 12 */
 283         FF (a, b, c, d,        0, S11); /* 13 */
 284         FF (d, a, b, c,        0, S12); /* 14 */
 285         FF (c, d, a, b, data[14], S13); /* 15 */
 286         FF (b, c, d, a,        0, S14); /* 16 */
 287
 288         /* Round 2 */
 289         GG (a, b, c, d, data[ 0], S21); /* 17 */
 290         GG (d, a, b, c, data[ 4], S22); /* 18 */
 291         GG (c, d, a, b,        0, S23); /* 19 */
 292         GG (b, c, d, a,        0, S24); /* 20 */
 293         GG (a, b, c, d, data[ 1], S21); /* 21 */
 294         GG (d, a, b, c, data[ 5], S22); /* 22 */
 295         GG (c, d, a, b,        0, S23); /* 23 */
 296         GG (b, c, d, a,        0, S24); /* 24 */
 297         GG (a, b, c, d, data[ 2], S21); /* 25 */
 298         GG (d, a, b, c, data[ 6], S22); /* 26 */
 299         GG (c, d, a, b,        0, S23); /* 27 */
 300         GG (b, c, d, a, data[14], S24); /* 28 */
 301         GG (a, b, c, d, data[ 3], S21); /* 29 */
 302         GG (d, a, b, c, data[ 7], S22); /* 30 */
 303         GG (c, d, a, b,        0, S23); /* 31 */
 304         GG (b, c, d, a,        0, S24); /* 32 */
 305
 306         /* Round 3 */
 307         HH (a, b, c, d, data[ 0], S31); /* 33 */
 308         HH (d, a, b, c,        0, S32); /* 34 */
 309         HH (c, d, a, b, data[ 4], S33); /* 35 */
 310         HH (b, c, d, a,        0, S34); /* 36 */
 311         HH (a, b, c, d, data[ 2], S31); /* 37 */
 312         HH (d, a, b, c,        0, S32); /* 38 */
 313         HH (c, d, a, b, data[ 6], S33); /* 39 */
 314         HH (b, c, d, a, data[14], S34); /* 40 */
 315         HH (a, b, c, d, data[ 1], S31); /* 41 */
 316         HH (d, a, b, c,        0, S32); /* 42 */
 317         HH (c, d, a, b, data[ 5], S33); /* 43 */
 318         HH (b, c, d, a,        0, S34); /* 44 */
 319         HH (a, b, c, d, data[ 3], S31); /* 45 */
 320         HH (d, a, b, c,        0, S32); /* 46 */
 321         HH (c, d, a, b, data[ 7], S33); /* 47 */
 322         HH (b, c, d, a,        0, S34); /* 48 */
 323
 324         // Finally, add initial values, as this is the only pass we make.
 325         a += 0x67452301;
 326         b += 0xefcdab89;
 327         c += 0x98badcfe;
 328         d += 0x10325476;
 329
 330         uDigest[0] = a;
 331         uDigest[1] = b;
 332         uDigest[2] = c;
 333         uDigest[3] = d;
 334 }