4. md5 Hashwert erzeugen?

md5 Hashwert erzeugen?

  • C

    Hi,

    kann mir jemand den Befehl sagen um einen eingegebenen string in die Hashsumme umzuwandeln? und was für eine datei muss ich einbinden???

    schonmal danke für die antworten...

    0
  • D

    Such einfach mal auf CodeGuru.com oder CodeProject.com danach ...

    0
  • C

    oder da:
    http://userpages.umbc.edu/~mabzug1/cs/md5/md5.html

    0
  • C

    Ist es möglich das zwei verschiedene datein eine gleich hash summe zurück geben?

    Oder ist ein Hashwert immer unique?

    0
  • C

    okok wer lesen kann ist klar im vorteil

    It is conjectured that it is computationally infeasible to produce two messages having the same message digest, or to produce any message having a given prespecified target message digest

    😉

    0
  • C

    so ich hab mir das jetzt mal angesehen... scheint ziemlich kompliziert zusein???
    Weis jemand ob es da nicht einen einfachen befehl (wie in php) gibt???
    oder kann mir das jemand auf einfach weise erklären?

    0
  • P

    Ich hab ne Klasse dafür auf meiner HP.
    Musst du aber evtl. noch an deine Bedürfnisse anpassen.

    md5

    Devil

    0
  • U

    Hier ne Klasse

    cpp

    //MD5.cpp
#include "stdafx.h"
#include "MD5class.h"
/*
#include <exception>
#include <strstream>

using namespace std;
*/
//CONSTRUCTOR
CMD5::CMD5()
{
	m_auiBuf[0] = 0x67452301;
	m_auiBuf[1] = 0xefcdab89;
	m_auiBuf[2] = 0x98badcfe;
	m_auiBuf[3] = 0x10325476;
	m_auiBits[0] = 0;
	m_auiBits[1] = 0;

	//Reset the flag
	m_bAddData = false;

}

void CMD5::AddData(char const* pcData, int iDataLength)
{

	unsigned int uiT;
	//Update bitcount
	uiT = m_auiBits[0];
	if((m_auiBits[0] = uiT + ((unsigned int)iDataLength << 3)) < uiT)
		m_auiBits[1]++; //Carry from low to high
	m_auiBits[1] += iDataLength >> 29;
	uiT = (uiT >> 3) & (BLOCKSIZE-1); //Bytes already

	if(uiT != 0)
	{
		unsigned char *puc = (unsigned char *)m_aucIn + uiT;
		uiT = BLOCKSIZE - uiT;
		if(iDataLength < uiT)
		{
			memcpy(puc, pcData, iDataLength);
			return;
		}
		memcpy(puc, pcData, uiT);
		Transform();
		pcData += uiT;
		iDataLength -= uiT;
	}
	//Process data in 64-byte chunks
	while(iDataLength >= BLOCKSIZE)
	{
		memcpy(m_aucIn, pcData, BLOCKSIZE);
		Transform();
		pcData += BLOCKSIZE;
		iDataLength -= BLOCKSIZE;
	}
	//Handle any remaining bytes of data
	memcpy(m_aucIn, pcData, iDataLength);
	//Set the flag
	m_bAddData = true;
}

void CMD5::FinalDigest(char* pcDigest)
{

	unsigned int uiCount;
	unsigned char* puc;
	uiCount = (m_auiBits[0] >> 3) & (BLOCKSIZE-1);

	puc = m_aucIn + uiCount;
	*puc++ = 0x80;

	uiCount = BLOCKSIZE - uiCount - 1;

	if(uiCount < 8)
	{

		memset(puc, 0, uiCount);
		Transform();
		memset(m_aucIn, 0, BLOCKSIZE-8);
	}
	else
	{
		memset(puc, 0, uiCount - 8);
	}
	((unsigned int*)m_aucIn)[(BLOCKSIZE>>2)-2] = m_auiBits[0];
	((unsigned int*)m_aucIn)[(BLOCKSIZE>>2)-1] = m_auiBits[1];
	Transform();
	memcpy(pcDigest, m_auiBuf, MD128LENGTH<<2);
	//Reinitialize
	Reset();
}

