unsigned char *MD4(const unsigned char *d, size_t n, unsigned char *md)
{
MD4_CTX c;
static unsigned char m[MD4_DIGEST_LENGTH];
if (md == NULL)
md = m;
if (!MD4_Init(&c))
return NULL;
#ifndef CHARSET_EBCDIC
MD4_Update(&c, d, n);
#else
{
char temp[1024];
unsigned long chunk;
while (n > 0) {
chunk = (n > sizeof(temp)) ? sizeof(temp) : n;
ebcdic2ascii(temp, d, chunk);
MD4_Update(&c, temp, chunk);
n -= chunk;
d += chunk;
}
}
#endif
MD4_Final(md, &c);
OPENSSL_cleanse(&c, sizeof(c)); /* security consideration */
return (md);
}
static void DCC(unsigned char *salt, unsigned int username_len,
unsigned int *dcc_hash, unsigned int count)
{
unsigned int id ;
unsigned int buffer[64] ;
unsigned int nt_hash[69] ; // large enough to handle 128 byte user name (when we expand to that size).
int password_len;
MD4_CTX ctx;
for (id = 0; id < count; id++) {
/* Proper Unicode conversion from UTF-8 or codepage */
password_len = enc_to_utf16((UTF16*)buffer,
MAX_PLAINTEXT_LENGTH,
(UTF8*)key_host[id],
strlen((const char*)key_host[id]));
/* Handle truncation */
if (password_len < 0)
password_len = strlen16((UTF16*)buffer);
// generate MD4 hash of the password (NT hash)
MD4_Init(&ctx);
MD4_Update(&ctx, buffer, password_len<<1);
MD4_Final((unsigned char*)nt_hash, &ctx);
// concatenate NT hash and the username (salt)
memcpy((unsigned char *)nt_hash + 16, salt, username_len << 1) ;
MD4_Init(&ctx);
MD4_Update(&ctx, nt_hash, (username_len<<1)+16);
MD4_Final((unsigned char*)(dcc_hash+4*id), &ctx);
}
}
void md4_keyed_mac(unsigned char *message, int mlen, unsigned char *key,
int klen, unsigned char *out)
{
MD4_CTX c;
MD4_Init(&c);
MD4_Update(&c, key, klen);
MD4_Update(&c, message, mlen);
MD4_Final(out, &c);
}
int ed2k (int fd)
{
int length;
int chunknum, chunklength, curlength;
MD4_CTX root;
MD4_CTX chunk;
MD4_Init(&root);
MD4_Init(&chunk);
chunknum = 0;
chunklength = 0;
file_length = 0;
while((length = read(fd, buff, BUFF_SIZE)) > 0)
{
file_length += length;
if (length + chunklength > CHUNK_SIZE)
{
curlength = CHUNK_SIZE - chunklength;
length = length - curlength;
}
else
{
curlength = length;
length = 0;
}
MD4_Update(&chunk, buff, curlength);
chunklength += curlength;
if (chunklength == CHUNK_SIZE)
{
MD4_Final(md, &chunk);
MD4_Init(&chunk);
MD4_Update(&root, md, MD4_DIGEST_LENGTH);
MD4_Update(&chunk, &buff[curlength], length);
chunklength = length;
chunknum ++;
}
}
if (length < 0)
{
return -1;
}
if (chunknum > 0)
{
if (chunklength > 0)
{
MD4_Final(md, &chunk);
MD4_Update(&root, md, MD4_DIGEST_LENGTH);
}
MD4_Final(md, &root);
}
else
MD4_Final(md, &chunk);
return 0;
}
NOEXPORT char *ntlm3(char *username, char *password, char *phase2) {
MD4_CTX md4;
char *decoded; /* decoded reply from proxy */
char phase3[146];
unsigned char md4_hash[21];
unsigned int userlen=strlen(username);
unsigned int phase3len=s_min(88+userlen, sizeof phase3);
/* setup phase3 structure */
memset(phase3, 0, sizeof phase3);
strcpy(phase3, "NTLMSSP");
phase3[8]=3; /* type: 3 */
phase3[16]=phase3len; /* LM-resp off */
phase3[20]=24; /* NT-resp len */
phase3[22]=24; /* NT-Resp len */
phase3[24]=64; /* NT-resp off */
phase3[32]=phase3len; /* domain offset */
phase3[36]=userlen; /* user length */
phase3[38]=userlen; /* user length */
phase3[40]=88; /* user offset */
phase3[48]=phase3len; /* host offset */
phase3[56]=phase3len; /* message len */
phase3[60]=2; /* flag: negotiate OEM */
phase3[61]=2; /* flag: negotiate NTLM */
/* calculate MD4 of UTF-16 encoded password */
MD4_Init(&md4);
while(*password) {
MD4_Update(&md4, password++, 1);
MD4_Update(&md4, "", 1); /* UTF-16 */
}
MD4_Final(md4_hash, &md4);
memset(md4_hash+16, 0, 5); /* pad to 21 bytes */
/* decode challenge and calculate response */
decoded=base64(0, phase2, strlen(phase2)); /* decode */
if(!decoded)
return NULL;
crypt_DES((unsigned char *)phase3+64,
(unsigned char *)decoded+24, md4_hash);
crypt_DES((unsigned char *)phase3+72,
(unsigned char *)decoded+24, md4_hash+7);
crypt_DES((unsigned char *)phase3+80,
(unsigned char *)decoded+24, md4_hash+14);
str_free(decoded);
strncpy(phase3+88, username, sizeof phase3-88);
return base64(1, phase3, phase3len); /* encode */
}
static int _do_loop(void)
{
unsigned char buf[_BUFSIZ];
unsigned char digest[MD4_DIGEST_LENGTH + 1];
int n = 0;
do {
n = read(_g_infd, buf, _BUFSIZ);
if (n > 0)
MD4_Update(&_g_md4ctx, buf, n);
} while (n > 0);
MD4_Final(digest, &_g_md4ctx);
digest[MD4_DIGEST_LENGTH] = 0;
if (_g_outfd >= 0) {
write(_g_outfd, digest, MD4_DIGEST_LENGTH);
close(_g_outfd);
_g_outfd = -1;
}
else {
int i;
printf("MD4(%s)= ", _g_infile);
for (i = 0; i < MD4_DIGEST_LENGTH; i++)
printf("%.2x", digest[i]);
printf("\n");
}
return 0;
}
void md4_length_extension(unsigned char *hash, int state_len, unsigned char *append,
int append_len, unsigned char *out)
{
MD4_CTX c;
MD4_Init(&c);
MD4_Update(&c, hash, state_len);
c.A = htole32(((uint32_t *)hash)[0]);
c.B = htole32(((uint32_t *)hash)[1]);
c.C = htole32(((uint32_t *)hash)[2]);
c.D = htole32(((uint32_t *)hash)[3]);
MD4_Update(&c, append, append_len);
MD4_Final(out, &c);
}
/**
Digests the input data and updates MD4 context.
This function performs MD4 digest on a data buffer of the specified size.
It can be called multiple times to compute the digest of long or discontinuous data streams.
MD4 context should be already correctly intialized by Md4Init(), and should not be finalized
by Md4Final(). Behavior with invalid context is undefined.
If Md4Context is NULL, then return FALSE.
@param[in, out] Md4Context Pointer to the MD4 context.
@param[in] Data Pointer to the buffer containing the data to be hashed.
@param[in] DataSize Size of Data buffer in bytes.
@retval TRUE MD4 data digest succeeded.
@retval FALSE MD4 data digest failed.
**/
BOOLEAN
EFIAPI
Md4Update (
IN OUT VOID *Md4Context,
IN CONST VOID *Data,
IN UINTN DataSize
)
{
//
// Check input parameters.
//
if (Md4Context == NULL) {
return FALSE;
}
//
// Check invalid parameters, in case that only DataLength was checked in OpenSSL
//
if (Data == NULL && DataSize != 0) {
return FALSE;
}
//
// OpenSSL MD4 Hash Update
//
return (BOOLEAN) (MD4_Update ((MD4_CTX *) Md4Context, Data, DataSize));
}
void MD4Encode(unsigned char *output, const unsigned char *input, unsigned int len){
#ifdef USE_COMMON_CRYPTO
CC_MD4_CTX context = {};
CC_MD4_Init (&context);
CC_MD4_Update (&context, (unsigned char *)input, len);
CC_MD4_Final (output, &context);
#else
MD4_CTX context = {};
MD4_Init (&context);
MD4_Update (&context, (unsigned char *)input, len);
MD4_Final (output, &context);
/*
mbedtls_md4_context ctx;
mbedtls_md4_init( &ctx );
mbedtls_md4_starts( &ctx );
mbedtls_md4_update( &ctx, (unsigned char *)input, len );
mbedtls_md4_finish( &ctx, output );
mbedtls_md4_free( &ctx );
*/
#endif
}
void winpr_MD4_Update(WINPR_MD4_CTX* ctx, const BYTE* input, size_t ilen)
{
#if defined(WITH_OPENSSL)
MD4_Update((MD4_CTX*) ctx, input, ilen);
#elif defined(WITH_MBEDTLS) && defined(MBEDTLS_MD4_C)
mbedtls_md4_update((mbedtls_md4_context*) ctx, input, ilen);
#endif
}
uint8_t *MD4(const uint8_t *data, size_t len, uint8_t *out) {
MD4_CTX ctx;
MD4_Init(&ctx);
MD4_Update(&ctx, data, len);
MD4_Final(out, &ctx);
return out;
}
void Util::md_update(int protocol, md_struct *context, const char *data, int size)
{
if (protocol >= 30) {
MD5_Update(&context->md5, data, size);
} else {
MD4_Update(&context->md4, data, size);
}
}
uint8* crypto_md4_hash(rdpBlob* blob)
{
MD4_CTX md4_ctx;
uint8* hash;
hash = (uint8*)xzalloc(16);
MD4_Init(&md4_ctx);
MD4_Update(&md4_ctx, blob->data, blob->length);
MD4_Final(hash, &md4_ctx);
return hash;
}
// create NTLM hash using md4
void ntlm_v1 (uint8_t *out, char *pwd)
{
MD4_CTX ctx;
size_t pwd_len;
wchar_t wcs_pwd[128];
pwd_len=mbstowcs (wcs_pwd, pwd, 128);
MD4_Init (&ctx);
MD4_Update (&ctx, pwd, pwd_len*2);
MD4_Final (out, &ctx);
}
unsigned char *MD4(const unsigned char *d, size_t n, unsigned char *md)
{
MD4_CTX c;
static unsigned char m[MD4_DIGEST_LENGTH];
if (md == NULL) md=m;
if (!MD4_Init(&c))
return NULL;
MD4_Update(&c,d,n);
MD4_Final(md,&c);
explicit_bzero(&c,sizeof(c));
return(md);
}
void ntlm1_password(char *password, u8 *digest)
{
u16 uni_pwd[128]={0};
u32 pass_len = strlen(password);
MD4_CTX ctx;
for(int i = 0;i < pass_len;i++)
uni_pwd[i] = password[i];
MD4_Init(&ctx);
MD4_Update(&ctx,uni_pwd,pass_len*2);
MD4_Final(digest,&ctx);
}
ikptr
ikrt_openssl_md4_update (ikptr s_ctx, ikptr s_input, ikptr s_input_len, ikpcb * pcb)
{
#ifdef HAVE_MD4_UPDATE
MD4_CTX * ctx = IK_MD4_CTX(s_ctx);
const void * in = IK_GENERALISED_C_STRING(s_input);
size_t in_len = ik_generalised_c_buffer_len(s_input, s_input_len);
int rv;
rv = MD4_Update(ctx, in, (unsigned long)in_len);
return IK_BOOLEAN_FROM_INT(rv);
#else
feature_failure(__func__);
#endif
}
BYTE* NTOWFv1W(LPWSTR Password, UINT32 PasswordLength, BYTE* NtHash)
{
MD4_CTX md4_ctx;
if (!Password)
return NULL;
if (!NtHash)
NtHash = malloc(16);
MD4_Init(&md4_ctx);
MD4_Update(&md4_ctx, Password, PasswordLength);
MD4_Final((void*) NtHash, &md4_ctx);
return NtHash;
}
void smb_ntlm_hash(const char *password, smb_ntlmh *hash)
{
MD4_CTX ctx;
char *ucs2le_pass;
size_t sz;
assert(password != NULL && hash != NULL);
sz = smb_to_utf16(password, strlen(password), &ucs2le_pass);
memset((void *)hash, 0, SMB_NTLM_HASH_SIZE);
MD4_Init(&ctx);
MD4_Update(&ctx, (uint8_t *)ucs2le_pass, sz);
MD4_Final((uint8_t *)hash, &ctx);
free(ucs2le_pass);
}
void do_fp(FILE *f)
{
MD4_CTX c;
unsigned char md[MD4_DIGEST_LENGTH];
int fd;
int i;
static unsigned char buf[BUFSIZE];
fd=fileno(f);
MD4_Init(&c);
for (;;)
{
i=read(fd,buf,sizeof buf);
if (i <= 0) break;
MD4_Update(&c,buf,(unsigned long)i);
}
MD4_Final(&(md[0]),&c);
pt(md);
}
static void MD4_File(FILE *file, unsigned char **output, int *outlength)
{
*output = new unsigned char[MD4_DIGEST_LENGTH];
*outlength = MD4_DIGEST_LENGTH;
MD4_CTX c;
int i;
unsigned char buf[MD4_FILE_BUFFER_SIZE];
MD4_Init(&c);
for (;;)
{
i = fread(buf,1,MD4_FILE_BUFFER_SIZE,file);
if(i <= 0)
break;
MD4_Update(&c,buf,(unsigned long)i);
}
MD4_Final(*output, &c);
}
void E_md4hash(uchar *passwd, uchar *p16)
{
int len;
int16 wpwd[129];
MD4_CTX ctx;
/* Password cannot be longer than 128 characters */
len = strlen((char *)passwd);
if(len > 128)
len = 128;
/* Password must be converted to NT unicode */
_my_mbstowcs(wpwd, passwd, len);
wpwd[len] = 0; /* Ensure string is null terminated */
/* Calculate length in bytes */
len = _my_wcslen(wpwd) * sizeof(int16);
MD4_Init(&ctx);
MD4_Update(&ctx, (unsigned char *)wpwd, len);
MD4_Final(p16, &ctx);
}
ULONG
AnscCryptoMd4Digest
(
PVOID buffer,
ULONG size,
PANSC_CRYPTO_HASH hash
)
{
#ifdef _ANSC_MD4_USED_
MD4_CTX context;
MD4_Init (&context);
MD4_Update(&context, (PUCHAR)buffer, size);
MD4_Final (hash->Value, &context);
hash->Length = ANSC_MD4_OUTPUT_SIZE;
#else
AnscTrace("WARNING: MD4 digest is disabled!!!\n");
#endif
return hash->Length;
}
static int update(EVP_MD_CTX *ctx, const void *data, size_t count)
{
return MD4_Update(ctx->md_data, data, count);
}
void MD4_Digester::Update(const u8* p, size_t len)
{
MD4_Update(&m_ctx, p, len);
}
int ed2k_link(char *fname, char ed2k_hash[])
{
/* It will do the ed2k hashing of the file inputted
* and it will finfo struct finfo.ed2k_hash
* and return the pounter to the changed finfo.
*/
static const char hashzero[33] = HASHZERO;
unsigned int a, b;
unsigned char *parthash;
unsigned char *hash;
int fl;
int64_t filesize;
MD4_CTX contents;
int chunks;
int len, start;
void *map;
filesize = get_file_size(fname);
if (filesize == -1){
/* We did not get file size
* err and quit
*/
fprintf(stderr, "We failed to get file size; abouting...\n");
return -1;
}
if(filesize == 0){
/* Refuse to work on zero byte files and
* return md4 of ""
*/
for(a = 0; a < 33; a++){
ed2k_hash[a] = hashzero[a];
}
return 1;
}
chunks = filesize/CHUNKSIZE;
if (filesize % CHUNKSIZE > 0){
chunks++;
}
parthash = (unsigned char*) malloc(16);
if (!parthash){
return 0;
}
parthash = (unsigned char*) malloc(chunks*16);
hash = (unsigned char* ) malloc(16);
fl = open(fname, O_RDONLY);
if (fl < 0){
fprintf(stderr, "Failded to open the file");
return +1;
}
for (a = 0; a < chunks; a++){
len = CHUNKSIZE;
MD4_CTX content;
if (a == chunks - 1){
len = filesize % CHUNKSIZE;
}
start = b*CHUNKSIZE;
map = mmap(NULL, len, PROT_READ, MAP_SHARED, fl, a*CHUNKSIZE);
if (map == NULL){
fprintf(stderr, "mmap() failed:, %s",strerror(errno));
return 0;
}
MD4_Init(&content);
MD4_Update(&content, map, len);
MD4_Final(parthash+(b*16), &content);
munmap(map, len);
printf("partial hash block %i\n", a);
}
if(chunks > 1){
MD4_Init(&contents);
MD4_Update(&contents, parthash,b*16);
MD4_Final(hash, &contents);
}else {
memcpy(hash, parthash, 16);
}
memset(ed2k_hash, 0x00, 33*sizeof(char));
for(b=0; b<16; b++){
ed2k_hash[(b<<1)] = hexdigits[(((hash[b]) & 0xf0) >> 4)];
ed2k_hash[(b<<1) + 1] = hexdigits[(((hash[b]) & 0x0f))];
}
return -1;
}
/*
HashNTLM
Function: Create a NTLM hash from the challenge
Variables:
ntlmhash = the hash created from this function
pass = users password
challenge = the challenge recieved from the server
*/
void
HashNTLM(unsigned char **ntlmhash, unsigned char *pass, unsigned char *challenge, char *miscptr)
{
MD4_CTX md4Context;
unsigned char hash[16]; /* MD4_SIGNATURE_SIZE = 16 */
unsigned char unicodePassword[256 * 2]; /* MAX_NT_PASSWORD = 256 */
unsigned char p21[21];
unsigned char ntlm_response[24];
int i = 0, j = 0;
int mdlen;
unsigned char *p;
char HexChar;
int HexValue;
/* Use NTLM Hash instead of password */
if (hashFlag == 1) {
/* 1000:D42E35E1A1E4C22BD32E2170E4857C20:5E20780DD45857A68402938C7629D3B2::: */
p = pass;
while ((*p != '\0') && (i < 2)) {
if (*p == ':')
i++;
p++;
}
if (*p == '\0') {
fprintf(stderr, "Error reading PWDUMP file.\n");
hydra_child_exit(0);
exit(1);
}
for (i = 0; i < 16; i++) {
HexValue = 0x0;
for (j = 0; j < 2; j++) {
HexChar = (char) p[2 * i + j];
if (HexChar > 0x39)
HexChar = HexChar | 0x20; /* convert upper case to lower */
if (!(((HexChar >= 0x30) && (HexChar <= 0x39)) || /* 0 - 9 */
((HexChar >= 0x61) && (HexChar <= 0x66)))) { /* a - f */
/*
* fprintf(stderr, "Error invalid char (%c) for hash.\n", HexChar);
* hydra_child_exit(0);
* exit(1);
*/
HexChar = 0x30;
}
HexChar -= 0x30;
if (HexChar > 0x09) /* HexChar is "a" - "f" */
HexChar -= 0x27;
HexValue = (HexValue << 4) | (char) HexChar;
}
hash[i] = (unsigned char) HexValue;
}
} else {
/* Password == Machine Name */
if (hashFlag == 2) {
for (i = 0; i < 16; i++) {
if (machine_name[i] > 0x39)
machine_name[i] = machine_name[i] | 0x20; /* convert upper case to lower */
pass = machine_name;
}
}
/* Initialize the Unicode version of the secret (== password). */
/* This implicitly supports 8-bit ISO8859/1 characters. */
bzero(unicodePassword, sizeof(unicodePassword));
for (i = 0; i < strlen((char *) pass); i++)
unicodePassword[i * 2] = (unsigned char) pass[i];
mdlen = strlen((char *) pass) * 2; /* length in bytes */
MD4_Init(&md4Context);
MD4_Update(&md4Context, unicodePassword, mdlen);
MD4_Final(hash, &md4Context); /* Tell MD4 we're done */
}
memset(p21, '\0', 21);
memcpy(p21, hash, 16);
DesEncrypt(challenge, p21 + 0, ntlm_response + 0);
DesEncrypt(challenge, p21 + 7, ntlm_response + 8);
DesEncrypt(challenge, p21 + 14, ntlm_response + 16);
memcpy(*ntlmhash, ntlm_response, 24);
}
//MD4 hash function
bool __fastcall MD4_Hash(
FILE *Input)
{
//Parameters check
if ((HashFamilyID != HASH_ID_MD4 && HashFamilyID != HASH_ID_ED2K) || Input == nullptr)
{
fwprintf_s(stderr, L"Parameters error.\n");
return false;
}
//Initialization
size_t ReadBlockSize = FILE_BUFFER_SIZE, ReadLength = 0, RoundCount = 0;
if (HashFamilyID == HASH_ID_ED2K)
ReadBlockSize = ED2K_SIZE_BLOCK;
std::shared_ptr<char> Buffer(new char[ReadBlockSize]()), StringBuffer(new char[FILE_BUFFER_SIZE]()), BufferED2K(new char[MD4_SIZE_DIGEST]());
memset(Buffer.get(), 0, ReadBlockSize);
memset(StringBuffer.get(), 0, FILE_BUFFER_SIZE);
memset(BufferED2K.get(), 0, MD4_SIZE_DIGEST);
MD4_CTX HashInstance, HashInstanceED2K;
memset(&HashInstance, 0, sizeof(MD4_CTX));
memset(&HashInstanceED2K, 0, sizeof(MD4_CTX));
//MD4 initialization
MD4_Init(&HashInstance);
if (HashFamilyID == HASH_ID_ED2K)
MD4_Init(&HashInstanceED2K);
//Hash process
while (!feof(Input))
{
memset(Buffer.get(), 0, ReadBlockSize);
_set_errno(0);
ReadLength = fread_s(Buffer.get(), ReadBlockSize, sizeof(char), ReadBlockSize, Input);
if (ReadLength == 0)
{
fwprintf_s(stderr, L"Hash process error");
if (errno > 0)
fwprintf_s(stderr, L", error code is %d.\n", errno);
else
fwprintf_s(stderr, L".\n");
return false;
}
else {
MD4_Update(&HashInstance, Buffer.get(), ReadLength);
if (HashFamilyID == HASH_ID_ED2K)
{
MD4_Final((unsigned char *)Buffer.get(), &HashInstance);
memcpy_s(BufferED2K.get(), MD4_SIZE_DIGEST, Buffer.get(), MD4_SIZE_DIGEST);
MD4_Update(&HashInstanceED2K, Buffer.get(), MD4_SIZE_DIGEST);
MD4_Init(&HashInstance);
}
++RoundCount;
}
}
//Binary to hex
memset(Buffer.get(), 0, ReadBlockSize);
if (HashFamilyID == HASH_ID_MD4)
{
MD4_Final((unsigned char *)Buffer.get(), &HashInstance);
}
else if (HashFamilyID == HASH_ID_ED2K)
{
if (RoundCount > 1U)
MD4_Final((unsigned char *)Buffer.get(), &HashInstanceED2K);
else
memcpy_s(Buffer.get(), MD4_SIZE_DIGEST, BufferED2K.get(), MD4_SIZE_DIGEST);
}
else {
return false;
}
if (sodium_bin2hex(StringBuffer.get(), FILE_BUFFER_SIZE, (const unsigned char *)Buffer.get(), MD4_SIZE_DIGEST) == nullptr)
{
fwprintf_s(stderr, L"Convert binary to hex error.\n");
return false;
}
else {
//Print to screen.
std::string HashResult = StringBuffer.get();
CaseConvert(true, HashResult);
for (size_t Index = 0;Index < HashResult.length();++Index)
fwprintf_s(stderr, L"%c", HashResult.c_str()[Index]);
fwprintf_s(stderr, L"\n");
}
return true;
}
static void
client_mschapv2(const void *server_nonce, size_t snoncelen,
const void *client_nonce, size_t cnoncelen,
const char *username,
const char *password)
{
SHA_CTX ctx;
MD4_CTX hctx;
unsigned char md[SHA_DIGEST_LENGTH], challange[SHA_DIGEST_LENGTH];
unsigned char hmd[MD4_DIGEST_LENGTH];
struct ntlm_buf answer;
int i, len, ret;
char *h;
SHA1_Init(&ctx);
SHA1_Update(&ctx, client_nonce, cnoncelen);
SHA1_Update(&ctx, server_nonce, snoncelen);
SHA1_Update(&ctx, username, strlen(username));
SHA1_Final(md, &ctx);
MD4_Init(&hctx);
len = strlen(password);
for (i = 0; i < len; i++) {
MD4_Update(&hctx, &password[i], 1);
MD4_Update(&hctx, &password[len], 1);
}
MD4_Final(hmd, &hctx);
/* ChallengeResponse */
ret = heim_ntlm_calculate_ntlm1(hmd, sizeof(hmd), md, &answer);
if (ret)
errx(1, "heim_ntlm_calculate_ntlm1");
hex_encode(answer.data, answer.length, &h);
printf("responseData=%s\n", h);
free(h);
/* PasswordHash */
MD4_Init(&hctx);
MD4_Update(&hctx, hmd, sizeof(hmd));
MD4_Final(hmd, &hctx);
/* GenerateAuthenticatorResponse */
SHA1_Init(&ctx);
SHA1_Update(&ctx, hmd, sizeof(hmd));
SHA1_Update(&ctx, answer.data, answer.length);
SHA1_Update(&ctx, ms_chap_v2_magic1, sizeof(ms_chap_v2_magic1));
SHA1_Final(md, &ctx);
/* ChallengeHash */
SHA1_Init(&ctx);
SHA1_Update(&ctx, client_nonce, cnoncelen);
SHA1_Update(&ctx, server_nonce, snoncelen);
SHA1_Update(&ctx, username, strlen(username));
SHA1_Final(challange, &ctx);
SHA1_Init(&ctx);
SHA1_Update(&ctx, md, sizeof(md));
SHA1_Update(&ctx, challange, 8);
SHA1_Update(&ctx, ms_chap_v2_magic2, sizeof(ms_chap_v2_magic2));
SHA1_Final(md, &ctx);
hex_encode(md, sizeof(md), &h);
printf("AuthenticatorResponse=%s\n", h);
free(h);
/* get_master, rfc 3079 3.4 */
SHA1_Init(&ctx);
SHA1_Update(&ctx, hmd, sizeof(hmd));
SHA1_Update(&ctx, answer.data, answer.length);
SHA1_Update(&ctx, ms_rfc3079_magic1, sizeof(ms_rfc3079_magic1));
SHA1_Final(md, &ctx);
free(answer.data);
hex_encode(md, 16, &h);
printf("session-key=%s\n", h);
free(h);
}
static char *
ed2k_hash (char *filename)
{
unsigned long size;
int fd, b, j, blocks;
unsigned char *parthashes, *ed2k_hash;
char *ed2k_hash_str;
if ((fd = open(filename, O_RDONLY)) < 0) {
ANIDBFS_DEBUG("Failed to open file (%s)", filename);
return NULL;
}
size = get_file_size(fd);
if (size <= 0) {
ANIDBFS_DEBUG("Error getting filesize (%s)", filename);
return NULL;
}
blocks = size / BLOCKSIZE;
if (size % BLOCKSIZE > 0)
blocks++;
ed2k_hash = (unsigned char *) malloc(16);
ed2k_hash_str = (char *) malloc(33);
parthashes = (unsigned char *) malloc(blocks * 16);
if ((!parthashes) || (!ed2k_hash) || (!ed2k_hash_str) || (!filename)) {
ANIDBFS_DEBUG("Failed to allocate memory (%s)", filename);
return NULL;
}
for (b = 0; b < blocks; b++) {
MD4_CTX context;
int len, start;
void *map;
len = BLOCKSIZE;
if (b == blocks - 1)
len = size % BLOCKSIZE;
start = b * BLOCKSIZE;
map = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, b * BLOCKSIZE);
if (map == NULL) {
ANIDBFS_DEBUG("mmap failed (%s)", filename);
}
MD4_Init(&context);
MD4_Update(&context, map, len);
MD4_Final(parthashes + (b * 16), &context);
munmap(map, len);
/* int percent = (int) (((float) (b+1) / (float) blocks) * 100);
ANIDBFS_DEBUG("Hashing %s %d%%", filename, percent);*/
}
close(fd);
if (blocks > 1) {
MD4_CTX context;
MD4_Init(&context);
MD4_Update(&context, parthashes, 16 * b);
MD4_Final(ed2k_hash, &context);
} else {
memcpy(ed2k_hash, parthashes, 16);
}
memset(ed2k_hash_str, 0x00, 33 * sizeof(char));
for (j = 0; j < 16; j++) {
ed2k_hash_str[(j<<1)] = hexdigits[(((ed2k_hash[j]) & 0xf0) >> 4)];
ed2k_hash_str[(j<<1)+1] = hexdigits[(((ed2k_hash[j]) & 0x0f))];
}
free(ed2k_hash);
free(parthashes);
return ed2k_hash_str;
}
