c语言跪求

发布网友发布时间：2022-04-29 22:58

共1个回答

热心网友时间：2022-06-25 05:25

使用MD5算法加密,第一次运行加密,第二次运行解密,当然密码需要一致

#include <string.h>
#include <stdio.h>

// 伪随机数
void initRandom(long * random, long x = 0, long a = 1103515245, long b = 12345, long m = 0)
{
random[0] = x;
random[1] = a;
random[2] = b;
random[3] = m;
}

long Rand(long * random)
{
    random[0] = random[0] * random[1] + random[2];
    if(random[3]) random[0] %= random[3];
    return random[0];
}

unsigned long ByteReverse(unsigned long in)
{
unsigned long r = ((in >> 16ul) & 0x0000FFFFul) | ((in << 16ul) & 0xFFFF0000ul);
r = ((r >> 8ul) & 0x00FF00FFul) | ((r << 8ul) & 0xFF00FF00ul);
return r;
}

// 简化版MD5
// 这个就是加密算法函数，这里使用使用MD5, 当然也可以使用其它算法
// 这个是简化版, 只适用计算len<56的MD5,
void cryptMD5(unsigned char * key, const unsigned char * in, int len)
{
// MD5 用到的宏定义
#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
#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)))
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
#define FF(a, b, c, d, x, s, ac) {(a) += F((b), (c), (d)) + (x) + (ac); (a) = ROTATE_LEFT((a), (s)); (a) += (b);}
#define GG(a, b, c, d, x, s, ac) {(a) += G((b), (c), (d)) + (x) + (ac); (a) = ROTATE_LEFT((a), (s)); (a) += (b);}
#define HH(a, b, c, d, x, s, ac) {(a) += H((b), (c), (d)) + (x) + (ac); (a) = ROTATE_LEFT((a), (s)); (a) += (b);}
#define II(a, b, c, d, x, s, ac) {(a) += I((b), (c), (d)) + (x) + (ac); (a) = ROTATE_LEFT((a), (s)); (a) += (b);}

unsigned char buf[64];  // 字符缓存
unsigned long state[4]; // 状态缓存
unsigned long a, b, c, d, x[16];
int i;

if(len > 56) len = 56;
memset(buf, 0, 64);     // 初始化字符缓存
memcpy(buf, in, len);   // 复制字符
if(len < 56) buf[len] = 0x80; // 填充1
((unsigned __int64 *)buf)[7] = (unsigned __int64)len << 3; // 设置字符串bit长度
    state[0] = 0x67452301ul; // 初始化状态缓存
    state[1] = 0xefcdab89ul;
    state[2] = 0x98badcfeul;
    state[3] = 0x10325476ul;

    a = state[0];
b = state[1];
c = state[2];
d = state[3] ;
for(i = 0; i < 16; ++i) x[i] = ((unsigned long *)buf)[i];

    // 第一轮变换
    FF(a, b, c, d, x[0] , S11, 0xd76aa478ul);
    FF(d, a, b, c, x[1] , S12, 0xe8c7b756ul);
    FF(c, d, a, b, x[2] , S13, 0x242070dbul);
    FF(b, c, d, a, x[3] , S14, 0xc1bdceeeul);
    FF(a, b, c, d, x[4] , S11, 0xf57c0faful);
    FF(d, a, b, c, x[5] , S12, 0x4787c62aul);
    FF(c, d, a, b, x[6] , S13, 0xa8304613ul);
    FF(b, c, d, a, x[7] , S14, 0xfd469501ul);
    FF(a, b, c, d, x[8] , S11, 0x698098d8ul);
    FF(d, a, b, c, x[9] , S12, 0x8b44f7aful);
    FF(c, d, a, b, x[10], S13, 0xffff5bb1ul);
    FF(b, c, d, a, x[11], S14, 0x895cd7beul);
    FF(a, b, c, d, x[12], S11, 0x6b901122ul);
    FF(d, a, b, c, x[13], S12, 0xfd987193ul);
    FF(c, d, a, b, x[14], S13, 0xa679438eul);
    FF(b, c, d, a, x[15], S14, 0x49b40821ul);

    // 第二轮变换
    GG(a, b, c, d, x[1] , S21, 0xf61e2562ul);
    GG(d, a, b, c, x[6] , S22, 0xc040b340ul);
    GG(c, d, a, b, x[11], S23, 0x265e5a51ul);
    GG(b, c, d, a, x[0] , S24, 0xe9b6c7aaul);
    GG(a, b, c, d, x[5] , S21, 0xd62f105l);
    GG(d, a, b, c, x[10], S22,  0x2441453ul);
    GG(c, d, a, b, x[15], S23, 0xd8a1e681ul);
    GG(b, c, d, a, x[4] , S24, 0xe7d3fbc8ul);
    GG(a, b, c, d, x[9] , S21, 0x21e1cde6ul);
    GG(d, a, b, c, x[14], S22, 0xc33707d6ul);
    GG(c, d, a, b, x[3] , S23, 0xf4d50d87ul);
    GG(b, c, d, a, x[8] , S24, 0x455a14el);
    GG(a, b, c, d, x[13], S21, 0xa9e3e905ul);
    GG(d, a, b, c, x[2] , S22, 0xfcefa3f8ul);
    GG(c, d, a, b, x[7] , S23, 0x676f02d9ul);
    GG(b, c, d, a, x[12], S24, 0x8d2a4c8aul);

    // 第三轮变换
    HH(a, b, c, d, x[5] , S31, 0xfffa3942ul);
    HH(d, a, b, c, x[8] , S32, 0x8771f681ul);
    HH(c, d, a, b, x[11], S33, 0x6d9d6122ul);
    HH(b, c, d, a, x[14], S34, 0xfde5380cul);
    HH(a, b, c, d, x[1] , S31, 0xa4beea44ul);
    HH(d, a, b, c, x[4] , S32, 0x4bdecfa9ul);
    HH(c, d, a, b, x[7] , S33, 0xf6bb4b60ul);
    HH(b, c, d, a, x[10], S34, 0xbebfbc70ul);
    HH(a, b, c, d, x[13], S31, 0x289b7ec6ul);
    HH(d, a, b, c, x[0] , S32, 0xeaa127faul);
    HH(c, d, a, b, x[3] , S33, 0xd4ef3085ul);
    HH(b, c, d, a, x[6] , S34,  0x4881d05ul);
    HH(a, b, c, d, x[9] , S31, 0xd9d4d039ul);
    HH(d, a, b, c, x[12], S32, 0xe6db99e5ul);
    HH(c, d, a, b, x[15], S33, 0x1fa27cf8ul);
    HH(b, c, d, a, x[2] , S34, 0xc4ac5665ul);

    // 第四轮变换
    II(a, b, c, d, x[0] , S41, 0xf4292244ul);
    II(d, a, b, c, x[7] , S42, 0x432aff97ul);
    II(c, d, a, b, x[14], S43, 0xab9423a7ul);
    II(b, c, d, a, x[5] , S44, 0xfc93a039ul);
    II(a, b, c, d, x[12], S41, 0x655b59c3ul);
    II(d, a, b, c, x[3] , S42, 0x8f0ccc92ul);
    II(c, d, a, b, x[10], S43, 0xffeff47l);
    II(b, c, d, a, x[1] , S44, 0x85845dd1ul);
    II(a, b, c, d, x[8] , S41, 0x6fa87e4ful);
    II(d, a, b, c, x[15], S42, 0xfe2ce6e0ul);
    II(c, d, a, b, x[6] , S43, 0xa3014314ul);
    II(b, c, d, a, x[13], S44, 0x4e0811a1ul);
    II(a, b, c, d, x[4] , S41, 0xf7537e82ul);
    II(d, a, b, c, x[11], S42, 0xbd3af235ul);
    II(c, d, a, b, x[2] , S43, 0x2ad7d2bbul);
    II(b, c, d, a, x[9] , S44, 0xeb86d391ul);

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

// 变换结束
for(i = 0; i < 4; i++) ((unsigned long *)key)[i] = state[i];
}

