API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 13th, 2018
173
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 12.57 KB | None | 0 0
raw download clone embed print report
  1. #include <bits/stdc++.h>
  2. class MD5
  3. {
  4. public:
  5.     typedef unsigned int size_type; // must be 32bit
  6.    
  7.     MD5();
  8.     MD5(const std::string& text);
  9.     void update(const unsigned char *buf, size_type length);
  10.     void update(const char *buf, size_type length);
  11.     MD5& finalize();
  12.     std::string hexdigest() const;
  13.     friend std::ostream& operator<<(std::ostream&, MD5 md5);
  14.    
  15. private:
  16.     void init();
  17.     typedef unsigned char uint1; //  8bit
  18.     typedef unsigned int uint4;  // 32bit
  19.     enum {blocksize = 64}; // VC6 won't eat a const static int here
  20.    
  21.     void transform(const uint1 block[blocksize]);
  22.     static void decode(uint4 output[], const uint1 input[], size_type len);
  23.     static void encode(uint1 output[], const uint4 input[], size_type len);
  24.    
  25.     bool finalized;
  26.     uint1 buffer[blocksize]; // bytes that didn't fit in last 64 byte chunk
  27.     uint4 count[2];   // 64bit counter for number of bits (lo, hi)
  28.     uint4 state[4];   // digest so far
  29.     uint1 digest[16]; // the result
  30.    
  31.     // low level logic operations
  32.     static inline uint4 F(uint4 x, uint4 y, uint4 z);
  33.     static inline uint4 G(uint4 x, uint4 y, uint4 z);
  34.     static inline uint4 H(uint4 x, uint4 y, uint4 z);
  35.     static inline uint4 I(uint4 x, uint4 y, uint4 z);
  36.     static inline uint4 rotate_left(uint4 x, int n);
  37.     static inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
  38.     static inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
  39.     static inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
  40.     static inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
  41. };
  42.  
  43. std::string md5(const std::string str);
  44. // Constants for MD5Transform routine.
  45. #define S11 7
  46. #define S12 12
  47. #define S13 17
  48. #define S14 22
  49. #define S21 5
  50. #define S22 9
  51. #define S23 14
  52. #define S24 20
  53. #define S31 4
  54. #define S32 11
  55. #define S33 16
  56. #define S34 23
  57. #define S41 6
  58. #define S42 10
  59. #define S43 15
  60. #define S44 21
  61.  
  62. ///////////////////////////////////////////////
  63.  
  64. // F, G, H and I are basic MD5 functions.
  65. inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) {
  66.     return x&y | ~x&z;
  67. }
  68.  
  69. inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) {
  70.     return x&z | y&~z;
  71. }
  72.  
  73. inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) {
  74.     return x^y^z;
  75. }
  76.  
  77. inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) {
  78.     return y ^ (x | ~z);
  79. }
  80.  
  81. // rotate_left rotates x left n bits.
  82. inline MD5::uint4 MD5::rotate_left(uint4 x, int n) {
  83.     return (x << n) | (x >> (32-n));
  84. }
  85.  
  86. // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
  87. // Rotation is separate from addition to prevent recomputation.
  88. inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
  89.     a = rotate_left(a+ F(b,c,d) + x + ac, s) + b;
  90. }
  91.  
  92. inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
  93.     a = rotate_left(a + G(b,c,d) + x + ac, s) + b;
  94. }
  95.  
  96. inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
  97.     a = rotate_left(a + H(b,c,d) + x + ac, s) + b;
  98. }
  99.  
  100. inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
  101.     a = rotate_left(a + I(b,c,d) + x + ac, s) + b;
  102. }
  103.  
  104. //////////////////////////////////////////////
  105.  
  106. // default ctor, just initailize
  107. MD5::MD5()
  108. {
  109.     init();
  110. }
  111.  
  112. //////////////////////////////////////////////
  113.  
  114. // nifty shortcut ctor, compute MD5 for string and finalize it right away
  115. MD5::MD5(const std::string &text)
  116. {
  117.     init();
  118.     update(text.c_str(), text.length());
  119.     finalize();
  120. }
  121.  
  122. //////////////////////////////
  123.  
  124. void MD5::init()
  125. {
  126.     finalized=false;
  127.    
  128.     count[0] = 0;
  129.     count[1] = 0;
  130.    
  131.     // load magic initialization constants.
  132.     state[0] = 0x67452301;
  133.     state[1] = 0xefcdab89;
  134.     state[2] = 0x98badcfe;
  135.     state[3] = 0x10325476;
  136. }
  137.  
  138. //////////////////////////////
  139.  
  140. // decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4.
  141. void MD5::decode(uint4 output[], const uint1 input[], size_type len)
  142. {
  143.     for (unsigned int i = 0, j = 0; j < len; i++, j += 4)
  144.         output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
  145.         (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
  146. }
  147.  
  148. //////////////////////////////
  149.  
  150. // encodes input (uint4) into output (unsigned char). Assumes len is
  151. // a multiple of 4.
  152. void MD5::encode(uint1 output[], const uint4 input[], size_type len)
  153. {
  154.     for (size_type i = 0, j = 0; j < len; i++, j += 4) {
  155.         output[j] = input[i] & 0xff;
  156.         output[j+1] = (input[i] >> 8) & 0xff;
  157.         output[j+2] = (input[i] >> 16) & 0xff;
  158.         output[j+3] = (input[i] >> 24) & 0xff;
  159.     }
  160. }
  161.  
  162. //////////////////////////////
  163.  
  164. // apply MD5 algo on a block
  165. void MD5::transform(const uint1 block[blocksize])
  166. {
  167.     uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
  168.     decode (x, block, blocksize);
  169.    
  170.     /* Round 1 */
  171.     FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
  172.     FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
  173.     FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
  174.     FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
  175.     FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
  176.     FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
  177.     FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
  178.     FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
  179.     FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
  180.     FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
  181.     FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
  182.     FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
  183.     FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
  184.     FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
  185.     FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
  186.     FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
  187.    
  188.     /* Round 2 */
  189.     GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
  190.     GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
  191.     GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
  192.     GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
  193.     GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
  194.     GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
  195.     GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
  196.     GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
  197.     GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
  198.     GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
  199.     GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
  200.     GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
  201.     GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
  202.     GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
  203.     GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
  204.     GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
  205.    
  206.     /* Round 3 */
  207.     HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
  208.     HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
  209.     HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
  210.     HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
  211.     HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
  212.     HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
  213.     HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
  214.     HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
  215.     HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
  216.     HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
  217.     HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
  218.     HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
  219.     HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
  220.     HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
  221.     HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
  222.     HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
  223.    
  224.     /* Round 4 */
  225.     II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
  226.     II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
  227.     II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
  228.     II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
  229.     II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
  230.     II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
  231.     II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
  232.     II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
  233.     II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
  234.     II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
  235.     II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
  236.     II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
  237.     II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
  238.     II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
  239.     II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
  240.     II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
  241.    
  242.     state[0] += a;
  243.     state[1] += b;
  244.     state[2] += c;
  245.     state[3] += d;
  246.    
  247.     // Zeroize sensitive information.
  248.     memset(x, 0, sizeof x);
  249. }
  250.  
  251. //////////////////////////////
  252.  
  253. // MD5 block update operation. Continues an MD5 message-digest
  254. // operation, processing another message block
  255. void MD5::update(const unsigned char input[], size_type length)
  256. {
  257.     // compute number of bytes mod 64
  258.     size_type index = count[0] / 8 % blocksize;
  259.    
  260.     // Update number of bits
  261.     if ((count[0] += (length << 3)) < (length << 3))
  262.         count[1]++;
  263.     count[1] += (length >> 29);
  264.    
  265.     // number of bytes we need to fill in buffer
  266.     size_type firstpart = 64 - index;
  267.    
  268.     size_type i;
  269.    
  270.     // transform as many times as possible.
  271.     if (length >= firstpart)
  272.      {
  273.         // fill buffer first, transform
  274.         memcpy(&buffer[index], input, firstpart);
  275.         transform(buffer);
  276.        
  277.         // transform chunks of blocksize (64 bytes)
  278.         for (i = firstpart; i + blocksize <= length; i += blocksize)
  279.             transform(&input[i]);
  280.        
  281.         index = 0;
  282.      }
  283.     else
  284.         i = 0;
  285.    
  286.     // buffer remaining input
  287.     memcpy(&buffer[index], &input[i], length-i);
  288. }
  289.  
  290. //////////////////////////////
  291.  
  292. // for convenience provide a verson with signed char
  293. void MD5::update(const char input[], size_type length)
  294. {
  295.     update((const unsigned char*)input, length);
  296. }
  297.  
  298. //////////////////////////////
  299.  
  300. // MD5 finalization. Ends an MD5 message-digest operation, writing the
  301. // the message digest and zeroizing the context.
  302. MD5& MD5::finalize()
  303. {
  304.     static unsigned char padding[64] = {
  305.         0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  306.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  307.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  308.     };
  309.    
  310.     if (!finalized) {
  311.         // Save number of bits
  312.         unsigned char bits[8];
  313.         encode(bits, count, 8);
  314.        
  315.         // pad out to 56 mod 64.
  316.         size_type index = count[0] / 8 % 64;
  317.         size_type padLen = (index < 56) ? (56 - index) : (120 - index);
  318.         update(padding, padLen);
  319.        
  320.         // Append length (before padding)
  321.         update(bits, 8);
  322.        
  323.         // Store state in digest
  324.         encode(digest, state, 16);
  325.        
  326.         // Zeroize sensitive information.
  327.         memset(buffer, 0, sizeof buffer);
  328.         memset(count, 0, sizeof count);
  329.        
  330.         finalized=true;
  331.     }
  332.    
  333.     return *this;
  334. }
  335.  
  336. //////////////////////////////
  337.  
  338. // return hex representation of digest as string
  339. std::string MD5::hexdigest() const
  340. {
  341.     if (!finalized)
  342.         return "";
  343.    
  344.     char buf[33];
  345.     for (int i=0; i<16; i++)
  346.         sprintf(buf+i*2, "%02x", digest[i]);
  347.     buf[32]=0;
  348.    
  349.     return std::string(buf);
  350. }
  351.  
  352. //////////////////////////////
  353.  
  354. std::ostream& operator<<(std::ostream& out, MD5 md5)
  355. {
  356.     return out << md5.hexdigest();
  357. }
  358.  
  359. //////////////////////////////
  360.  
  361. std::string md5(const std::string str)
  362. {
  363.     MD5 md5 = MD5(str);
  364.    
  365.     return md5.hexdigest();
  366. }
  367.  
  368. using namespace std;
  369. int main() {
  370.     string dc = "qwertyuiopasdfghjklzxcvbnm1234567890QWERTYUIOPASDFGHJKLZXCVBNM_";
  371.     long long cntall = pow(dc.size(), 5);
  372.     long long cnt = 0;
  373.     for (auto x : dc)
  374.         for (auto y : dc)
  375.             for (auto z : dc)
  376.                 for (auto q : dc)
  377.                     for (auto f : dc) {
  378.                         string qq = "CC{     }";
  379.                         qq[3] = x;
  380.                         qq[4] = y;
  381.                         qq[5] = z;
  382.                         qq[6] = q;
  383.                         qq[7] = f;
  384.                         if (md5(qq) == "2fbbdc6a5fcf7b96b0b1be4dd33f94a7") {
  385.                             cout << qq << endl;
  386.                             return 0;
  387.                         }
  388.                         cnt += 1;
  389.                         if (cnt % 1000 == 0) {
  390.                             cout << 100.0 * cnt / cntall << endl;
  391.                         }
  392.                     }
  393.     //for (auto x : dc)
  394. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!