请教破解MD5的方法

阿呆

我懒得查，没有兄弟帮忙贴一下么？

carechen

我贴：

carechen

MD5.h
/*
* This is work is derived from material Copyright RSA Data Security, Inc.
*
* The RSA copyright statement and Licence for that original material is
* included below. This is followed by the Apache copyright statement and
* licence for the modifications made to that material.
*/

/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
   rights reserved.

   License to copy and use this software is granted provided that it
   is identified as the "RSA Data Security, Inc. MD5 Message-Digest
   Algorithm" in all material mentioning or referencing this software
   or this function.

   License is also granted to make and use derivative works provided
   that such works are identified as "derived from the RSA Data
   Security, Inc. MD5 Message-Digest Algorithm" in all material
   mentioning or referencing the derived work.

   RSA Data Security, Inc. makes no representations concerning either
   the merchantability of this software or the suitability of this
   software for any particular purpose. It is provided "as is"
   without express or implied warranty of any kind.

   These notices must be retained in any copies of any part of this
   documentation and/or software.
*/

#ifdef __cplusplus
extern "C" {
#endif

/**
* @package DPL MD5 Library
*/

#define MD5_DIGESTSIZE 16
#define DPL_SUCCESS 0

#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21

/** MD5 context. */
typedef struct dpl_md5_ctx_t {
    /** state (ABCD) */
    UINT32  state[4];
    /** number of bits, modulo 2^64 (lsb first) */
    UINT32  count[2];
    /** input buffer */
    UINT8   buffer[64];
}dpl_md5_ctx_t;

static UINT8 PADDING[64] =
{
    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

/* F, G, H and I are basic MD5 functions.
*/
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))

/* ROTATE_LEFT rotates x left n bits.
*/
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
   Rotation is separate from addition to prevent recomputation.
*/
#define FF(a, b, c, d, x, s, ac) { \
(a) += F ((b), (c), (d)) + (x) + (UINT32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
  }
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (UINT32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
  }
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (UINT32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
  }
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + (UINT32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
  }


/**
* MD5 Initialize.  Begins an MD5 operation, writing a new context.
* @param context The MD5 context to initialize.
* @deffunc apr_status_t apr_MD5Init(apr_md5_ctx_t *context)
*/
INT32 dpl_MD5Init(dpl_md5_ctx_t *context);


/**
* MD5 block update operation.  Continue an MD5 message-digest operation,
* processing another message block, and updating the context.
* @param context The MD5 content to update.
* @param input next message block to update
* @param inputLen The length of the next message block
* @deffunc apr_status_t apr_MD5Update(apr_md5_ctx_t *context, const unsigned char *input, unsigned int inputLen)
*/
INT32 dpl_MD5Update(dpl_md5_ctx_t *context,
                                       const UINT8 *input,
                                       UINT32 inputLen);

/**
* MD5 finalization.  Ends an MD5 message-digest operation, writing the
* message digest and zeroing the context
* @param digest The final MD5 digest
* @param context The MD5 content we are finalizing.
* @deffunc apr_status_t apr_MD5Final(unsigned char digest[MD5_DIGESTSIZE], apr_md5_ctx_t *context)
*/
INT32 dpl_MD5Final(UINT8 digest[MD5_DIGESTSIZE],
                                      dpl_md5_ctx_t *context);

/**
* Encode a password using an MD5 algorithm
* @param password The password to encode
* @param salt The salt to use for the encoding
* @param result The string to store the encoded password in
* @param nbytes The length of the string
* @deffunc apr_status_t apr_MD5Encode(const char *password, const char *salt, char *result, size_t nbytes)
*/
INT32 dpl_MD5Encode(const INT8 *password, const INT8 *salt,
                                     INT8 *result, UINT32 nbytes);

INT8 *dpl_md5_binary(INT8 *out,const UINT8 *buf, INT32 length);

#ifdef __cplusplus
}
#endif

carechen