void CMD5::Reset()
{
	//Reinitialize
	m_auiBuf[0] = 0x67452301;
	m_auiBuf[1] = 0xefcdab89;
	m_auiBuf[2] = 0x98badcfe;
	m_auiBuf[3] = 0x10325476;
	m_auiBits[0] = 0;
	m_auiBits[1] = 0;
	//Reset the flag
	m_bAddData = false;
}

void CMD5::Transform()
{
	unsigned int* puiIn = (unsigned int*)m_aucIn;
	register unsigned int a, b, c, d;
	a = m_auiBuf[0];
	b = m_auiBuf[1];
	c = m_auiBuf[2];
	d = m_auiBuf[3];
	//
	MD5STEP(F1, a, b, c, d, puiIn[0] + 0xd76aa478, 7);
	MD5STEP(F1, d, a, b, c, puiIn[1] + 0xe8c7b756, 12);
	MD5STEP(F1, c, d, a, b, puiIn[2] + 0x242070db, 17);
	MD5STEP(F1, b, c, d, a, puiIn[3] + 0xc1bdceee, 22);
	MD5STEP(F1, a, b, c, d, puiIn[4] + 0xf57c0faf, 7);
	MD5STEP(F1, d, a, b, c, puiIn[5] + 0x4787c62a, 12);
	MD5STEP(F1, c, d, a, b, puiIn[6] + 0xa8304613, 17);
	MD5STEP(F1, b, c, d, a, puiIn[7] + 0xfd469501, 22);
	MD5STEP(F1, a, b, c, d, puiIn[8] + 0x698098d8, 7);
	MD5STEP(F1, d, a, b, c, puiIn[9] + 0x8b44f7af, 12);
	MD5STEP(F1, c, d, a, b, puiIn[10] + 0xffff5bb1, 17);
	MD5STEP(F1, b, c, d, a, puiIn[11] + 0x895cd7be, 22);
	MD5STEP(F1, a, b, c, d, puiIn[12] + 0x6b901122, 7);
	MD5STEP(F1, d, a, b, c, puiIn[13] + 0xfd987193, 12);
	MD5STEP(F1, c, d, a, b, puiIn[14] + 0xa679438e, 17);
	MD5STEP(F1, b, c, d, a, puiIn[15] + 0x49b40821, 22);
	//
	MD5STEP(F2, a, b, c, d, puiIn[1] + 0xf61e2562, 5);
	MD5STEP(F2, d, a, b, c, puiIn[6] + 0xc040b340, 9);
	MD5STEP(F2, c, d, a, b, puiIn[11] + 0x265e5a51, 14);
	MD5STEP(F2, b, c, d, a, puiIn[0] + 0xe9b6c7aa, 20);
	MD5STEP(F2, a, b, c, d, puiIn[5] + 0xd62f105d, 5);
	MD5STEP(F2, d, a, b, c, puiIn[10] + 0x02441453, 9);
	MD5STEP(F2, c, d, a, b, puiIn[15] + 0xd8a1e681, 14);
	MD5STEP(F2, b, c, d, a, puiIn[4] + 0xe7d3fbc8, 20);
	MD5STEP(F2, a, b, c, d, puiIn[9] + 0x21e1cde6, 5);
	MD5STEP(F2, d, a, b, c, puiIn[14] + 0xc33707d6, 9);
	MD5STEP(F2, c, d, a, b, puiIn[3] + 0xf4d50d87, 14);
	MD5STEP(F2, b, c, d, a, puiIn[8] + 0x455a14ed, 20);
	MD5STEP(F2, a, b, c, d, puiIn[13] + 0xa9e3e905, 5);
	MD5STEP(F2, d, a, b, c, puiIn[2] + 0xfcefa3f8, 9);
	MD5STEP(F2, c, d, a, b, puiIn[7] + 0x676f02d9, 14);
	MD5STEP(F2, b, c, d, a, puiIn[12] + 0x8d2a4c8a, 20);
	//
	MD5STEP(F3, a, b, c, d, puiIn[5] + 0xfffa3942, 4);
	MD5STEP(F3, d, a, b, c, puiIn[8] + 0x8771f681, 11);
	MD5STEP(F3, c, d, a, b, puiIn[11] + 0x6d9d6122, 16);
	MD5STEP(F3, b, c, d, a, puiIn[14] + 0xfde5380c, 23);
	MD5STEP(F3, a, b, c, d, puiIn[1] + 0xa4beea44, 4);
	MD5STEP(F3, d, a, b, c, puiIn[4] + 0x4bdecfa9, 11);
	MD5STEP(F3, c, d, a, b, puiIn[7] + 0xf6bb4b60, 16);
	MD5STEP(F3, b, c, d, a, puiIn[10] + 0xbebfbc70, 23);
	MD5STEP(F3, a, b, c, d, puiIn[13] + 0x289b7ec6, 4);
	MD5STEP(F3, d, a, b, c, puiIn[0] + 0xeaa127fa, 11);
	MD5STEP(F3, c, d, a, b, puiIn[3] + 0xd4ef3085, 16);
	MD5STEP(F3, b, c, d, a, puiIn[6] + 0x04881d05, 23);
	MD5STEP(F3, a, b, c, d, puiIn[9] + 0xd9d4d039, 4);
	MD5STEP(F3, d, a, b, c, puiIn[12] + 0xe6db99e5, 11);
	MD5STEP(F3, c, d, a, b, puiIn[15] + 0x1fa27cf8, 16);
	MD5STEP(F3, b, c, d, a, puiIn[2] + 0xc4ac5665, 23);
	//
	MD5STEP(F4, a, b, c, d, puiIn[0] + 0xf4292244, 6);
	MD5STEP(F4, d, a, b, c, puiIn[7] + 0x432aff97, 10);
	MD5STEP(F4, c, d, a, b, puiIn[14] + 0xab9423a7, 15);
	MD5STEP(F4, b, c, d, a, puiIn[5] + 0xfc93a039, 21);
	MD5STEP(F4, a, b, c, d, puiIn[12] + 0x655b59c3, 6);
	MD5STEP(F4, d, a, b, c, puiIn[3] + 0x8f0ccc92, 10);
	MD5STEP(F4, c, d, a, b, puiIn[10] + 0xffeff47d, 15);
	MD5STEP(F4, b, c, d, a, puiIn[1] + 0x85845dd1, 21);
	MD5STEP(F4, a, b, c, d, puiIn[8] + 0x6fa87e4f, 6);
	MD5STEP(F4, d, a, b, c, puiIn[15] + 0xfe2ce6e0, 10);
	MD5STEP(F4, c, d, a, b, puiIn[6] + 0xa3014314, 15);
	MD5STEP(F4, b, c, d, a, puiIn[13] + 0x4e0811a1, 21);
	MD5STEP(F4, a, b, c, d, puiIn[4] + 0xf7537e82, 6);
	MD5STEP(F4, d, a, b, c, puiIn[11] + 0xbd3af235, 10);
	MD5STEP(F4, c, d, a, b, puiIn[2] + 0x2ad7d2bb, 15);
	MD5STEP(F4, b, c, d, a, puiIn[9] + 0xeb86d391, 21);
	//
	m_auiBuf[0] += a;
	m_auiBuf[1] += b;
	m_auiBuf[2] += c;
	m_auiBuf[3] += d;
}

