unsigned char * ntpwdhash (unsigned char *szHash, const unsigned char *szPassword, int ctohex)
{
unsigned char szUnicodePass[513];
unsigned int nPasswordLen;
MD4_CTX ctx;
unsigned int i;
/*
* NT passwords are unicode. Convert plain text password
* to unicode by inserting a zero every other byte
*/
nPasswordLen = (int)strlen((char *)szPassword);
if(nPasswordLen > 255)nPasswordLen = 255;
for (i = 0; i < nPasswordLen; i++) {
szUnicodePass[i << 1] = szPassword[i];
szUnicodePass[(i << 1) + 1] = 0;
}
/* Encrypt Unicode password to a 16-byte MD4 hash */
MD4Init(&ctx);
MD4Update(&ctx, szUnicodePass, (nPasswordLen<<1));
MD4Final(szUnicodePass, &ctx);
if (ctohex){
tohex(szUnicodePass, szHash, 16);
}
else memcpy(szHash, szUnicodePass, 16);
return szHash;
}
void md4_mac(char *key, size_t key_size, char *message, size_t message_size, char *mac) {
MD4_CTX ctx;
MD4Init(&ctx);
MD4Update(&ctx, (uint8_t *)key, key_size);
MD4Update(&ctx, (uint8_t *)message, message_size);
MD4Final((uint8_t *)mac, &ctx);
}
/*!
* \see http://blogs.msdn.com/b/michael_howard/archive/2005/01/14/353379.aspx
*/
NTSTATUS
NTAPI
KsecGatherEntropyData(
PKSEC_ENTROPY_DATA EntropyData)
{
MD4_CTX Md4Context;
PTEB Teb;
PPEB Peb;
PWSTR String;
SIZE_T ReturnLength;
NTSTATUS Status;
/* Query some generic values */
EntropyData->CurrentProcessId = PsGetCurrentProcessId();
EntropyData->CurrentThreadId = PsGetCurrentThreadId();
KeQueryTickCount(&EntropyData->TickCount);
KeQuerySystemTime(&EntropyData->SystemTime);
EntropyData->PerformanceCounter = KeQueryPerformanceCounter(
&EntropyData->PerformanceFrequency);
/* Check if we have a TEB/PEB for the process environment */
Teb = PsGetCurrentThread()->Tcb.Teb;
if (Teb != NULL)
{
Peb = Teb->ProcessEnvironmentBlock;
/* Initialize the MD4 context */
MD4Init(&Md4Context);
_SEH2_TRY
{
/* Get the end of the environment */
String = Peb->ProcessParameters->Environment;
while (*String)
{
String += wcslen(String) + 1;
}
/* Update the MD4 context from the environment data */
MD4Update(&Md4Context,
(PUCHAR)Peb->ProcessParameters->Environment,
(ULONG)((PUCHAR)String - (PUCHAR)Peb->ProcessParameters->Environment));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Simply ignore the exception */
}
_SEH2_END;
/* Finalize and copy the MD4 hash */
MD4Final(&Md4Context);
RtlCopyMemory(&EntropyData->EnvironmentHash, Md4Context.digest, 16);
}
/* quick wrapper for easy md4 */
void
md4(unsigned char *from, int from_len, unsigned char *to)
{
MD4_CTX Context;
#ifndef __NetBSD__
from_len <<= 3; /* bytes->bits */
#endif
MD4Init(&Context);
MD4Update(&Context, from, from_len);
MD4Final(to, &Context);
}
static void
NTPasswordHash(u_char *secret, int secret_len, u_char hash[MD4_SIGNATURE_SIZE])
{
MD4_CTX md4Context;
unsigned char * secret_ch = (unsigned char *)secret;
MD4Init(&md4Context);
/* MD4Update() process maximum 64 bytes at a time. */
for( ; secret_len >= 64; secret_len -=64 )
{
MD4Update(&md4Context, secret_ch, 64*8);
secret_ch += 64;
}
MD4Update(&md4Context, secret_ch, secret_len*8);
MD4Final(hash, &md4Context);
}
/* ARGSUSED */
char *
MD4End(MD4_CTX *ctx, char *buf)
{
int i;
u_int8_t digest[MD4_DIGEST_LENGTH];
static const char hex[] = "0123456789abcdef";
if (buf == NULL && (buf = malloc(MD4_DIGEST_STRING_LENGTH)) == NULL)
return (NULL);
MD4Final(digest, ctx);
for (i = 0; i < MD4_DIGEST_LENGTH; i++) {
buf[i + i] = hex[digest[i] >> 4];
buf[i + i + 1] = hex[digest[i] & 0x0f];
}
buf[i + i] = '\0';
memset(digest, 0, sizeof(digest));
return (buf);
}
static NTSTATUS hash_finish( struct hash_impl *hash, enum alg_id alg_id,
UCHAR *output, ULONG size )
{
switch (alg_id)
{
case ALG_ID_MD2:
md2_finalize( &hash->u.md2, output );
break;
case ALG_ID_MD4:
MD4Final( &hash->u.md4 );
memcpy( output, hash->u.md4.digest, 16 );
break;
case ALG_ID_MD5:
MD5Final( &hash->u.md5 );
memcpy( output, hash->u.md5.digest, 16 );
break;
case ALG_ID_SHA1:
A_SHAFinal( &hash->u.sha1, (ULONG *)output );
break;
case ALG_ID_SHA256:
sha256_finalize( &hash->u.sha256, output );
break;
case ALG_ID_SHA384:
sha384_finalize( &hash->u.sha512, output );
break;
case ALG_ID_SHA512:
sha512_finalize( &hash->u.sha512, output );
break;
default:
ERR( "unhandled id %u\n", alg_id );
return STATUS_NOT_IMPLEMENTED;
}
return STATUS_SUCCESS;
}
static int
keycrunch_md4(char *result, char *seed, char *passwd)
{
char *buf = NULL;
MD4_CTX md;
u_int32_t results[4];
unsigned int buflen;
/*
* If seed and passwd are defined we are in keycrunch() mode,
* else we are in f() mode.
*/
if (seed && passwd) {
buflen = strlen(seed) + strlen(passwd);
if ((buf = malloc(buflen + 1)) == NULL)
return(-1);
(void)strlcpy(buf, seed, buflen + 1);
lowcase(buf);
(void)strlcat(buf, passwd, buflen + 1);
sevenbit(buf);
} else {
buf = result;
buflen = SKEY_BINKEY_SIZE;
}
/* Crunch the key through MD4 */
MD4Init(&md);
MD4Update(&md, (unsigned char *)buf, buflen);
MD4Final((unsigned char *)results, &md);
/* Fold result from 128 to 64 bits */
results[0] ^= results[2];
results[1] ^= results[3];
(void)memcpy((void *)result, (void *)results, SKEY_BINKEY_SIZE);
if (buf != result)
(void)free(buf);
return(0);
}
static void
md4(const char *src, const char *out)
{
MD4_CTX ctx;
unsigned char digest[16];
char s_digest[34];
assert(strlen(out) == 32);
MD4Init(&ctx);
if (strlen(src) > 12) {
MD4Update(&ctx, (const unsigned char *) src, 5);
MD4Update(&ctx, (const unsigned char *) src+5, strlen(src) - 5);
} else {
MD4Update(&ctx, (const unsigned char *) src, strlen(src));
}
MD4Final(&ctx, digest);
if (strcasecmp(bin2ascii(s_digest, digest, 16), out) != 0) {
fprintf(stderr, "Wrong md4(%s) -> %s expected %s\n", src, s_digest, out);
exit(1);
}
}
static void md4drv_from_erlang(ErlDrvData drv_data, char *buf, int len)
{
MD4_CTX context;
unsigned char digest[16];
t_md4drv *md4 = (t_md4drv *) drv_data;
ErlDrvBinary *bin = NULL;
MD4Init(&context);
MD4Update(&context, buf, len);
MD4Final(digest, &context);
if (!(bin = driver_alloc_binary(16))) {
driver_send_error(md4, &am_enomem);
}
else {
memcpy(bin->orig_bytes, digest, 16);
driver_send_bin(md4, bin, 16);
driver_free_binary(bin);
}
return;
}
void main (int nargs, char *args[])
{
char *filename = args[1];
unsigned char digest[16];
FILE *file;
MD4_CTX context;
int len;
unsigned char buffer[BUFFER_LEN];
if ((file = fopen (filename, "rb")) == NULL){
exit(2);
} else {
int i;
MD4Init (&context);
while ((len = fread (buffer, 1, BUFFER_LEN, file))!=0){
MD4Update (&context, buffer, len);}
MD4Final (digest, &context);
for(i=0; i<16; i++) printf("%d", digest[i]);
printf("\n");
fclose (file);
}
}
static char *
chap_BuildAnswer(char *name, char *key, u_char id, char *challenge
#ifndef NODES
, u_char type, char *peerchallenge, char *authresponse,
int lanman
#endif
)
{
char *result, *digest;
size_t nlen, klen;
nlen = strlen(name);
klen = strlen(key);
#ifndef NODES
if (type == 0x80) {
char expkey[AUTHLEN << 2];
MD4_CTX MD4context;
size_t f;
if ((result = malloc(1 + nlen + MS_CHAP_RESPONSE_LEN)) == NULL)
return result;
digest = result; /* the response */
*digest++ = MS_CHAP_RESPONSE_LEN; /* 49 */
memcpy(digest + MS_CHAP_RESPONSE_LEN, name, nlen);
if (lanman) {
memset(digest + 24, '\0', 25);
mschap_LANMan(digest, challenge + 1, key); /* LANMan response */
} else {
memset(digest, '\0', 25);
digest += 24;
for (f = 0; f < klen; f++) {
expkey[2*f] = key[f];
expkey[2*f+1] = '\0';
}
/*
* -----------
* expkey = | k\0e\0y\0 |
* -----------
*/
MD4Init(&MD4context);
MD4Update(&MD4context, expkey, klen << 1);
MD4Final(digest, &MD4context);
/*
* ---- -------- ---------------- ------- ------
* result = | 49 | LANMan | 16 byte digest | 9 * ? | name |
* ---- -------- ---------------- ------- ------
*/
mschap_NT(digest, challenge + 1);
}
/*
* ---- -------- ------------- ----- ------
* | | struct MS_ChapResponse24 | |
* result = | 49 | LANMan | NT digest | 0/1 | name |
* ---- -------- ------------- ----- ------
* where only one of LANMan & NT digest are set.
*/
} else if (type == 0x81) {
char expkey[AUTHLEN << 2];
char pwdhash[CHAP81_HASH_LEN];
char pwdhashhash[CHAP81_HASH_LEN];
char *ntresponse;
size_t f;
if ((result = malloc(1 + nlen + CHAP81_RESPONSE_LEN)) == NULL)
return result;
memset(result, 0, 1 + nlen + CHAP81_RESPONSE_LEN);
digest = result;
*digest++ = CHAP81_RESPONSE_LEN; /* value size */
/* Copy our challenge */
memcpy(digest, peerchallenge + 1, CHAP81_CHALLENGE_LEN);
/* Expand password to Unicode XXX */
for (f = 0; f < klen; f++) {
expkey[2*f] = key[f];
expkey[2*f+1] = '\0';
}
ntresponse = digest + CHAP81_NTRESPONSE_OFF;
/* Get some needed hashes */
NtPasswordHash(expkey, klen * 2, pwdhash);
HashNtPasswordHash(pwdhash, pwdhashhash);
/* Generate NTRESPONSE to respond on challenge call */
GenerateNTResponse(challenge + 1, peerchallenge + 1, name,
expkey, klen * 2, ntresponse);
/* Generate MPPE MASTERKEY */
GetMasterKey(pwdhashhash, ntresponse, MPPE_MasterKey); /* XXX Global ! */
/* Generate AUTHRESPONSE to verify on auth success */
GenerateAuthenticatorResponse(expkey, klen * 2, ntresponse,
peerchallenge + 1, challenge + 1, name,
authresponse);
authresponse[CHAP81_AUTHRESPONSE_LEN] = 0;
memcpy(digest + CHAP81_RESPONSE_LEN, name, nlen);
} else
#endif
if ((result = malloc(nlen + 17)) != NULL) {
/* Normal MD5 stuff */
MD5_CTX MD5context;
digest = result;
*digest++ = 16; /* value size */
MD5Init(&MD5context);
MD5Update(&MD5context, &id, 1);
MD5Update(&MD5context, key, klen);
MD5Update(&MD5context, challenge + 1, *challenge);
MD5Final(digest, &MD5context);
memcpy(digest + 16, name, nlen);
/*
* ---- -------- ------
* result = | 16 | digest | name |
* ---- -------- ------
*/
}
return result;
}
static char *
chap_BuildAnswer_old(char *name, char *key, u_char id, char *challenge, u_char type
#ifdef HAVE_DES
, int lanman
#endif
)
{
char *result;
#ifndef __GNU__
char *digest;
#endif /* __GNU__ */
size_t nlen, klen;
nlen = strlen(name);
klen = strlen(key);
#ifdef HAVE_DES
if (type == 0x80) {
char expkey[AUTHLEN << 2];
MD4_CTX MD4context;
int f;
if ((result = malloc(1 + nlen + MS_CHAP_RESPONSE_LEN)) == NULL)
return result;
digest = result; /* the response */
*digest++ = MS_CHAP_RESPONSE_LEN; /* 49 */
memcpy(digest + MS_CHAP_RESPONSE_LEN, name, nlen);
if (lanman) {
memset(digest + 24, '\0', 25);
mschap_LANMan(digest, challenge + 1, key); /* LANMan response */
} else {
memset(digest, '\0', 25);
digest += 24;
for (f = 0; f < klen; f++) {
expkey[2*f] = key[f];
expkey[2*f+1] = '\0';
}
/*
* -----------
* expkey = | k\0e\0y\0 |
* -----------
*/
MD4Init(&MD4context);
MD4Update(&MD4context, expkey, klen << 1);
MD4Final(digest, &MD4context);
/*
* ---- -------- ---------------- ------- ------
* result = | 49 | LANMan | 16 byte digest | 9 * ? | name |
* ---- -------- ---------------- ------- ------
*/
mschap_NT(digest, challenge + 1);
}
/*
* ---- -------- ------------- ----- ------
* | | struct MS_ChapResponse24 | |
* result = | 49 | LANMan | NT digest | 0/1 | name |
* ---- -------- ------------- ----- ------
* where only one of LANMan & NT digest are set.
*/
} else
#endif
if ((result = malloc(nlen + 17)) != NULL) {
/* Normal MD5 stuff */
#ifdef __GNU__
_exit (240); /* Critical */
#else
MD5_CTX MD5context;
digest = result;
*digest++ = 16; /* value size */
MD5Init(&MD5context);
MD5Update(&MD5context, &id, 1);
MD5Update(&MD5context, key, klen);
MD5Update(&MD5context, challenge + 1, *challenge);
MD5Final(digest, &MD5context);
memcpy(digest + 16, name, nlen);
/*
* ---- -------- ------
* result = | 16 | digest | name |
* ---- -------- ------
*/
#endif
}
return result;
}
int md4_low_final(MD4_CTX *context, unsigned char *out) {
MD4Final(out, context);
return 0;
}
/// Set Ed2k hash from a file
// returns false if aborted
bool Ed2kHash::SetED2KHashFromFile(const wxFileName& filename, MD4Hook hook)
{
// Open file and let wxFFile destructor close the file
// Closing it explicitly may crash on Win32 ...
wxFFile file(filename.GetFullPath(), wxT("rbS"));
if (! file.IsOpened())
{
wxLogError (_("Unable to open %s"),unicode2char(filename.GetFullPath()));
return (false);
}
else
{
unsigned char ret[MD4_HASHLEN_BYTE];
MD4Context hdc;
size_t read;
size_t partcount;
size_t dataread;
wxFileOffset totalread;
char *buf = new char[BUFSIZE];
bool goAhead = true;
#ifdef WANT_STRING_IMPLEMENTATION
wxString tmpHash(wxEmptyString);
#else
unsigned char* tmpCharHash = NULL;
#endif
// Clear Ed2k Hash
m_ed2kArrayOfHashes.Clear();
// Processing each block
totalread=0;
partcount = 0;
while (!file.Eof())
{
dataread = 0;
MD4Init(&hdc);
while (dataread < PARTSIZE && !file.Eof())
{
if (hook)
{
goAhead = hook((int)((double)(100.0 * totalread) / file.Length()));
}
if (goAhead)
{
if ((dataread + BUFSIZE) > PARTSIZE)
{
read = file.Read(buf, PARTSIZE - dataread);
}
else
{
read = file.Read(buf, BUFSIZE);
}
dataread += read;
totalread += read;
MD4Update(&hdc, reinterpret_cast<unsigned char const *>(buf),
read);
}
else
{
return (false);
}
}
MD4Final(&hdc, ret);
// Add part-hash
m_ed2kArrayOfHashes.Add(charToHex(reinterpret_cast<const char *>(ret),
MD4_HASHLEN_BYTE));
partcount++;
#ifdef WANT_STRING_IMPLEMENTATION
// MD4_HASHLEN_BYTE is ABSOLUTLY needed as we dont want NULL
// character to be interpreted as the end of the parthash string
#if wxUSE_UNICODE
tmpHash += wxString(reinterpret_cast<const wchar_t *>(ret),MD4_HASHLEN_BYTE);
#else
tmpHash += wxString(reinterpret_cast<const char *>(ret),MD4_HASHLEN_BYTE);
#endif
#else
tmpCharHash = (unsigned char*)realloc(tmpCharHash,
sizeof(unsigned char) * (MD4_HASHLEN_BYTE * partcount));
memcpy ( tmpCharHash + MD4_HASHLEN_BYTE * (partcount - 1), ret, MD4_HASHLEN_BYTE );
#endif
}
delete [] buf;
// hash == hash of concatenned parthashes
if (partcount > 1)
{
wxString finalHash;
#ifdef WANT_STRING_IMPLEMENTATION
finalHash=calcMd4FromString(tmpHash);
#else
MD4Init(&hdc);
MD4Update(&hdc, tmpCharHash, MD4_HASHLEN_BYTE * partcount);
MD4Final(&hdc, ret);
finalHash = charToHex(reinterpret_cast<const char *>(ret),
MD4_HASHLEN_BYTE);
#endif
m_ed2kArrayOfHashes.Add(finalHash);
}
#ifndef WANT_STRING_IMPLEMENTATION
free(tmpCharHash);
tmpCharHash=NULL;
#endif
m_ed2kArrayOfHashes.Shrink();
// Set members
m_fileSize = file.Length();
m_filename = filename.GetFullName();
return true;
}
}
int CHashManager::HashFile(char *pszFile)
{
FILE *fp = NULL;
unsigned char pBuf[SIZE_HASH_BUFFER];
unsigned long uRead = 0;
unsigned char pTemp[256];
char szTemp[RH_MAX_BUFFER];
int i = 0;
printf("File: <");
printf(pszFile);
printf(">");
printf(CPS_NEWLINE);
fp = fopen(pszFile, "rb");
if(fp == NULL) return RH_CANNOT_OPEN_FILE;
if(m_bAlgorithm[HASHID_CRC16]) crc16_init(&m_crc16);
if(m_bAlgorithm[HASHID_CRC16CCITT]) crc16ccitt_init(&m_crc16ccitt);
if(m_bAlgorithm[HASHID_CRC32]) crc32Init(&m_crc32);
if(m_bAlgorithm[HASHID_FCS_16]) fcs16_init(&m_fcs16);
if(m_bAlgorithm[HASHID_FCS_32]) fcs32_init(&m_fcs32);
if(m_bAlgorithm[HASHID_GHASH_32_3] || m_bAlgorithm[HASHID_GHASH_32_5]) m_ghash.Init();
if(m_bAlgorithm[HASHID_GOST]) gosthash_reset(&m_gost);
if(m_bAlgorithm[HASHID_HAVAL]) haval_start(&m_haval);
if(m_bAlgorithm[HASHID_MD2]) m_md2.Init();
if(m_bAlgorithm[HASHID_MD4]) MD4Init(&m_md4);
if(m_bAlgorithm[HASHID_MD5]) MD5Init(&m_md5, 0);
if(m_bAlgorithm[HASHID_SHA1]) sha1_begin(&m_sha1);
if(m_bAlgorithm[HASHID_SHA2_256]) sha256_begin(&m_sha256);
if(m_bAlgorithm[HASHID_SHA2_384]) sha384_begin(&m_sha384);
if(m_bAlgorithm[HASHID_SHA2_512]) sha512_begin(&m_sha512);
if(m_bAlgorithm[HASHID_SIZE_32]) sizehash32_begin(&m_uSizeHash32);
if(m_bAlgorithm[HASHID_TIGER]) tiger_init(&m_tiger);
while(1)
{
uRead = fread(pBuf, 1, SIZE_HASH_BUFFER, fp);
if(uRead != 0)
{
if(m_bAlgorithm[HASHID_CRC16])
crc16_update(&m_crc16, pBuf, uRead);
if(m_bAlgorithm[HASHID_CRC16CCITT])
crc16ccitt_update(&m_crc16ccitt, pBuf, uRead);
if(m_bAlgorithm[HASHID_CRC32])
crc32Update(&m_crc32, pBuf, uRead);
if(m_bAlgorithm[HASHID_FCS_16])
fcs16_update(&m_fcs16, pBuf, uRead);
if(m_bAlgorithm[HASHID_FCS_32])
fcs32_update(&m_fcs32, pBuf, uRead);
if(m_bAlgorithm[HASHID_GHASH_32_3] || m_bAlgorithm[HASHID_GHASH_32_5])
m_ghash.Update(pBuf, uRead);
if(m_bAlgorithm[HASHID_GOST])
gosthash_update(&m_gost, pBuf, uRead);
if(m_bAlgorithm[HASHID_HAVAL])
haval_hash(&m_haval, pBuf, uRead);
if(m_bAlgorithm[HASHID_MD2])
m_md2.Update(pBuf, uRead);
if(m_bAlgorithm[HASHID_MD4])
MD4Update(&m_md4, pBuf, uRead);
if(m_bAlgorithm[HASHID_MD5])
MD5Update(&m_md5, pBuf, uRead);
if(m_bAlgorithm[HASHID_SHA1])
sha1_hash(pBuf, uRead, &m_sha1);
if(m_bAlgorithm[HASHID_SHA2_256])
sha256_hash(pBuf, uRead, &m_sha256);
if(m_bAlgorithm[HASHID_SHA2_384])
sha384_hash(pBuf, uRead, &m_sha384);
if(m_bAlgorithm[HASHID_SHA2_512])
sha512_hash(pBuf, uRead, &m_sha512);
if(m_bAlgorithm[HASHID_SIZE_32])
sizehash32_hash(&m_uSizeHash32, uRead);
if(m_bAlgorithm[HASHID_TIGER])
tiger_process(&m_tiger, pBuf, uRead);
}
if(uRead != SIZE_HASH_BUFFER) break;
}
fclose(fp); fp = NULL;
// SizeHash-32 is the first hash, because it's the simplest one,
// the fastest, and most widely used one. ;-)
if(m_bAlgorithm[HASHID_SIZE_32])
{
sizehash32_end(&m_uSizeHash32);
printf(SZ_SIZEHASH_32);
printf(SZ_HASHPRE);
printf("%08X", m_uSizeHash32);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_CRC16])
{
crc16_final(&m_crc16);
printf(SZ_CRC16);
printf(SZ_HASHPRE);
printf("%04X", m_crc16);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_CRC16CCITT])
{
crc16ccitt_final(&m_crc16ccitt);
printf(SZ_CRC16CCITT);
printf(SZ_HASHPRE);
printf("%04X", m_crc16ccitt);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_CRC32])
{
crc32Finish(&m_crc32);
printf(SZ_CRC32);
printf(SZ_HASHPRE);
printf("%08X", m_crc32);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_FCS_16])
{
fcs16_final(&m_fcs16);
printf(SZ_FCS_16);
printf(SZ_HASHPRE);
printf("%04X", m_fcs16);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_FCS_32])
{
fcs32_final(&m_fcs32);
printf(SZ_FCS_32);
printf(SZ_HASHPRE);
printf("%08X", m_fcs32);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_GHASH_32_3])
{
m_ghash.FinalToStr(szTemp, 3);
printf(SZ_GHASH_32_3);
printf(SZ_HASHPRE);
printf(szTemp);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_GHASH_32_5])
{
m_ghash.FinalToStr(szTemp, 5);
printf(SZ_GHASH_32_5);
printf(SZ_HASHPRE);
printf(szTemp);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_GOST])
{
gosthash_final(&m_gost, pTemp);
printf(SZ_GOST);
printf(SZ_HASHPRE);
for(i = 0; i < 32; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_HAVAL])
{
haval_end(&m_haval, pTemp);
printf(SZ_HAVAL);
printf(SZ_HASHPRE);
for(i = 0; i < 32; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_MD2])
{
m_md2.TruncatedFinal(pTemp, 16);
printf(SZ_MD2);
printf(SZ_HASHPRE);
for(i = 0; i < 16; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_MD4])
{
MD4Final(pTemp, &m_md4);
printf(SZ_MD4);
printf(SZ_HASHPRE);
for(i = 0; i < 16; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_MD5])
{
MD5Final(&m_md5);
printf(SZ_MD5);
printf(SZ_HASHPRE);
for(i = 0; i < 16; i++)
{
fmtFixHashOutput(i);
printf("%02X", m_md5.digest[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_SHA1])
{
sha1_end(pTemp, &m_sha1);
printf(SZ_SHA1);
printf(SZ_HASHPRE);
for(i = 0; i < 20; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_SHA2_256])
{
sha256_end(pTemp, &m_sha256);
printf(SZ_SHA2_256);
printf(SZ_HASHPRE);
for(i = 0; i < 32; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_SHA2_384])
{
sha384_end(pTemp, &m_sha384);
printf(SZ_SHA2_384);
printf(SZ_HASHPRE);
for(i = 0; i < 48; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_SHA2_512])
{
sha512_end(pTemp, &m_sha512);
printf(SZ_SHA2_512);
printf(SZ_HASHPRE);
for(i = 0; i < 64; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_TIGER])
{
tiger_done(&m_tiger, pTemp);
printf(SZ_TIGER);
printf(SZ_HASHPRE);
for(i = 0; i < 8; i++) { fmtFixHashOutput(i); printf("%02X", pTemp[7-i]); }
for(i = 8; i < 16; i++) { fmtFixHashOutput(i); printf("%02X", pTemp[23-i]); }
for(i = 16; i < 24; i++) { fmtFixHashOutput(i); printf("%02X", pTemp[39-i]); }
printf(CPS_NEWLINE);
}
return RH_SUCCESS;
}