MD5.C
#include "MD5.h"

/* Constants for MD5Transform routine.
*/

static void MD5Transform(UINT32 state[4], const UINT8 block[64]);
static void Encode(UINT8 *output, const UINT32 *input,
                   UINT32 len);
static void Decode(UINT32 *output, const UINT8 *input,
                   UINT32 len);

/* MD5 initialization. Begins an MD5 operation, writing a new context.
*/
INT32 dpl_MD5Init(dpl_md5_ctx_t *context)
{
    context->count[0] = context->count[1] = 0;
    /* Load magic initialization constants. */
    context->state[0] = 0x67452301;
    context->state[1] = 0xefcdab89;
    context->state[2] = 0x98badcfe;
    context->state[3] = 0x10325476;

    return DPL_SUCCESS;
}

/* MD5 block update operation. Continues an MD5 message-digest
   operation, processing another message block, and updating the
   context.
*/
INT32 dpl_MD5Update(dpl_md5_ctx_t *context,
                                     const UINT8 *input,
                                     UINT32 inputLen)
{
    UINT32 i, idx, partLen;

    /* Compute number of bytes mod 64 */
    idx = (UINT32) ((context->count[0] >> 3) & 0x3F);

    /* Update number of bits */
    if ((context->count[0] += ((UINT32) inputLen << 3))
            < ((UINT32) inputLen << 3))
        context->count[1]++;
    context->count[1] += (UINT32) inputLen >> 29;

    partLen = 64 - idx;

    /* Transform as many times as possible. */
    if (inputLen >= partLen) {
        memcpy(&context->buffer[idx], input, partLen);
        MD5Transform(context->state, context->buffer);

        for (i = partLen; i + 63 < inputLen; i += 64)
            MD5Transform(context->state, &input);

        idx = 0;
    }
    else
        i = 0;

    /* Buffer remaining input */
    memcpy(&context->buffer[idx], &input, inputLen - i);
   
    return DPL_SUCCESS;
}

/* MD5 finalization. Ends an MD5 message-digest operation, writing the
   the message digest and zeroizing the context.
*/
INT32 dpl_MD5Final(UINT8 digest[MD5_DIGESTSIZE],
                                      dpl_md5_ctx_t *context)
{
    UINT8  bits[8];
    UINT32 idx, padLen;

    /* Save number of bits */
    Encode(bits, context->count, 8);


    /* Pad out to 56 mod 64. */
    idx = (UINT32) ((context->count[0] >> 3) & 0x3f);
    padLen = (idx < 56) ? (56 - idx) : (120 - idx);
    dpl_MD5Update(context, PADDING, padLen);

    /* Append length (before padding) */
    dpl_MD5Update(context, bits, 8);

    /* Store state in digest */
    Encode(digest, context->state, MD5_DIGESTSIZE);

    /* Zeroize sensitive information. */
    memset(context, 0, sizeof(dpl_md5_ctx_t));
   
    return DPL_SUCCESS;
}

