-/*\r
- * rcracki_mt is a multithreaded implementation and fork of the original \r
- * RainbowCrack\r
- *\r
- * Copyright Bitweasil\r
- * Copyright 2009, 2010 Daniël Niggebrugge <niggebrugge@fox-it.com>\r
- * Copyright 2009, 2010 James Nobis <frt@quelrod.net>\r
- *\r
- * This file is part of rcracki_mt.\r
- *\r
- * rcracki_mt is free software: you can redistribute it and/or modify\r
- * it under the terms of the GNU General Public License as published by\r
- * the Free Software Foundation, either version 2 of the License, or\r
- * (at your option) any later version.\r
- *\r
- * rcracki_mt is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
- * GNU General Public License for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License\r
- * along with rcracki_mt. If not, see <http://www.gnu.org/licenses/>.\r
- *\r
- * This code implements the MD4 message-digest algorithm.\r
- * "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\r
- * \r
- * little bit optimized (or at least attempted) for NTLM (unicode) by neinbrucke\r
- */\r
-\r
-\r
-//#include <cstdlib>\r
-//#include <cstring>\r
-#include "md4.h"\r
-\r
-/* MD4 Defines as per RFC reference implementation */\r
-#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))\r
-#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))\r
-#define H(x, y, z) ((x) ^ (y) ^ (z))\r
-#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))\r
-#define FF(a, b, c, d, x, s) { \\r
- (a) += F ((b), (c), (d)) + (x); \\r
- (a) = ROTATE_LEFT ((a), (s)); \\r
- }\r
-#define GG(a, b, c, d, x, s) { \\r
- (a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; \\r
- (a) = ROTATE_LEFT ((a), (s)); \\r
- }\r
-#define HH(a, b, c, d, x, s) { \\r
- (a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; \\r
- (a) = ROTATE_LEFT ((a), (s)); \\r
- }\r
-#define S11 3\r
-#define S12 7\r
-#define S13 11\r
-#define S14 19\r
-#define S21 3\r
-#define S22 5\r
-#define S23 9\r
-#define S24 13\r
-#define S31 3\r
-#define S32 9\r
-#define S33 11\r
-#define S34 15\r
-/* End MD4 Defines */\r
-\r
-void MD4_NEW( unsigned char * pData, int length, unsigned char * pDigest)\r
-{\r
- // access data as 4-byte word\r
- #define uData ((UINT4 *)pData)\r
- #define uDigest ((UINT4 *)pDigest)\r
-\r
- // pad word and append bit at appropriate location\r
- #define MD4_pad_w0() (0x00000080)\r
- #define MD4_pad_w1(data) (((data) & 0x000000FF) | 0x00008000)\r
- #define MD4_pad_w2(data) (((data) & 0x0000FFFF) | 0x00800000)\r
- #define MD4_pad_w3(data) (((data) & 0x00FFFFFF) | 0x80000000)\r
-\r
- // For the hash working space\r
- //__attribute__((aligned(16))) UINT4 data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};\r
- //__declspec(align(16)) UINT4 data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};\r
- UINT4 data[MD4_DIGEST_LENGTH] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};\r
-\r
- // For the output result\r
- UINT4 a,b,c,d;\r
-\r
- switch (length)\r
- {\r
- case 0:\r
- {\r
- data[ 0] = MD4_pad_w0();\r
-\r
- data[14] = 0;\r
- }\r
- break;\r
- case 1:\r
- {\r
- data[ 0] = MD4_pad_w1(uData[0]);\r
-\r
- data[14] = 1 << 3;\r
- }\r
- break;\r
- case 2:\r
- {\r
- data[ 0] = MD4_pad_w2(uData[0]);\r
-\r
- data[14] = 2 << 3;\r
- }\r
- break;\r
- case 3:\r
- {\r
- data[ 0] = MD4_pad_w3(uData[0]);\r
-\r
- data[14] = 3 << 3;\r
- }\r
- break;\r
- case 4:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = MD4_pad_w0();\r
-\r
- data[14] = 4 << 3;\r
- }\r
- break;\r
- case 5:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = MD4_pad_w1(uData[1]);\r
-\r
- data[14] = 5 << 3;\r
- }\r
- break;\r
- case 6:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = MD4_pad_w2(uData[1]);\r
-\r
- data[14] = 6 << 3;\r
- }\r
- break;\r
- case 7:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = MD4_pad_w3(uData[1]);\r
-\r
- data[14] = 7 << 3;\r
- }\r
- break;\r
- case 8:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = uData[1];\r
- data[ 2] = MD4_pad_w0();\r
-\r
- data[14] = 8 << 3;\r
- }\r
- break;\r
- case 9:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = uData[1];\r
- data[ 2] = MD4_pad_w1(uData[2]);\r
-\r
- data[14] = 9 << 3;\r
- }\r
- break;\r
- case 10:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = uData[1];\r
- data[ 2] = MD4_pad_w2(uData[2]);\r
-\r
- data[14] = 10 << 3;\r
- }\r
- break;\r
- case 11:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = uData[1];\r
- data[ 2] = MD4_pad_w3(uData[2]);\r
-\r
- data[14] = 11 << 3;\r
- }\r
- break;\r
- case 12:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = uData[1];\r
- data[ 2] = uData[2];\r
- data[ 3] = MD4_pad_w0();\r
-\r
- data[14] = 12 << 3;\r
- }\r
- break;\r
- case 13:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = uData[1];\r
- data[ 2] = uData[2];\r
- data[ 3] = MD4_pad_w1(uData[3]);\r
-\r
- data[14] = 13 << 3;\r
- }\r
- break;\r
- case 14:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = uData[1];\r
- data[ 2] = uData[2];\r
- data[ 3] = MD4_pad_w2(uData[3]);\r
-\r
- data[14] = 14 << 3;\r
- }\r
- break;\r
- case 15:\r
- {\r
- data[ 0] = uData[0];\r
- data[ 1] = uData[1];\r
- data[ 2] = uData[2];\r
- data[ 3] = MD4_pad_w3(uData[3]);\r
-\r
- data[14] = 15 << 3;\r
- }\r
- break;\r
-\r
- default:\r
- {\r
- length = length % 32; // lenght >= 32 not suported\r
-\r
- int word = length >> 2;\r
-\r
- int i = 0;\r
- while (i < word) {\r
- data[i] = uData[i];\r
- i++;\r
- }\r
-\r
- switch (length & 0x3) {\r
- case 0:\r
- {\r
- data[word] = MD4_pad_w0();\r
- }\r
- break;\r
- case 1:\r
- {\r
- data[word] = MD4_pad_w1(uData[word]);\r
- }\r
- break;\r
- case 2:\r
- {\r
- data[word] = MD4_pad_w2(uData[word]);\r
- }\r
- break;\r
- case 3:\r
- {\r
- data[word] = MD4_pad_w3(uData[word]);\r
- }\r
- break;\r
- }\r
-\r
- data[14] = length << 3;\r
- }\r
- break;\r
- }\r
-\r
- a = 0x67452301;\r
- b = 0xefcdab89;\r
- c = 0x98badcfe;\r
- d = 0x10325476;\r
-\r
- /* Round 1 */\r
- FF (a, b, c, d, data[ 0], S11); /* 1 */\r
- FF (d, a, b, c, data[ 1], S12); /* 2 */\r
- FF (c, d, a, b, data[ 2], S13); /* 3 */\r
- FF (b, c, d, a, data[ 3], S14); /* 4 */\r
- FF (a, b, c, d, data[ 4], S11); /* 5 */\r
- FF (d, a, b, c, data[ 5], S12); /* 6 */\r
- FF (c, d, a, b, data[ 6], S13); /* 7 */\r
- FF (b, c, d, a, data[ 7], S14); /* 8 */\r
- FF (a, b, c, d, 0, S11); /* 9 */\r
- FF (d, a, b, c, 0, S12); /* 10 */\r
- FF (c, d, a, b, 0, S13); /* 11 */\r
- FF (b, c, d, a, 0, S14); /* 12 */\r
- FF (a, b, c, d, 0, S11); /* 13 */\r
- FF (d, a, b, c, 0, S12); /* 14 */\r
- FF (c, d, a, b, data[14], S13); /* 15 */\r
- FF (b, c, d, a, 0, S14); /* 16 */\r
-\r
- /* Round 2 */\r
- GG (a, b, c, d, data[ 0], S21); /* 17 */\r
- GG (d, a, b, c, data[ 4], S22); /* 18 */\r
- GG (c, d, a, b, 0, S23); /* 19 */\r
- GG (b, c, d, a, 0, S24); /* 20 */\r
- GG (a, b, c, d, data[ 1], S21); /* 21 */\r
- GG (d, a, b, c, data[ 5], S22); /* 22 */\r
- GG (c, d, a, b, 0, S23); /* 23 */\r
- GG (b, c, d, a, 0, S24); /* 24 */\r
- GG (a, b, c, d, data[ 2], S21); /* 25 */\r
- GG (d, a, b, c, data[ 6], S22); /* 26 */\r
- GG (c, d, a, b, 0, S23); /* 27 */\r
- GG (b, c, d, a, data[14], S24); /* 28 */\r
- GG (a, b, c, d, data[ 3], S21); /* 29 */\r
- GG (d, a, b, c, data[ 7], S22); /* 30 */\r
- GG (c, d, a, b, 0, S23); /* 31 */\r
- GG (b, c, d, a, 0, S24); /* 32 */\r
-\r
- /* Round 3 */\r
- HH (a, b, c, d, data[ 0], S31); /* 33 */\r
- HH (d, a, b, c, 0, S32); /* 34 */\r
- HH (c, d, a, b, data[ 4], S33); /* 35 */\r
- HH (b, c, d, a, 0, S34); /* 36 */\r
- HH (a, b, c, d, data[ 2], S31); /* 37 */\r
- HH (d, a, b, c, 0, S32); /* 38 */\r
- HH (c, d, a, b, data[ 6], S33); /* 39 */\r
- HH (b, c, d, a, data[14], S34); /* 40 */\r
- HH (a, b, c, d, data[ 1], S31); /* 41 */\r
- HH (d, a, b, c, 0, S32); /* 42 */\r
- HH (c, d, a, b, data[ 5], S33); /* 43 */\r
- HH (b, c, d, a, 0, S34); /* 44 */\r
- HH (a, b, c, d, data[ 3], S31); /* 45 */\r
- HH (d, a, b, c, 0, S32); /* 46 */\r
- HH (c, d, a, b, data[ 7], S33); /* 47 */\r
- HH (b, c, d, a, 0, S34); /* 48 */\r
-\r
- // Finally, add initial values, as this is the only pass we make.\r
- a += 0x67452301;\r
- b += 0xefcdab89;\r
- c += 0x98badcfe;\r
- d += 0x10325476;\r
-\r
- uDigest[0] = a;\r
- uDigest[1] = b;\r
- uDigest[2] = c;\r
- uDigest[3] = d;\r
-}\r
+/*
+ * rcracki_mt is a multithreaded implementation and fork of the original
+ * RainbowCrack
+ *
+ * Copyright Bitweasil
+ * Copyright 2009, 2010 Daniël Niggebrugge <niggebrugge@fox-it.com>
+ * Copyright 2009, 2010 James Nobis <frt@quelrod.net>
+ *
+ * This file is part of rcracki_mt.
+ *
+ * rcracki_mt is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * rcracki_mt is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with rcracki_mt. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * This code implements the MD4 message-digest algorithm.
+ * "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
+ *
+ * little bit optimized (or at least attempted) for NTLM (unicode) by neinbrucke
+ */
+
+
+//#include <cstdlib>
+//#include <cstring>
+#include "md4.h"
+
+/* MD4 Defines as per RFC reference implementation */
+#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
+#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+#define FF(a, b, c, d, x, s) { \
+ (a) += F ((b), (c), (d)) + (x); \
+ (a) = ROTATE_LEFT ((a), (s)); \
+ }
+#define GG(a, b, c, d, x, s) { \
+ (a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; \
+ (a) = ROTATE_LEFT ((a), (s)); \
+ }
+#define HH(a, b, c, d, x, s) { \
+ (a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; \
+ (a) = ROTATE_LEFT ((a), (s)); \
+ }
+#define S11 3
+#define S12 7
+#define S13 11
+#define S14 19
+#define S21 3
+#define S22 5
+#define S23 9
+#define S24 13
+#define S31 3
+#define S32 9
+#define S33 11
+#define S34 15
+/* End MD4 Defines */
+
+void MD4_NEW( unsigned char * pData, int length, unsigned char * pDigest)
+{
+ // access data as 4-byte word
+ #define uData ((UINT4 *)pData)
+ #define uDigest ((UINT4 *)pDigest)
+
+ // pad word and append bit at appropriate location
+ #define MD4_pad_w0() (0x00000080)
+ #define MD4_pad_w1(data) (((data) & 0x000000FF) | 0x00008000)
+ #define MD4_pad_w2(data) (((data) & 0x0000FFFF) | 0x00800000)
+ #define MD4_pad_w3(data) (((data) & 0x00FFFFFF) | 0x80000000)
+
+ // For the hash working space
+ //__attribute__((aligned(16))) UINT4 data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+ //__declspec(align(16)) UINT4 data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+ UINT4 data[MD4_DIGEST_LENGTH] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+
+ // For the output result
+ UINT4 a,b,c,d;
+
+ switch (length)
+ {
+ case 0:
+ {
+ data[ 0] = MD4_pad_w0();
+
+ data[14] = 0;
+ }
+ break;
+ case 1:
+ {
+ data[ 0] = MD4_pad_w1(uData[0]);
+
+ data[14] = 1 << 3;
+ }
+ break;
+ case 2:
+ {
+ data[ 0] = MD4_pad_w2(uData[0]);
+
+ data[14] = 2 << 3;
+ }
+ break;
+ case 3:
+ {
+ data[ 0] = MD4_pad_w3(uData[0]);
+
+ data[14] = 3 << 3;
+ }
+ break;
+ case 4:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = MD4_pad_w0();
+
+ data[14] = 4 << 3;
+ }
+ break;
+ case 5:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = MD4_pad_w1(uData[1]);
+
+ data[14] = 5 << 3;
+ }
+ break;
+ case 6:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = MD4_pad_w2(uData[1]);
+
+ data[14] = 6 << 3;
+ }
+ break;
+ case 7:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = MD4_pad_w3(uData[1]);
+
+ data[14] = 7 << 3;
+ }
+ break;
+ case 8:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = uData[1];
+ data[ 2] = MD4_pad_w0();
+
+ data[14] = 8 << 3;
+ }
+ break;
+ case 9:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = uData[1];
+ data[ 2] = MD4_pad_w1(uData[2]);
+
+ data[14] = 9 << 3;
+ }
+ break;
+ case 10:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = uData[1];
+ data[ 2] = MD4_pad_w2(uData[2]);
+
+ data[14] = 10 << 3;
+ }
+ break;
+ case 11:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = uData[1];
+ data[ 2] = MD4_pad_w3(uData[2]);
+
+ data[14] = 11 << 3;
+ }
+ break;
+ case 12:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = uData[1];
+ data[ 2] = uData[2];
+ data[ 3] = MD4_pad_w0();
+
+ data[14] = 12 << 3;
+ }
+ break;
+ case 13:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = uData[1];
+ data[ 2] = uData[2];
+ data[ 3] = MD4_pad_w1(uData[3]);
+
+ data[14] = 13 << 3;
+ }
+ break;
+ case 14:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = uData[1];
+ data[ 2] = uData[2];
+ data[ 3] = MD4_pad_w2(uData[3]);
+
+ data[14] = 14 << 3;
+ }
+ break;
+ case 15:
+ {
+ data[ 0] = uData[0];
+ data[ 1] = uData[1];
+ data[ 2] = uData[2];
+ data[ 3] = MD4_pad_w3(uData[3]);
+
+ data[14] = 15 << 3;
+ }
+ break;
+
+ default:
+ {
+ length = length % 32; // lenght >= 32 not suported
+
+ int word = length >> 2;
+
+ int i = 0;
+ while (i < word) {
+ data[i] = uData[i];
+ i++;
+ }
+
+ switch (length & 0x3) {
+ case 0:
+ {
+ data[word] = MD4_pad_w0();
+ }
+ break;
+ case 1:
+ {
+ data[word] = MD4_pad_w1(uData[word]);
+ }
+ break;
+ case 2:
+ {
+ data[word] = MD4_pad_w2(uData[word]);
+ }
+ break;
+ case 3:
+ {
+ data[word] = MD4_pad_w3(uData[word]);
+ }
+ break;
+ }
+
+ data[14] = length << 3;
+ }
+ break;
+ }
+
+ a = 0x67452301;
+ b = 0xefcdab89;
+ c = 0x98badcfe;
+ d = 0x10325476;
+
+ /* Round 1 */
+ FF (a, b, c, d, data[ 0], S11); /* 1 */
+ FF (d, a, b, c, data[ 1], S12); /* 2 */
+ FF (c, d, a, b, data[ 2], S13); /* 3 */
+ FF (b, c, d, a, data[ 3], S14); /* 4 */
+ FF (a, b, c, d, data[ 4], S11); /* 5 */
+ FF (d, a, b, c, data[ 5], S12); /* 6 */
+ FF (c, d, a, b, data[ 6], S13); /* 7 */
+ FF (b, c, d, a, data[ 7], S14); /* 8 */
+ FF (a, b, c, d, 0, S11); /* 9 */
+ FF (d, a, b, c, 0, S12); /* 10 */
+ FF (c, d, a, b, 0, S13); /* 11 */
+ FF (b, c, d, a, 0, S14); /* 12 */
+ FF (a, b, c, d, 0, S11); /* 13 */
+ FF (d, a, b, c, 0, S12); /* 14 */
+ FF (c, d, a, b, data[14], S13); /* 15 */
+ FF (b, c, d, a, 0, S14); /* 16 */
+
+ /* Round 2 */
+ GG (a, b, c, d, data[ 0], S21); /* 17 */
+ GG (d, a, b, c, data[ 4], S22); /* 18 */
+ GG (c, d, a, b, 0, S23); /* 19 */
+ GG (b, c, d, a, 0, S24); /* 20 */
+ GG (a, b, c, d, data[ 1], S21); /* 21 */
+ GG (d, a, b, c, data[ 5], S22); /* 22 */
+ GG (c, d, a, b, 0, S23); /* 23 */
+ GG (b, c, d, a, 0, S24); /* 24 */
+ GG (a, b, c, d, data[ 2], S21); /* 25 */
+ GG (d, a, b, c, data[ 6], S22); /* 26 */
+ GG (c, d, a, b, 0, S23); /* 27 */
+ GG (b, c, d, a, data[14], S24); /* 28 */
+ GG (a, b, c, d, data[ 3], S21); /* 29 */
+ GG (d, a, b, c, data[ 7], S22); /* 30 */
+ GG (c, d, a, b, 0, S23); /* 31 */
+ GG (b, c, d, a, 0, S24); /* 32 */
+
+ /* Round 3 */
+ HH (a, b, c, d, data[ 0], S31); /* 33 */
+ HH (d, a, b, c, 0, S32); /* 34 */
+ HH (c, d, a, b, data[ 4], S33); /* 35 */
+ HH (b, c, d, a, 0, S34); /* 36 */
+ HH (a, b, c, d, data[ 2], S31); /* 37 */
+ HH (d, a, b, c, 0, S32); /* 38 */
+ HH (c, d, a, b, data[ 6], S33); /* 39 */
+ HH (b, c, d, a, data[14], S34); /* 40 */
+ HH (a, b, c, d, data[ 1], S31); /* 41 */
+ HH (d, a, b, c, 0, S32); /* 42 */
+ HH (c, d, a, b, data[ 5], S33); /* 43 */
+ HH (b, c, d, a, 0, S34); /* 44 */
+ HH (a, b, c, d, data[ 3], S31); /* 45 */
+ HH (d, a, b, c, 0, S32); /* 46 */
+ HH (c, d, a, b, data[ 7], S33); /* 47 */
+ HH (b, c, d, a, 0, S34); /* 48 */
+
+ // Finally, add initial values, as this is the only pass we make.
+ a += 0x67452301;
+ b += 0xefcdab89;
+ c += 0x98badcfe;
+ d += 0x10325476;
+
+ uDigest[0] = a;
+ uDigest[1] = b;
+ uDigest[2] = c;
+ uDigest[3] = d;
+}
projects / freerainbowtables / blobdiff