void CMD5::Char2Hex(unsigned char ch, char* szHex)
{
	static unsigned char saucHex[] = "0123456789ABCDEF";
	szHex[0] = saucHex[ch >> 4];
	szHex[1] = saucHex[ch&0xF];
	szHex[2] = 0;
}

void CMD5::Binary2Hex(unsigned char const* pucBinStr, int iBinSize, char* pszHexStr)
{
	int i;
	char szHex[3];
	unsigned char const* pucBinStr1 = pucBinStr;
	*pszHexStr = 0;
	for(i=0; i<iBinSize; i++,pucBinStr1++)
	{
		Char2Hex(*pucBinStr1, szHex);
		strcat(pszHexStr, szHex);
	}
}

CString CMD5::getmd5string(const CString &source)
{

CString md5out;
char acDigest[65] = {0};
char acHex[129] = {0};

	AddData(LPCTSTR(source), source.GetLength());
	FinalDigest(acDigest);
	Binary2Hex(reinterpret_cast<unsigned char*>(acDigest), 16, acHex);

md5out = acHex;
return md5out;
}

    header

    //MD5.h

#ifndef __MD5_H__
#define __MD5_H__

class CMD5
{
public:
	CString getmd5string(const CString &source);
	//CONSTRUCTOR
	CMD5();