/* MD5 basic transformation. Transforms state based on block. */
static void MD5Transform(UINT32 state[4], const UINT8 block[64])
{
    UINT32 a = state[0], b = state[1], c = state[2], d = state[3],
          x[MD5_DIGESTSIZE];

    Decode(x, block, 64);

    /* Round 1 */
    FF(a, b, c, d, x[0], S11, 0xd76aa478);        /* 1 */
    FF(d, a, b, c, x[1], S12, 0xe8c7b756);        /* 2 */
    FF(c, d, a, b, x[2], S13, 0x242070db);        /* 3 */
    FF(b, c, d, a, x[3], S14, 0xc1bdceee);        /* 4 */
    FF(a, b, c, d, x[4], S11, 0xf57c0faf);        /* 5 */
    FF(d, a, b, c, x[5], S12, 0x4787c62a);        /* 6 */
    FF(c, d, a, b, x[6], S13, 0xa8304613);        /* 7 */
    FF(b, c, d, a, x[7], S14, 0xfd469501);        /* 8 */
    FF(a, b, c, d, x[8], S11, 0x698098d8);        /* 9 */
    FF(d, a, b, c, x[9], S12, 0x8b44f7af);        /* 10 */
    FF(c, d, a, b, x[10], S13, 0xffff5bb1);        /* 11 */
    FF(b, c, d, a, x[11], S14, 0x895cd7be);        /* 12 */
    FF(a, b, c, d, x[12], S11, 0x6b901122);        /* 13 */
    FF(d, a, b, c, x[13], S12, 0xfd987193);        /* 14 */
    FF(c, d, a, b, x[14], S13, 0xa679438e);        /* 15 */
    FF(b, c, d, a, x[15], S14, 0x49b40821);        /* 16 */

    /* Round 2 */
    GG(a, b, c, d, x[1], S21, 0xf61e2562);        /* 17 */
    GG(d, a, b, c, x[6], S22, 0xc040b340);        /* 18 */
    GG(c, d, a, b, x[11], S23, 0x265e5a51);        /* 19 */
    GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);        /* 20 */
    GG(a, b, c, d, x[5], S21, 0xd62f105d);        /* 21 */
    GG(d, a, b, c, x[10], S22, 0x2441453);        /* 22 */
    GG(c, d, a, b, x[15], S23, 0xd8a1e681);        /* 23 */
    GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);        /* 24 */
    GG(a, b, c, d, x[9], S21, 0x21e1cde6);        /* 25 */
    GG(d, a, b, c, x[14], S22, 0xc33707d6);        /* 26 */
    GG(c, d, a, b, x[3], S23, 0xf4d50d87);        /* 27 */
    GG(b, c, d, a, x[8], S24, 0x455a14ed);        /* 28 */
    GG(a, b, c, d, x[13], S21, 0xa9e3e905);        /* 29 */
    GG(d, a, b, c, x[2], S22, 0xfcefa3f8);        /* 30 */
    GG(c, d, a, b, x[7], S23, 0x676f02d9);        /* 31 */
    GG(b, c, d, a, x[12], S24, 0x8d2a4c8a);        /* 32 */

    /* Round 3 */
    HH(a, b, c, d, x[5], S31, 0xfffa3942);        /* 33 */
    HH(d, a, b, c, x[8], S32, 0x8771f681);        /* 34 */
    HH(c, d, a, b, x[11], S33, 0x6d9d6122);        /* 35 */
    HH(b, c, d, a, x[14], S34, 0xfde5380c);        /* 36 */
    HH(a, b, c, d, x[1], S31, 0xa4beea44);        /* 37 */
    HH(d, a, b, c, x[4], S32, 0x4bdecfa9);        /* 38 */
    HH(c, d, a, b, x[7], S33, 0xf6bb4b60);        /* 39 */
    HH(b, c, d, a, x[10], S34, 0xbebfbc70);        /* 40 */
    HH(a, b, c, d, x[13], S31, 0x289b7ec6);        /* 41 */
    HH(d, a, b, c, x[0], S32, 0xeaa127fa);        /* 42 */
    HH(c, d, a, b, x[3], S33, 0xd4ef3085);        /* 43 */
    HH(b, c, d, a, x[6], S34, 0x4881d05);        /* 44 */
    HH(a, b, c, d, x[9], S31, 0xd9d4d039);        /* 45 */
    HH(d, a, b, c, x[12], S32, 0xe6db99e5);        /* 46 */
    HH(c, d, a, b, x[15], S33, 0x1fa27cf8);        /* 47 */
    HH(b, c, d, a, x[2], S34, 0xc4ac5665);        /* 48 */

    /* Round 4 */
    II(a, b, c, d, x[0], S41, 0xf4292244);        /* 49 */
    II(d, a, b, c, x[7], S42, 0x432aff97);        /* 50 */
    II(c, d, a, b, x[14], S43, 0xab9423a7);        /* 51 */
    II(b, c, d, a, x[5], S44, 0xfc93a039);        /* 52 */
    II(a, b, c, d, x[12], S41, 0x655b59c3);        /* 53 */
    II(d, a, b, c, x[3], S42, 0x8f0ccc92);        /* 54 */
    II(c, d, a, b, x[10], S43, 0xffeff47d);        /* 55 */
    II(b, c, d, a, x[1], S44, 0x85845dd1);        /* 56 */
    II(a, b, c, d, x[8], S41, 0x6fa87e4f);        /* 57 */
    II(d, a, b, c, x[15], S42, 0xfe2ce6e0);        /* 58 */
    II(c, d, a, b, x[6], S43, 0xa3014314);        /* 59 */
    II(b, c, d, a, x[13], S44, 0x4e0811a1);        /* 60 */
    II(a, b, c, d, x[4], S41, 0xf7537e82);        /* 61 */
    II(d, a, b, c, x[11], S42, 0xbd3af235);        /* 62 */
    II(c, d, a, b, x[2], S43, 0x2ad7d2bb);        /* 63 */
    II(b, c, d, a, x[9], S44, 0xeb86d391);        /* 64 */

    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;

    /* Zeroize sensitive information. */
    memset(x, 0, sizeof(x));
}