long MyRandom[4][4];       // 四个伪随机数
unsigned long CryptKey[4];
int CryptKeyPos;

void cryptKey()
{
int i;
for(i = 0; i < 4; ++i) CryptKey[i] = ByteReverse(CryptKey[i]);
cryptMD5((unsigned char *)CryptKey, (const unsigned char *)CryptKey, 16);
for(i = 0; i < 4; ++i) CryptKey[i] = ByteReverse(CryptKey[i]);
}

void GenKey()
{
for(int i = 0; i < 4; i++) CryptKey[i] = Rand(MyRandom[i]); // 产生
cryptKey(); // 加密
}

void initMyRandom(const char * key)
{
int i;
cryptMD5((unsigned char *)CryptKey, (const unsigned char *)key, strlen(key));
for(i = 0; i < 4; ++i) initRandom(MyRandom[i], CryptKey[i]);
CryptKeyPos = 0;
}

char CryptChar()
{
if(CryptKeyPos >= 12) {GenKey(); CryptKeyPos = 0;}
return ((const char *)CryptKey)[CryptKeyPos++];
}

void CryptFile(const char * File, const char * key)
{
char outFile[256], buf[1024];
FILE *fpo, *fpi;
int i, n;

sprintf(outFile, "%s.cry", File);
fpo = fopen(outFile, "wb");
fpi = fopen(File, "rb");

if(fpo == NULL || fpi == NULL)
{
if(fpo) fclose(fpo);
if(fpi) fclose(fpi);
return ;
}
initMyRandom(key);

while(!feof(fpi))
{
n = fread(buf, 1, 1000, fpi);
for(i = 0; i < n; ++i) buf[i] ^= CryptChar();
fwrite(buf, 1, n, fpo);
}

fclose(fpo);
fclose(fpi);
}

int main()
{
char key[32];
char File[256];
scanf("%s %s", key, File);
CryptFile(File, key);
return 0;
}