void MSN_MakeDigest(const char* chl, char* dgst) { //Digest it DWORD md5hash[4], md5hashOr[4]; mir_md5_state_t context; mir_md5_init(&context); mir_md5_append(&context, (BYTE*)chl, (int)strlen(chl)); mir_md5_append(&context, (BYTE*)msnProtChallenge, (int)strlen(msnProtChallenge)); mir_md5_finish(&context, (BYTE*)md5hash); memcpy(md5hashOr, md5hash, sizeof(md5hash)); size_t i; for (i=0; i < 4; i++) md5hash[i] &= 0x7FFFFFFF; char chlString[128]; mir_snprintf(chlString, sizeof(chlString), "%s%s00000000", chl, msnProductID); chlString[(strlen(chl)+strlen(msnProductID)+7) & 0xF8] = 0; LONGLONG high=0, low=0; int* chlStringArray = (int*)chlString; for (i=0; i < strlen(chlString) / 4; i += 2) { LONGLONG temp = chlStringArray[i]; temp = (0x0E79A9C1 * temp) % 0x7FFFFFFF; temp += high; temp = md5hash[0] * temp + md5hash[1]; temp = temp % 0x7FFFFFFF; high = chlStringArray[i + 1]; high = (high + temp) % 0x7FFFFFFF; high = md5hash[2] * high + md5hash[3]; high = high % 0x7FFFFFFF; low = low + high + temp; } high = (high + md5hash[1]) % 0x7FFFFFFF; low = (low + md5hash[3]) % 0x7FFFFFFF; md5hashOr[0] ^= high; md5hashOr[1] ^= low; md5hashOr[2] ^= high; md5hashOr[3] ^= low; char* str = arrayToHex((PBYTE)md5hashOr, sizeof(md5hashOr)); strcpy(dgst, str); mir_free(str); }
BYTE* utils::md5string(const BYTE *data, int size, BYTE *digest) { mir_md5_state_t md5_state; mir_md5_init(&md5_state); mir_md5_append(&md5_state, data, size); mir_md5_finish(&md5_state, digest); return digest; }
char *EvaUtil::doMd5(char *in, int len) { mir_md5_state_t ctx; mir_md5_init(&ctx); mir_md5_append(&ctx, (mir_md5_byte_t *)in, len); mir_md5_finish(&ctx, (mir_md5_byte_t *)md5Buf); return md5Buf; }
int CAimProto::aim_auth_request(HANDLE hServerConn, unsigned short &seqno, const char* key, const char* language, const char* country, const char* username, const char* password) { unsigned short offset = 0; BYTE pass_hash[16]; BYTE auth_hash[16]; mir_md5_state_t state; mir_md5_init(&state); mir_md5_append(&state, (const BYTE *)password, (int)mir_strlen(password)); mir_md5_finish(&state, pass_hash); mir_md5_init(&state); mir_md5_append(&state, (BYTE*)key, (int)mir_strlen(key)); mir_md5_append(&state, (BYTE*)pass_hash, MD5_HASH_LENGTH); mir_md5_append(&state, (BYTE*)AIM_MD5_STRING, sizeof(AIM_MD5_STRING) - 1); mir_md5_finish(&state, auth_hash); char client_id[64], mirver[64]; CallService(MS_SYSTEM_GETVERSIONTEXT, sizeof(mirver), (LPARAM)mirver); int client_id_len = mir_snprintf(client_id, "Miranda AIM, version %s", mirver); char* buf = (char*)alloca(SNAC_SIZE + TLV_HEADER_SIZE * 14 + MD5_HASH_LENGTH + mir_strlen(username) + client_id_len + 30 + mir_strlen(language) + mir_strlen(country)); aim_writesnac(0x17, 0x02, offset, buf); aim_writetlv(0x01, (unsigned short)mir_strlen(username), username, offset, buf); aim_writetlv(0x25, MD5_HASH_LENGTH, (char*)auth_hash, offset, buf); aim_writetlv(0x4C, 0, 0, offset, buf);//signifies new password hash instead of old method aim_writetlv(0x03, (unsigned short)client_id_len, client_id, offset, buf); aim_writetlvshort(0x17, AIM_CLIENT_MAJOR_VERSION, offset, buf); aim_writetlvshort(0x18, AIM_CLIENT_MINOR_VERSION, offset, buf); aim_writetlvshort(0x19, AIM_CLIENT_LESSER_VERSION, offset, buf); aim_writetlvshort(0x1A, AIM_CLIENT_BUILD_NUMBER, offset, buf); aim_writetlvshort(0x16, AIM_CLIENT_ID_NUMBER, offset, buf); aim_writetlvlong(0x14, AIM_CLIENT_DISTRIBUTION_NUMBER, offset, buf); aim_writetlv(0x0F, (unsigned short)mir_strlen(language), language, offset, buf); aim_writetlv(0x0E, (unsigned short)mir_strlen(country), country, offset, buf); aim_writetlvchar(0x4A, getByte(AIM_KEY_FSC, 0) ? 3 : 1, offset, buf); // aim_writetlvchar(0x94,0,offset,buf); if (!getByte(AIM_KEY_DSSL, 0)) aim_writetlv(0x8c, 0, NULL, offset, buf); // Request SSL connection return aim_sendflap(hServerConn, 0x02, offset, buf, seqno); }
void CIcqProto::handleAuthKeyResponse(BYTE *buf, size_t wPacketLen, serverthread_info *info) { char szKey[64] = {0}; mir_md5_state_t state; BYTE digest[16]; debugLogA("Received %s", "ICQ_SIGNON_AUTH_KEY"); if (wPacketLen < 2) { debugLogA("Malformed %s", "ICQ_SIGNON_AUTH_KEY"); icq_LogMessage(LOG_FATAL, LPGEN("Secure login failed.\nInvalid server response.")); SetCurrentStatus(ID_STATUS_OFFLINE); return; } size_t wKeyLen; unpackWord(&buf, &wKeyLen); wPacketLen -= 2; if (!wKeyLen || wKeyLen > wPacketLen || wKeyLen > sizeof(szKey)) { debugLogA("Invalid length in %s: %u", "ICQ_SIGNON_AUTH_KEY", wKeyLen); icq_LogMessage(LOG_FATAL, LPGEN("Secure login failed.\nInvalid key length.")); SetCurrentStatus(ID_STATUS_OFFLINE); return; } unpackString(&buf, szKey, wKeyLen); mir_md5_init(&state); mir_md5_append(&state, info->szAuthKey, (int)info->wAuthKeyLen); mir_md5_finish(&state, digest); mir_md5_init(&state); mir_md5_append(&state, (LPBYTE)szKey, (int)wKeyLen); mir_md5_append(&state, digest, 16); mir_md5_append(&state, (LPBYTE)CLIENT_MD5_STRING, sizeof(CLIENT_MD5_STRING)-1); mir_md5_finish(&state, digest); debugLogA("Sending ICQ_SIGNON_LOGIN_REQUEST to login server"); sendClientAuth((char*)digest, 0x10, TRUE); }
BYTE* calcMD5HashOfFile(const TCHAR *tszFile) { BYTE *res = NULL; HANDLE hFile = NULL, hMap = NULL; if ((hFile = CreateFile(tszFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL )) != INVALID_HANDLE_VALUE) { if ((hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL) { long cbFileSize = GetFileSize(hFile, NULL); res = (BYTE*)SAFE_MALLOC(16 * sizeof(BYTE)); if (cbFileSize != 0 && res) { mir_md5_state_t state; BYTE digest[16]; int dwOffset = 0; mir_md5_init(&state); while (dwOffset < cbFileSize) { BYTE *ppMap = NULL; int dwBlockSize = min(MD5_BLOCK_SIZE, cbFileSize-dwOffset); if (!(ppMap = (BYTE*)MapViewOfFile(hMap, FILE_MAP_READ, 0, dwOffset, dwBlockSize))) break; mir_md5_append(&state, (const BYTE *)ppMap, dwBlockSize); UnmapViewOfFile(ppMap); dwOffset += dwBlockSize; } mir_md5_finish(&state, digest); memcpy(res, digest, 16 * sizeof(BYTE)); } } if (hMap != NULL) CloseHandle(hMap); if (hFile != NULL) CloseHandle(hFile); } return res; }
static void SetAvatar(TlenProtocol *proto, HANDLE hContact, TLEN_LIST_ITEM *item, char *data, int len, DWORD format) { TCHAR filename[MAX_PATH]; char md5[33]; mir_md5_state_t ctx; DWORD digest[4]; if (format == PA_FORMAT_UNKNOWN && len > 4) format = ProtoGetBufferFormat(data); mir_md5_init( &ctx ); mir_md5_append( &ctx, ( BYTE* )data, len); mir_md5_finish( &ctx, ( BYTE* )digest ); sprintf( md5, "%08x%08x%08x%08x", (int)htonl(digest[0]), (int)htonl(digest[1]), (int)htonl(digest[2]), (int)htonl(digest[3])); //!!!!!!!!!!!!!! if (item != NULL) { char *hash = item->avatarHash; item->avatarFormat = format; item->avatarHash = mir_strdup(md5); mir_free(hash); } else { proto->threadData->avatarFormat = format; strcpy(proto->threadData->avatarHash, md5); } TlenGetAvatarFileName(proto, item, filename, sizeof filename ); DeleteFile(filename); FILE *out = _tfopen(filename, TEXT("wb") ); if (out != NULL) { fwrite(data, len, 1, out); fclose(out); db_set_ts(hContact, "ContactPhoto", "File", filename ); db_set_s(hContact, proto->m_szModuleName, "AvatarHash", md5); db_set_dw(hContact, proto->m_szModuleName, "AvatarFormat", format); } else { TCHAR buffer[128]; mir_sntprintf(buffer, SIZEOF(buffer), TranslateT("Can not save new avatar file \"%s\" Error:\n\t%s (Error: %d)"), filename, _tcserror(errno), errno); PUShowMessageT(buffer, SM_WARNING); proto->debugLog(buffer); return; } ProtoBroadcastAck( proto->m_szModuleName, hContact, ACKTYPE_AVATAR, ACKRESULT_STATUS, NULL , 0); }
bool get_avatar_hash(const TCHAR* file, char* hash, char** data, unsigned short &size) { int fileId = _topen(file, _O_RDONLY | _O_BINARY, _S_IREAD); if (fileId == -1) return false; long lAvatar = _filelength(fileId); if (lAvatar <= 0) { _close(fileId); return false; } char* pResult = (char*)mir_alloc(lAvatar); int res = _read(fileId, pResult, lAvatar); _close(fileId); if (res <= 0) { mir_free(pResult); return false; } mir_md5_state_t state; mir_md5_init(&state); mir_md5_append(&state, (unsigned char*)pResult, lAvatar); mir_md5_finish(&state, (unsigned char*)hash); if (data) { *data = pResult; size = (unsigned short)lAvatar; } else mir_free(pResult); return true; }
INT_PTR CAimProto::SetAvatar(WPARAM, LPARAM lParam) { TCHAR *szFileName = (TCHAR*)lParam; if (m_state != 1) return 1; if (szFileName == NULL) { aim_ssi_update(m_hServerConn, m_seqno, true); aim_delete_avatar_hash(m_hServerConn, m_seqno, 1, 1, m_avatar_id_sm); aim_delete_avatar_hash(m_hServerConn, m_seqno, 1, 12, m_avatar_id_lg); aim_ssi_update(m_hServerConn, m_seqno, false); avatar_request_handler(NULL, NULL, 0); } else { char hash[16], hash1[16], *data, *data1 = NULL; unsigned short size, size1 = 0; if (!get_avatar_hash(szFileName, hash, &data, size)) { mir_free(hash); return 1; } rescale_image(data, size, data1, size1); if (size1) { mir_md5_state_t state; mir_md5_init(&state); mir_md5_append(&state, (unsigned char*)data1, size1); mir_md5_finish(&state, (unsigned char*)hash1); mir_free(m_hash_lg); m_hash_lg = bytes_to_string(hash, sizeof(hash)); mir_free(m_hash_sm); m_hash_sm = bytes_to_string(hash1, sizeof(hash1)); aim_ssi_update(m_hServerConn, m_seqno, true); aim_set_avatar_hash(m_hServerConn, m_seqno, 1, 1, m_avatar_id_sm, 16, hash1); aim_set_avatar_hash(m_hServerConn, m_seqno, 1, 12, m_avatar_id_lg, 16, hash); aim_ssi_update(m_hServerConn, m_seqno, false); } else { mir_free(m_hash_lg); m_hash_lg = NULL; mir_free(m_hash_sm); m_hash_sm = bytes_to_string(hash, sizeof(hash1)); aim_ssi_update(m_hServerConn, m_seqno, true); aim_set_avatar_hash(m_hServerConn, m_seqno, 1, 1, m_avatar_id_sm, 16, hash); aim_delete_avatar_hash(m_hServerConn, m_seqno, 1, 12, m_avatar_id_lg); aim_ssi_update(m_hServerConn, m_seqno, false); } avatar_request_handler(NULL, NULL, 0); avatar_up_req *req = new avatar_up_req(data, size, data1, size1); ForkThread(&CAimProto::avatar_upload_thread, req); TCHAR tFileName[MAX_PATH]; TCHAR *ext = _tcsrchr(szFileName, '.'); get_avatar_filename(NULL, tFileName, _countof(tFileName), ext); int fileId = _topen(tFileName, _O_CREAT | _O_TRUNC | _O_WRONLY | O_BINARY, _S_IREAD | _S_IWRITE); if (fileId < 0) { char errmsg[512]; mir_snprintf(errmsg, "Cannot store avatar. File '%s' could not be created/overwritten", tFileName); ShowPopup(errmsg, ERROR_POPUP); return 1; } _write(fileId, data, size); _close(fileId); } return 0; }
int PEChecksum( TCHAR *filename, BYTE digest[16] ) { HANDLE hFile = INVALID_HANDLE_VALUE; HANDLE hMap; PBYTE ptr = 0; int res = RESULT_OK; DWORD filesize; DWORD hsize = 0; WORD machine = 0; DWORD sections = 0; hFile = CreateFile( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL ); if ( hFile == INVALID_HANDLE_VALUE ) return RESULT_NOTFOUND; // check minimum and maximum size filesize = GetFileSize( hFile, &hsize ); if ( !filesize || filesize == INVALID_FILE_SIZE || hsize ) { CloseHandle( hFile ); return RESULT_INVALID; } if ( filesize < sizeof(IMAGE_DOS_HEADER) + sizeof(IMAGE_NT_HEADERS)) { CloseHandle( hFile ); return RESULT_NOTPE; } hMap = CreateFileMapping( hFile, NULL, PAGE_WRITECOPY, 0, 0, NULL ); if ( hMap ) ptr = (PBYTE)MapViewOfFile( hMap, FILE_MAP_COPY, 0, 0 ,0 ); if ( ptr ) { PIMAGE_DOS_HEADER pIDH = 0; PIMAGE_NT_HEADERS pINTH = 0; pIDH = (PIMAGE_DOS_HEADER)ptr; if ( pIDH->e_magic == IMAGE_DOS_SIGNATURE ) pINTH = (PIMAGE_NT_HEADERS)( ptr + pIDH->e_lfanew ); if ( !pINTH) res = RESULT_NOTPE; else if ((PBYTE)pINTH + sizeof(IMAGE_NT_HEADERS) >= ptr + filesize ) res = RESULT_CORRUPTED; else if ( pINTH->Signature != IMAGE_NT_SIGNATURE ) res = RESULT_NOTPE; else { machine = pINTH->FileHeader.Machine; #ifdef DEBUG_SECTIONS if ( debug ) { switch(machine) { case IMAGE_FILE_MACHINE_I386: _ftprintf( stderr, _T("Build: x86\n")); break; case IMAGE_FILE_MACHINE_AMD64: _ftprintf( stderr, _T("Build: x64\n")); break; case IMAGE_FILE_MACHINE_IA64: _ftprintf( stderr, _T("Build: IA64 :-)\n")); break; default: _ftprintf( stderr, _T("Build: unknown :-(\n")); break; } } #endif sections = pINTH->FileHeader.NumberOfSections; if ( !sections ) res = RESULT_INVALID; else { PIMAGE_DATA_DIRECTORY pIDD = 0; PIMAGE_DEBUG_DIRECTORY pDBG = 0; DWORD dbgSize = 0, dbgAddr = 0; // debug information DWORD expSize = 0, expAddr = 0; // export table DWORD resSize = 0, resAddr = 0; // resource directory DWORD relocSize = 0, relocAddr = 0; // relocation table PBYTE pRealloc = 0; DWORD offset; ULONGLONG base = 0; // try to found correct offset independent of architectures offset = pIDH->e_lfanew + pINTH->FileHeader.SizeOfOptionalHeader + sizeof(IMAGE_NT_HEADERS) - sizeof(IMAGE_OPTIONAL_HEADER); if (( machine == IMAGE_FILE_MACHINE_I386 ) && ( pINTH->FileHeader.SizeOfOptionalHeader >= sizeof(IMAGE_OPTIONAL_HEADER32)) && ( pINTH->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC )) { pIDD = (PIMAGE_DATA_DIRECTORY)((PBYTE)pINTH + offsetof( IMAGE_NT_HEADERS32, OptionalHeader.DataDirectory )); base = *(DWORD*)((PBYTE)pINTH + offsetof( IMAGE_NT_HEADERS32, OptionalHeader.ImageBase )); } else if (( machine == IMAGE_FILE_MACHINE_AMD64 ) && ( pINTH->FileHeader.SizeOfOptionalHeader >= sizeof(IMAGE_OPTIONAL_HEADER64)) && ( pINTH->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC )) { pIDD = (PIMAGE_DATA_DIRECTORY)((PBYTE)pINTH + offsetof( IMAGE_NT_HEADERS64, OptionalHeader.DataDirectory )); base = *(ULONGLONG*)((PBYTE)pINTH + offsetof( IMAGE_NT_HEADERS64, OptionalHeader.ImageBase )); } else res = RESULT_CORRUPTED; #ifdef DEBUG_REALLOCS if ( debug ) _ftprintf( stderr, _T("Image base is 0x%I64x \n"), base ); #endif if ( pIDD ) { // Debugging information entry dbgAddr = pIDD[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress; dbgSize = pIDD[IMAGE_DIRECTORY_ENTRY_DEBUG].Size; // Export information entry expAddr = pIDD[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress; expSize = pIDD[IMAGE_DIRECTORY_ENTRY_EXPORT].Size; // Resource directory resAddr = pIDD[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress; resSize = pIDD[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size; // Reallocation information entry relocAddr = pIDD[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress; relocSize = pIDD[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size; } // verify image integrity for (DWORD idx=0; idx < sections; idx++) { PIMAGE_SECTION_HEADER pISH = (PIMAGE_SECTION_HEADER)( ptr + offset + idx * sizeof(IMAGE_SECTION_HEADER)); if (((PBYTE)pISH + sizeof(IMAGE_SECTION_HEADER) > ptr + filesize ) || ( pISH->PointerToRawData + pISH->SizeOfRawData > filesize )) { res = RESULT_CORRUPTED; break; } // erase timestamp if (( dbgSize >= sizeof( IMAGE_DEBUG_DIRECTORY )) && ( dbgAddr >= pISH->VirtualAddress ) && ( dbgAddr + dbgSize <= pISH->VirtualAddress + pISH->SizeOfRawData )) { DWORD shift = dbgAddr - pISH->VirtualAddress; pDBG = (PIMAGE_DEBUG_DIRECTORY)( ptr + shift + pISH->PointerToRawData ); pDBG->TimeDateStamp = 0; #ifdef DEBUG_SECTIONS if ( debug ) _ftprintf( stderr, _T("Found debug section entry at 0x%08X (%d), data at 0x%08X (%d)\n"), pISH->PointerToRawData + shift, dbgSize, pDBG->PointerToRawData, pDBG->SizeOfData ); #endif } // erase export timestamp if (( expSize >= sizeof( IMAGE_EXPORT_DIRECTORY )) && ( expAddr >= pISH->VirtualAddress ) && ( expAddr + expSize <= pISH->VirtualAddress + pISH->SizeOfRawData )) { DWORD shift = expAddr - pISH->VirtualAddress; PIMAGE_EXPORT_DIRECTORY pEXP = (PIMAGE_EXPORT_DIRECTORY)( ptr + shift + pISH->PointerToRawData ); pEXP->TimeDateStamp = 0; #ifdef DEBUG_SECTIONS if ( debug ) _ftprintf( stderr, _T("Found export section entry at 0x%08X\n"), pISH->PointerToRawData + shift ); #endif } // find realocation table if (( relocSize >= sizeof( IMAGE_BASE_RELOCATION )) && ( relocAddr >= pISH->VirtualAddress ) && ( relocAddr + relocSize <= pISH->VirtualAddress + pISH->SizeOfRawData )) { DWORD shift = relocAddr - pISH->VirtualAddress; pRealloc = ptr + shift + pISH->PointerToRawData; #ifdef DEBUG_SECTIONS if ( debug ) _ftprintf( stderr, _T("Found reallocation table entry at 0x%08X (%d)\n"), pISH->PointerToRawData + shift, relocSize ); #endif } } if ( res == RESULT_OK ) { mir_md5_state_t pms; mir_md5_init( &pms ); for (size_t idx=0; idx < sections; idx++) { PIMAGE_SECTION_HEADER pISH = (PIMAGE_SECTION_HEADER)( ptr + offset + idx * sizeof(IMAGE_SECTION_HEADER)); if (((PBYTE)pISH + sizeof(IMAGE_SECTION_HEADER) > ptr + filesize ) || ( pISH->PointerToRawData + pISH->SizeOfRawData > filesize )) { res = RESULT_CORRUPTED; break; } // erase debug information if ( pDBG && pDBG->SizeOfData > 0 && pDBG->PointerToRawData >= pISH->PointerToRawData && pDBG->PointerToRawData + pDBG->SizeOfData <= pISH->PointerToRawData + pISH->SizeOfRawData ) { ZeroMemory( ptr + pDBG->PointerToRawData, pDBG->SizeOfData ); } // patch resources if ( resSize > 0 && resAddr >= pISH->VirtualAddress && resAddr + resSize <= pISH->VirtualAddress + pISH->SizeOfRawData ) { DWORD shift = resAddr - pISH->VirtualAddress + pISH->PointerToRawData; IMAGE_RESOURCE_DIRECTORY* pIRD = (IMAGE_RESOURCE_DIRECTORY*)( ptr + shift ); PatchResourcesDirectory(pIRD, ptr + shift); } // rebase to zero address if ( pRealloc ) { DWORD blocklen = relocSize; PWORD pw; DWORD type; int len; PBYTE pAddr; DWORD shift; DWORD addr; PIMAGE_BASE_RELOCATION pIBR = (PIMAGE_BASE_RELOCATION)pRealloc; while( pIBR ) { if (( pIBR->VirtualAddress >= pISH->VirtualAddress ) && ( pIBR->VirtualAddress < pISH->VirtualAddress + pISH->SizeOfRawData ) && ( pIBR->SizeOfBlock <= blocklen )) { shift = pIBR->VirtualAddress - pISH->VirtualAddress + pISH->PointerToRawData; len = pIBR->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION); pw = (PWORD)((PBYTE)pIBR + sizeof(IMAGE_BASE_RELOCATION)); #ifdef DEBUG_REALLOCS if ( debug ) _ftprintf( stderr, _T("Realloc block at %08X (%d)\n"), pIBR->VirtualAddress, pIBR->SizeOfBlock ); #endif while( len > 0 ) { type = *pw >> 12; addr = ( *pw & 0x0FFF ); pAddr = ptr + shift + addr; switch( type ) { case IMAGE_REL_BASED_HIGHLOW: if ( addr + pIBR->VirtualAddress + sizeof(DWORD) >= pISH->VirtualAddress + pISH->SizeOfRawData ) { len = 0; break; } #ifdef DEBUG_REALLOCS if ( debug && ( *(PDWORD)pAddr < (DWORD)base )) _ftprintf( stderr, _T("Realloc address is less than base\n")); #endif *(PDWORD)pAddr = (DWORD)((*(PDWORD)pAddr) - (DWORD)base ); break; case IMAGE_REL_BASED_DIR64: if ( addr + pIBR->VirtualAddress + sizeof(ULONGLONG) >= pISH->VirtualAddress + pISH->SizeOfRawData ) { len = 0; break; } #ifdef DEBUG_REALLOCS if ( debug && ( *(ULONGLONG*)pAddr < base )) _ftprintf( stderr, _T("Realloc address is less than base\n")); #endif *(ULONGLONG*)pAddr = (ULONGLONG)((*(ULONGLONG*)pAddr) - base ); break; case IMAGE_REL_BASED_ABSOLUTE: // stop processing len = 0; break; case IMAGE_REL_BASED_HIGH: case IMAGE_REL_BASED_LOW: case IMAGE_REL_BASED_HIGHADJ: #ifdef DEBUG_REALLOCS if ( debug ) _ftprintf( stderr, _T("Unexpected block type %d\n"), type ); #endif break; default: #ifdef DEBUG_REALLOCS if ( debug ) _ftprintf( stderr, _T("Unknown block type %d\n"), type ); #endif break; } len -= sizeof(WORD); pw++; } } blocklen -= pIBR->SizeOfBlock; if ( blocklen > sizeof(IMAGE_BASE_RELOCATION)) pIBR = (PIMAGE_BASE_RELOCATION)((PBYTE)pIBR + pIBR->SizeOfBlock ); else break; } } #ifdef DEBUG_SECTIONS if ( debug ) { int i; BYTE digest2[16]; mir_md5_state_t pms2; mir_md5_init( &pms2 ); mir_md5_append( &pms2, ptr + pISH->PointerToRawData, pISH->SizeOfRawData ); mir_md5_finish( &pms2, digest2 ); _ftprintf( stderr, _T("%s - %08X - %d "), pISH->Name, pISH->PointerToRawData, pISH->SizeOfRawData); for ( i = 0; i < sizeof( digest2 ) / sizeof( digest2[0] ); i++ ) _ftprintf( stderr, _T("%02X"), digest2[i] ); _ftprintf( stderr, _T("\n")); } #endif mir_md5_append( &pms, ptr + pISH->PointerToRawData, pISH->SizeOfRawData ); } if ( res == RESULT_OK ) mir_md5_finish( &pms, digest ); } } }
char* TMD5Auth::getChallenge(const TCHAR *challenge) { if (iCallCount > 0) return NULL; iCallCount++; unsigned resultLen; ptrA text((char*)mir_base64_decode( _T2A(challenge), &resultLen)); TStringPairs pairs(text); const char *realm = pairs["realm"], *nonce = pairs["nonce"]; char cnonce[40], tmpBuf[40]; DWORD digest[4], hash1[4], hash2[4]; mir_md5_state_t ctx; Utils_GetRandom(digest, sizeof(digest)); mir_snprintf(cnonce, _countof(cnonce), "%08x%08x%08x%08x", htonl(digest[0]), htonl(digest[1]), htonl(digest[2]), htonl(digest[3])); T2Utf uname(info->conn.username), passw(info->conn.password); ptrA serv(mir_utf8encode(info->conn.server)); mir_md5_init(&ctx); mir_md5_append(&ctx, (BYTE*)(char*)uname, (int)mir_strlen(uname)); mir_md5_append(&ctx, (BYTE*)":", 1); mir_md5_append(&ctx, (BYTE*)realm, (int)mir_strlen(realm)); mir_md5_append(&ctx, (BYTE*)":", 1); mir_md5_append(&ctx, (BYTE*)(char*)passw, (int)mir_strlen(passw)); mir_md5_finish(&ctx, (BYTE*)hash1); mir_md5_init(&ctx); mir_md5_append(&ctx, (BYTE*)hash1, 16); mir_md5_append(&ctx, (BYTE*)":", 1); mir_md5_append(&ctx, (BYTE*)nonce, (int)mir_strlen(nonce)); mir_md5_append(&ctx, (BYTE*)":", 1); mir_md5_append(&ctx, (BYTE*)cnonce, (int)mir_strlen(cnonce)); mir_md5_finish(&ctx, (BYTE*)hash1); mir_md5_init(&ctx); mir_md5_append(&ctx, (BYTE*)"AUTHENTICATE:xmpp/", 18); mir_md5_append(&ctx, (BYTE*)(char*)serv, (int)mir_strlen(serv)); mir_md5_finish(&ctx, (BYTE*)hash2); mir_md5_init(&ctx); mir_snprintf(tmpBuf, _countof(tmpBuf), "%08x%08x%08x%08x", htonl(hash1[0]), htonl(hash1[1]), htonl(hash1[2]), htonl(hash1[3])); mir_md5_append(&ctx, (BYTE*)tmpBuf, (int)mir_strlen(tmpBuf)); mir_md5_append(&ctx, (BYTE*)":", 1); mir_md5_append(&ctx, (BYTE*)nonce, (int)mir_strlen(nonce)); mir_snprintf(tmpBuf, _countof(tmpBuf), ":%08d:", iCallCount); mir_md5_append(&ctx, (BYTE*)tmpBuf, (int)mir_strlen(tmpBuf)); mir_md5_append(&ctx, (BYTE*)cnonce, (int)mir_strlen(cnonce)); mir_md5_append(&ctx, (BYTE*)":auth:", 6); mir_snprintf(tmpBuf, _countof(tmpBuf), "%08x%08x%08x%08x", htonl(hash2[0]), htonl(hash2[1]), htonl(hash2[2]), htonl(hash2[3])); mir_md5_append(&ctx, (BYTE*)tmpBuf, (int)mir_strlen(tmpBuf)); mir_md5_finish(&ctx, (BYTE*)digest); char *buf = (char*)alloca(8000); int cbLen = mir_snprintf(buf, 8000, "username=\"%s\",realm=\"%s\",nonce=\"%s\",cnonce=\"%s\",nc=%08d," "qop=auth,digest-uri=\"xmpp/%s\",charset=utf-8,response=%08x%08x%08x%08x", uname, realm, nonce, cnonce, iCallCount, serv, htonl(digest[0]), htonl(digest[1]), htonl(digest[2]), htonl(digest[3])); return mir_base64_encode((PBYTE)buf, cbLen); }
char* TMD5Auth::getChallenge( const TCHAR* challenge ) { if ( iCallCount > 0 ) return NULL; iCallCount++; int resultLen; char* text = JabberBase64Decode( challenge, &resultLen ); JabberLog( "MD5 challenge = <%s>", text ); TStringPairs pairs( text ); const char *realm = pairs["realm"], *nonce = pairs["nonce"]; char randomNumber[40], cnonce[40], tmpBuf[40]; srand( time(0)); itoa( rand(), randomNumber, 10 ); DWORD digest[4], hash1[4], hash2[4]; mir_md5_state_t ctx; mir_md5_init( &ctx ); mir_md5_append( &ctx, ( BYTE* )randomNumber, strlen(randomNumber)); mir_md5_finish( &ctx, ( BYTE* )digest ); sprintf( cnonce, "%08x%08x%08x%08x", htonl(digest[0]), htonl(digest[1]), htonl(digest[2]), htonl(digest[3])); char *uname = mir_utf8encodeT( info->username ), *passw = mir_utf8encode( info->password ), *serv = mir_utf8encode( info->server ); mir_md5_init( &ctx ); mir_md5_append( &ctx, ( BYTE* )uname, strlen( uname )); mir_md5_append( &ctx, ( BYTE* )":", 1 ); mir_md5_append( &ctx, ( BYTE* )realm, strlen( realm )); mir_md5_append( &ctx, ( BYTE* )":", 1 ); mir_md5_append( &ctx, ( BYTE* )passw, strlen( passw )); mir_md5_finish( &ctx, ( BYTE* )hash1 ); mir_md5_init( &ctx ); mir_md5_append( &ctx, ( BYTE* )hash1, 16 ); mir_md5_append( &ctx, ( BYTE* )":", 1 ); mir_md5_append( &ctx, ( BYTE* )nonce, strlen( nonce )); mir_md5_append( &ctx, ( BYTE* )":", 1 ); mir_md5_append( &ctx, ( BYTE* )cnonce, strlen( cnonce )); mir_md5_finish( &ctx, ( BYTE* )hash1 ); mir_md5_init( &ctx ); mir_md5_append( &ctx, ( BYTE* )"AUTHENTICATE:xmpp/", 18 ); mir_md5_append( &ctx, ( BYTE* )serv, strlen( serv )); mir_md5_finish( &ctx, ( BYTE* )hash2 ); mir_md5_init( &ctx ); sprintf( tmpBuf, "%08x%08x%08x%08x", htonl(hash1[0]), htonl(hash1[1]), htonl(hash1[2]), htonl(hash1[3])); mir_md5_append( &ctx, ( BYTE* )tmpBuf, strlen( tmpBuf )); mir_md5_append( &ctx, ( BYTE* )":", 1 ); mir_md5_append( &ctx, ( BYTE* )nonce, strlen( nonce )); sprintf( tmpBuf, ":%08d:", iCallCount ); mir_md5_append( &ctx, ( BYTE* )tmpBuf, strlen( tmpBuf )); mir_md5_append( &ctx, ( BYTE* )cnonce, strlen( cnonce )); mir_md5_append( &ctx, ( BYTE* )":auth:", 6 ); sprintf( tmpBuf, "%08x%08x%08x%08x", htonl(hash2[0]), htonl(hash2[1]), htonl(hash2[2]), htonl(hash2[3])); mir_md5_append( &ctx, ( BYTE* )tmpBuf, strlen( tmpBuf )); mir_md5_finish( &ctx, ( BYTE* )digest ); char* buf = (char*)alloca(8000); int cbLen = mir_snprintf( buf, 8000, "username=\"%s\",realm=\"%s\",nonce=\"%s\",cnonce=\"%s\",nc=%08d," "qop=auth,digest-uri=\"xmpp/%s\",charset=utf-8,response=%08x%08x%08x%08x", uname, realm, nonce, cnonce, iCallCount, serv, htonl(digest[0]), htonl(digest[1]), htonl(digest[2]), htonl(digest[3])); mir_free( uname ); mir_free( passw ); mir_free( serv ); mir_free( text ); return JabberBase64Encode( buf, cbLen ); }