	void AddData(char const* pcData, int iDataLength);

	void FinalDigest(char* pcDigest);

	void Reset();

protected:

	enum { BLOCKSIZE=64 };
	bool m_bAddData;
	void Char2Hex(unsigned char ch, char* szHex);
	void Binary2Hex(unsigned char const* pucBinStr, int iBinSize, char* pszHexStr);

private:
	enum { MD128LENGTH=4 };;
	//Context Variables
	unsigned int m_auiBuf[4];
	unsigned int m_auiBits[2];
	unsigned char m_aucIn[64];
	//
	static unsigned int F1(unsigned int x, unsigned int y, unsigned int z);
	static unsigned int F2(unsigned int x, unsigned int y, unsigned int z);
	static unsigned int F3(unsigned int x, unsigned int y, unsigned int z);
	static unsigned int F4(unsigned int x, unsigned int y, unsigned int z);

	static void MD5STEP(unsigned int (*f)(unsigned int x, unsigned int y, unsigned int z),
		unsigned int& w, unsigned int x, unsigned int y, unsigned int z, unsigned int data, unsigned int s);

	void Transform();
};

inline unsigned int CMD5::F1(unsigned int x, unsigned int y, unsigned int z)
{
	return (z ^ (x & (y ^ z))); //OR (x & y | ~x & z)
}

inline unsigned int CMD5::F2(unsigned int x, unsigned int y, unsigned int z)
{
	return F1(z, x, y);
}

inline unsigned int CMD5::F3(unsigned int x, unsigned int y, unsigned int z)
{
	return x ^ y ^ z;
}

inline unsigned int CMD5::F4(unsigned int x, unsigned int y, unsigned int z)
{
	return (y ^ (x | ~z));
}

//This is the central step in the MD5 algorithm.
inline void CMD5::MD5STEP(unsigned int (*f)(unsigned int x, unsigned int y, unsigned int z),
	unsigned int& w, unsigned int x, unsigned int y, unsigned int z, unsigned int data, unsigned int s)
{
	w += f(x, y, z) + data;
	w = w << s | w >> (32-s);
	w += x;
}

#endif // __MD5_H__

    Funktion

    CString meinmd5 = getmd5string(md5source);
    0
  • C

    @devil81 und Unix Tom
    erstmal danke für die antwort...
    so wie muss ich jetzt eriter vorgehen? ich hab meine cpp datei in der der benutzer aufgefordert wie einen wert einzugeben. muss ich jetzt in der datei alle 3 header dateien einbinden? und wass muss ich mit den cpp dateien machen? sorry wenn die fragen dummm rüberkommen aber ich hab halt noch ned soviel erfahrung mit c++ ... wäre dankbar wenn ihrs mir erklären könntet 😉

    0
  • ?

    Man kann auch einfach die Windows Security API benutzen...

    0
  • C

    @Darph
    und wie nutzt ich die???

    0
Anmelden zum Antworten