/* Encodes input (UINT4) into output (unsigned char). Assumes len is
   a multiple of 4.
*/
static void Encode(UINT8 *output, const UINT32 *input, UINT32 len)
{
    UINT32 i, j, k;

    for (i = 0, j = 0; j < len; i++, j += 4) {
        k = input;
        output[j] = (UINT8) (k & 0xff);
        output[j + 1] = (UINT8) ((k >> 8) & 0xff);
        output[j + 2] = (UINT8) ((k >> 16) & 0xff);
        output[j + 3] = (UINT8) ((k >> 24) & 0xff);
    }
}

/* Decodes input (unsigned char) into output (UINT4). Assumes len is
* a multiple of 4.
*/
static void Decode(UINT32 *output, const UINT8 *input, UINT32 len)
{
    UINT32 i, j;

    for (i = 0, j = 0; j < len; i++, j += 4)
        output = ((UINT32) input[j]) | (((UINT32) input[j + 1]) << 8) |
            (((UINT32) input[j + 2]) << 16) | (((UINT32) input[j + 3]) << 24);
}

/*
* Define the Magic String prefix that identifies a password as being
* hashed using our algorithm.
*
static const char *apr1_id = "$apr1$";
*/

INT8 *MD5_Buffer(const UINT8 *buf, INT32 length, INT8 *out)
{
        dpl_md5_ctx_t my_md5;
        dpl_MD5Init(&my_md5);
        dpl_MD5Update(&my_md5, buf, (UINT32)length);
        dpl_MD5Final(out, &my_md5);
        
        return out;
}

阿呆

我倒！~~~~~

有ＶＢ的么？

阿呆

忘了说： 谢谢你！谢谢你！！！～～～

fish

md5好象是用于生成数据的"指纹/签名", 而不是加密数据.
它由不同大小的原始数据产生定长的指纹, 在原始数据的
基础做少量修改而产生相同的指纹基本上是不可能的, 这样
就可以在给出指纹的后确认某文件没有被修改, 证实该文件
是原文件. 由于md5生成的是定长度的"指纹", 还是有可能
不同的文件有相同的"指纹".

从压缩的角度看, 无论使用什么方法都不可能把数据无限
压缩; 不同长度的数据怎么可能压缩成如此短的定长数据
呢.

carechen

VB的？
恐怕很难？大凡加密算法都要用到大量的位操作，BASIC语言有没有位操作？我不清楚，但是很少有用VB来做加解密的工作。

阿呆

不是要把数据无限压缩到16个byte了，只是要知道MD5的算法，或者在许多个之中找到一个能与密文匹配的明文。可否用穷举法得到其中的一个？