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 );
}