Sha256 source code

HI NKBao.

1. Bạn tiếng Anh không giỏi lắm thì tự học đi.
2. C sơ sơ thì học lên. Các thư viện viết bằng code C không dễ đọc nếu chỉ sơ sơ.
3. Bạn tìm 1 thư viện kéo về build và băm thử xem có đúng không là biết nên tập trung vào dâu.

đây là bài tập môn an ninh mạng m vừa học tiếc là m lại làm về md5 chứ k phải sha256
tham khảo băm md5 1 chuỗi

md5.png1752x1110 180 KB

#define  _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
using namespace std;

#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)+(unsigned long int)(ac); \
	(a) = ROTATE_LEFT((a), (s)); \
	(a) += (b); \
}

#define GG(a, b, c, d, x, s, ac) { \
	(a) += G((b), (c), (d)) + (x)+(unsigned long int)(ac); \
	(a) = ROTATE_LEFT((a), (s)); \
	(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
	(a) += H((b), (c), (d)) + (x)+(unsigned long int)(ac); \
	(a) = ROTATE_LEFT((a), (s)); \
	(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
	(a) += I((b), (c), (d)) + (x)+(unsigned long int)(ac); \
	(a) = ROTATE_LEFT((a), (s)); \
	(a) += (b); \
}


class md5{
private:
	 unsigned long int state[4];
	 unsigned long int count[2];
	 unsigned char buffer[64];
	 unsigned char digest[16];
	 string hashvalue;
	
	void update(const unsigned char input[], unsigned int length){
		unsigned int index = (count[0] >> 3) & 0x3F;
		unsigned int partlen = 64 - index;
		if ((count[0] += (length << 3)) < (length << 3)) count[1]++;
		count[1] += (length >> 29);
		unsigned int i;
		if (length >= partlen){
			memcpy(&buffer[index], input, partlen);
			transform(buffer);
			for (i = partlen; i + 63 <= length; i += 64) transform(&input[i]);
			index = 0;
		}
		else i = 0;
		memcpy(&buffer[index], &input[i], length - i);
	}

	void transform(const unsigned char block[64]){
		unsigned long int a = state[0], b = state[1], c = state[2], d = state[3], x[16];
		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;
		memset(x, 0, sizeof(x));
	}

	void final(){
		static unsigned char padding[64] = {0};
		padding[0] = 0x80;
		unsigned char bits[8];
		encode(bits, count, 8);
		unsigned int index = (count[0] >> 3) & 0x3F;
		unsigned int padlen = (index < 56) ? (56 - index) : (120 - index);
		update(padding, padlen);
		update(bits, padlen);
		encode(digest, state, 16);
		memset(buffer, 0, sizeof(buffer));
		memset(count, 0, sizeof (count));
	}

	void digest2hex(){
		char buf[33];
		for (int i = 0; i < 16; i++) sprintf(buf + i * 2, "%02x", digest[i]);
		buf[32] = 0;
		hashvalue = string(buf);
	}

	void decode(unsigned long int output[],const unsigned char input[], unsigned int length){
		for (unsigned int i = 0, j = 0; j < length; i++, j += 4)
			output[i] = ((unsigned long int)input[j]) | (((unsigned long int)input[j + 1]) << 8) |
			(((unsigned long int)input[j + 2]) << 16) | (((unsigned long int)input[j + 3]) << 24);
	}

	void encode(unsigned char output[], unsigned long int input[], unsigned int length){
		for (unsigned char i = 0, j = 0; j < length; i++, j += 4) {
			output[j] = input[i] & 0xff;
			output[j + 1] = (input[i] >> 8) & 0xff;
			output[j + 2] = (input[i] >> 16) & 0xff;
			output[j + 3] = (input[i] >> 24) & 0xff;
		}
	}

public:
	md5(){
		state[0] = 0x67452301;
		state[1] = 0xefcdab89;
		state[2] = 0x98badcfe;
		state[3] = 0x10325476;
		count[0] = count[1] = 0;
	}

	string hashmd5(const string &message){
		update((unsigned char *)message.c_str(), message.length());
		final();
		digest2hex();
		return hashvalue;
	}
};


void main(){
	string message;
	cout << "Nhap thong diep   ";
	fflush(stdin);
	getline(cin, message);
	md5 gethash;
	cout << "md5(" << message << ") = " << gethash.hashmd5(message) << endl;
	system("pause");
}

Thanks nha bạn : ))