GitBucket
Newer
Ajax Dong
/** @file
AmiTpm20PlatformPei - TPM 2.0 Platform PEIM
Source: AmiModulePkg/TCG2/Common/AmiTcgPlatformPei/AmiTpm20PlatformPei.c
PurleyPlatPkg/BootGuard/BootGuardTCG2/BootGuardTCG2.c
Binary: AmiTpm20PlatformPei.efi (PE32+ IA32)
MD5: 25c2ce5883bbe0ec3af8f070073ce99d
SHA256: 60bd49067898d0f6639b2b05218a81ff22c875670fc5bf5189d724fdbd1cf39b
*/
// Module base: 0xffe21a14, Image size: 0xafc0
// 100 functions total, 5232 lines of decompiled code
// ============================================================================
// 0xffe21c74 RdRand16
// ============================================================================
int __cdecl RdRand16(_WORD *a1)
{
__asm { rdrand eax } /*0xffe21c74*/
if ( !_CF ) /*0xffe21c77*/
return 0; /*0xffe21c79*/
*a1 = _EAX; /*0xffe21c80*/
return 1; /*0xffe21c7b*/
}
// ============================================================================
// 0xffe21cc4 BaseCopyMem
// ============================================================================
char *__cdecl BaseCopyMem(char *dst, char *src, unsigned int count_1)
{
unsigned int count; // edx
char *dst_1; // edi
char *src_1; // esi
count = count_1; /*0xffe21cce*/
if ( src < dst && &src[count_1 - 1] >= dst ) /*0xffe21cdc*/
{
src_1 = &src[count_1 - 1]; /*0xffe21cf0*/
dst_1 = &dst[count_1 - 1]; /*0xffe21cf2*/
}
else
{
count = count_1 & 3; /*0xffe21ce0*/
qmemcpy(dst, src, 4 * (count_1 >> 2)); /*0xffe21ce9*/
src_1 = &src[4 * (count_1 >> 2)]; /*0xffe21ce9*/
dst_1 = &dst[4 * (count_1 >> 2)]; /*0xffe21ce9*/
}
qmemcpy(dst_1, src_1, count); /*0xffe21cf9*/
return dst; /*0xffe21d00*/
}
// ============================================================================
// 0xffe21d04 BaseSetMem8
// ============================================================================
void *__cdecl BaseSetMem8(void *buf, unsigned int count, char value)
{
memset(buf, value, count); /*0xffe21d11*/
return buf; /*0xffe21d17*/
}
// ============================================================================
// 0xffe21d44 BaseDivU64x32Remainder
// ============================================================================
int __cdecl BaseDivU64x32Remainder(int a1, int a2, int a3, int a4)
{
do /*0xffe21d5d*/
{
*(_DWORD *)(a1 + 8 * a2 - 8) = a3; /*0xffe21d55*/
*(_DWORD *)(a1 + 8 * a2-- - 4) = a4; /*0xffe21d59*/
}
while ( a2 ); /*0xffe21d5d*/
return a1; /*0xffe21d61*/
}
// ============================================================================
// 0xffe21d64 BaseSetMem32
// ============================================================================
void *__cdecl BaseSetMem32(void *buf, unsigned int count, int value)
{
memset32(buf, value, count); /*0xffe21d71*/
return buf; /*0xffe21d77*/
}
// ============================================================================
// 0xffe21e04 _ModuleEntryPoint
// ============================================================================
EFI_STATUS ModuleEntryPoint(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
int v2; // eax
if ( *(char *)(sub_FFE2A4DF() + 1024068) >= 0 ) /*0xffe21e15*/
{
sub_FFE2A4EB(); /*0xffe21e17*/
v2 = sub_FFE2A4DF(); /*0xffe21e1c*/
*(_BYTE *)(v2 + 1024068) |= 0x80u; /*0xffe21e28*/
}
return sub_FFE2361B(ImageHandle, SystemTable); /*0xffe21e2e*/
}
// ============================================================================
// 0xffe21e34 AmiTpm20GetPpiPointer
// ============================================================================
int __fastcall AmiTpm20GetPpiPointer(int a1, int a2, int a3)
{
int v5; // eax
_DWORD *v6; // ecx
int v7; // edi
int result; // eax
int v9; // [esp+10h] [ebp-8h] BYREF
int v10; // [esp+14h] [ebp-4h] BYREF
v9 = 0; /*0xffe21e36*/
if ( !a1 || !*(_DWORD *)a1 || !a2 ) /*0xffe21e56*/
return -2147483646; /*0xffe21ef1*/
v5 = (*(int (__cdecl **)(int, int, int *))(*(_DWORD *)a1 + 76))(a1, 22, &v9); /*0xffe21e64*/
v6 = (_DWORD *)v9; /*0xffe21e67*/
if ( !v9 || v5 < 0 ) /*0xffe21e74*/
return -2147483639; /*0xffe21eea*/
v7 = 0; /*0xffe21e7a*/
while ( 1 ) /*0xffe21e7c*/
{
v10 = a3; /*0xffe21e7c*/
*v6 = 22; /*0xffe21e80*/
*(_DWORD *)(v9 + 4) = 14; /*0xffe21e8f*/
*(_WORD *)(v9 + 8) = 1; /*0xffe21e9a*/
*(_DWORD *)(v9 + 10) = v7; /*0xffe21ea2*/
*(_DWORD *)(v9 + 14) = 4; /*0xffe21ea9*/
(*(void (__cdecl **)(int, int *, int))(*(_DWORD *)a1 + 80))(v9 + 18, &v10, 4); /*0xffe21ebf*/
result = (*(int (__cdecl **)(int, _DWORD, _DWORD, int *, _DWORD, int, _DWORD, int))(a2 + 8))( /*0xffe21ed4*/
a2,
0,
0,
&v10,
0,
4,
0,
v9);
if ( result < 0 ) /*0xffe21edc*/
break; /*0xffe21edc*/
if ( (unsigned int)++v7 >= 8 ) /*0xffe21ee2*/
break; /*0xffe21ee2*/
v6 = (_DWORD *)v9; /*0xffe21ee4*/
}
return result; /*0xffe21ef6*/
}
// ============================================================================
// 0xffe21efd AmiTpm20GetTrEEProtocol
// ============================================================================
int __fastcall AmiTpm20GetTrEEProtocol(int a1, int a2)
{
sub_FFE23839(a2, 150995008); /*0xffe21f08*/
sub_FFE2380A(a2 + 4, 0); /*0xffe21f12*/
*(_BYTE *)(a2 + 6) = 0; /*0xffe21f19*/
sub_FFE2380A(a2 + 7, 0); /*0xffe21f20*/
return 9; /*0xffe21f2a*/
}
// ============================================================================
// 0xffe21f2d AmiTpm20SubmitCommand
// ============================================================================
int __fastcall AmiTpm20SubmitCommand(int a1, unsigned int n1073741835)
{
unsigned int v4; // eax
_BYTE *v5; // edi
unsigned int v6; // edi
int v7; // eax
int v8; // esi
int v10; // eax
int v11; // eax
__int16 n640; // [esp+10h] [ebp-13Ch] BYREF
unsigned __int32 v13; // [esp+12h] [ebp-13Ah]
int n553713664; // [esp+16h] [ebp-136h]
int n201326656; // [esp+1Ah] [ebp-132h]
unsigned __int32 v16; // [esp+1Eh] [ebp-12Eh]
_BYTE v17[142]; // [esp+22h] [ebp-12Ah] BYREF
_BYTE v18[2]; // [esp+B0h] [ebp-9Ch] BYREF
unsigned int v19; // [esp+B2h] [ebp-9Ah]
unsigned int v20; // [esp+B6h] [ebp-96h]
n553713664 = 553713664; /*0xffe21f45*/
n640 = 640; /*0xffe21f52*/
n201326656 = 201326656; /*0xffe21f59*/
v4 = sub_FFE21EFD(a1, (int)v17); /*0xffe21f61*/
v5 = &v17[v4]; /*0xffe21f6a*/
v16 = _byteswap_ulong(v4); /*0xffe21f72*/
sub_FFE23839(&v17[v4], _byteswap_ulong(n1073741835)); /*0xffe21f78*/
v5 += 4; /*0xffe21f7d*/
*v5 = 0; /*0xffe21f89*/
v6 = v5 - (_BYTE *)&n640 + 1; /*0xffe21f8e*/
v13 = _byteswap_ulong(v6); /*0xffe21f93*/
v7 = (*(int (__cdecl **)(int, unsigned int, __int16 *, int, _BYTE *))(a1 + 12))(a1, v6, &n640, 147, v18); /*0xffe21fa7*/
v8 = v7; /*0xffe21faa*/
if ( v7 >= 0 )
{
v10 = (v19 & 0xFF00 | (v19 << 16)) << 8; /*0xffe21ff5*/
if ( (v10 | ((HIWORD(v19) | v19 & 0xFF0000) >> 8)) <= 0x93 )
{
v11 = (v20 & 0xFF00 | (v20 << 16)) << 8; /*0xffe22036*/
if ( v11 | ((HIWORD(v20) | v20 & 0xFF0000) >> 8) )
{
sub_FFE23AA9(
0x80000000,
"HierarchyControl: Response Code error! 0x%08x\r\n",
v11 | ((HIWORD(v20) | v20 & 0xFF0000) >> 8));
return -2147483641; /*0xffe22050*/
}
else
{
return 0; /*0xffe22057*/
}
}
else
{
sub_FFE23AA9(
0x80000000,
"HierarchyControl: Response size too large! %d\r\n",
v10 | ((HIWORD(v19) | v19 & 0xFF0000) >> 8));
return -2147483643; /*0xffe22011*/
}
}
else
{
sub_FFE23AA9(0x80000000, "Tpm2GetRandom TrEEProtocolInstance->SubmitCommand = %r \n", v7); /*0xffe21fbe*/
return v8; /*0xffe21fc6*/
}
}
// ============================================================================
// 0xffe22064 AmiTpm20CreateTpmHob
// ============================================================================
int __fastcall AmiTpm20CreateTpmHob(int this, _DWORD *a2, int n15, _DWORD *a4)
{
int v5; // eax
int v6; // esi
_DWORD *v8; // edi
v5 = (*(int (__cdecl **)(int, int, int, _DWORD *))(*(_DWORD *)this + 52))(this, 4, n15 + 24, a4); /*0xffe2207b*/
v6 = v5; /*0xffe2207e*/
if ( v5 >= 0 ) /*0xffe22085*/
{
sub_FFE23AA9(64, "Hob created \n"); /*0xffe220a2*/
v8 = (_DWORD *)(*a4 + 8); /*0xffe220ab*/
*v8++ = *a2; /*0xffe220b2*/
*v8++ = a2[1]; /*0xffe220b3*/
*v8 = a2[2]; /*0xffe220b4*/
v8[1] = a2[3]; /*0xffe220b5*/
return 0; /*0xffe220ae*/
}
else
{
sub_FFE23AA9(64, "Failed to create TCG/TPM Hob Status = %r \n", v5); /*0xffe2208f*/
return v6; /*0xffe22097*/
}
}
// ============================================================================
// 0xffe220ba MeasureLogDxeFwVol
// ============================================================================
int __fastcall MeasureLogDxeFwVol(
int this,
int *a2,
int a3,
int (__cdecl **a4)(int, int, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD *, _DWORD *))
{
int v5; // ebp
int v6; // eax
int *p_src; // edi
char n2; // cl
int v9; // ebx
int v10; // eax
int v11; // esi
int v12; // esi
char n2_1; // [esp+17h] [ebp-3EDh]
int v15; // [esp+18h] [ebp-3ECh]
_DWORD v17[4]; // [esp+20h] [ebp-3E4h] BYREF
_DWORD buf_1[24]; // [esp+30h] [ebp-3D4h] BYREF
_BYTE buf[112]; // [esp+90h] [ebp-374h] BYREF
_DWORD v20[3]; // [esp+100h] [ebp-304h] BYREF
__int16 n4; // [esp+10Ch] [ebp-2F8h]
char dst[328]; // [esp+10Eh] [ebp-2F6h] BYREF
int n16; // [esp+256h] [ebp-1AEh]
_DWORD v24[52]; // [esp+260h] [ebp-1A4h] BYREF
_DWORD v25[53]; // [esp+330h] [ebp-D4h] BYREF
v5 = 0; /*0xffe220d6*/
sub_FFE23AA9(64, "[%d] Enter MeasureLogDxeFwVol\n", 555); /*0xffe220d8*/
v6 = *a2; /*0xffe220dd*/
p_src = a2 + 3; /*0xffe220df*/
n2 = *((_BYTE *)a2 + 4); /*0xffe220e2*/
v20[0] = 0; /*0xffe220e7*/
v17[3] = 0; /*0xffe220ef*/
v9 = a2[2]; /*0xffe220f6*/
v15 = v6; /*0xffe220f9*/
v17[0] = a2[3]; /*0xffe220ff*/
v17[1] = a2[4]; /*0xffe22106*/
v10 = a2[5]; /*0xffe2210a*/
n2_1 = n2; /*0xffe2210d*/
v20[1] = 1; /*0xffe22111*/
n16 = 16; /*0xffe22118*/
v17[2] = v10; /*0xffe22123*/
if ( n2 == 1 ) /*0xffe22129*/
{
sub_FFE24D71(buf_1); /*0xffe2212f*/
}
else if ( n2 == 2 ) /*0xffe22139*/
{
if ( (v9 & 1) != 0 ) /*0xffe2213d*/
sub_FFE24D71(buf_1); /*0xffe22143*/
if ( (v9 & 2) != 0 ) /*0xffe2214b*/
sub_FFE27758(buf); /*0xffe22154*/
if ( (v9 & 4) != 0 ) /*0xffe2215c*/
sub_FFE279CA(v24); /*0xffe22165*/
if ( (v9 & 8) != 0 ) /*0xffe2216d*/
sub_FFE28807(v25); /*0xffe22176*/
if ( (v9 & 0x10) != 0 ) /*0xffe2217e*/
sub_FFE27758(buf); /*0xffe22187*/
}
v11 = v15; /*0xffe2218c*/
sub_FFE23AA9(64, "FwVolHobCount = %x \n", v15); /*0xffe22198*/
if ( v15 ) /*0xffe221a2*/
{
do /*0xffe2225f*/
{
sub_FFE23AA9(64, "TpmFwVolHob[i].Size = %x \n", p_src[2]); /*0xffe221b2*/
sub_FFE23AA9(64, "TpmFwVolHob[i].baseAddress = %lx \n", *p_src); /*0xffe221c6*/
if ( n2_1 == 1 ) /*0xffe221d4*/
{
sub_FFE24D9C((int)buf_1, (char *)*p_src, p_src[2]); /*0xffe221df*/
}
else if ( n2_1 == 2 ) /*0xffe221e8*/
{
if ( (v9 & 2) != 0 ) /*0xffe221ec*/
sub_FFE2779B((int)buf, (unsigned __int8 *)*p_src, p_src[2]); /*0xffe221fa*/
if ( (v9 & 1) != 0 ) /*0xffe22203*/
sub_FFE24D9C((int)buf_1, (char *)*p_src, p_src[2]); /*0xffe2220e*/
if ( (v9 & 4) != 0 ) /*0xffe22217*/
sub_FFE2888A((int)v24, (char *)*p_src, p_src[2]); /*0xffe22225*/
if ( (v9 & 8) != 0 ) /*0xffe2222e*/
sub_FFE2888A((int)v25, (char *)*p_src, p_src[2]); /*0xffe2223c*/
if ( (v9 & 0x10) != 0 ) /*0xffe22245*/
sub_FFE2779B((int)buf, (unsigned __int8 *)*p_src, p_src[2]); /*0xffe22253*/
}
p_src += 6; /*0xffe22259*/
--v11; /*0xffe2225c*/
}
while ( v11 ); /*0xffe2225f*/
}
if ( n2_1 == 1 ) /*0xffe2226b*/
{
sub_FFE24E32((int)src_1, buf_1); /*0xffe22278*/
sub_FFE238C8(dst, src_1, 0x14u); /*0xffe22288*/
n4 = 4; /*0xffe22291*/
}
else if ( n2_1 == 2 ) /*0xffe222a0*/
{
if ( (v9 & 1) != 0 ) /*0xffe222a9*/
{
sub_FFE24E32((int)src_2, buf_1); /*0xffe222b6*/
sub_FFE238C8(dst, src_2, 0x14u); /*0xffe222c6*/
n4 = 4; /*0xffe222d1*/
v5 = 1; /*0xffe222d9*/
}
if ( (v9 & 2) != 0 ) /*0xffe222dd*/
{
sub_FFE2783B(buf, src_3); /*0xffe222ed*/
sub_FFE238C8(&dst[66 * v5], src_3, 0x20u); /*0xffe22302*/
*(_WORD *)&dst[66 * v5++ - 2] = 11; /*0xffe2230b*/
}
if ( (v9 & 4) != 0 ) /*0xffe22317*/
{
sub_FFE27A4D((int)v24, dst); /*0xffe22327*/
sub_FFE238C8(&dst[66 * v5], dst, 0x30u); /*0xffe2233c*/
*(_WORD *)&dst[66 * v5++ - 2] = 12; /*0xffe22345*/
}
if ( (v9 & 8) != 0 ) /*0xffe22351*/
{
sub_FFE2892A((int)v25, src_4); /*0xffe22361*/
sub_FFE238C8(&dst[66 * v5], src_4, 0x40u); /*0xffe22376*/
*(_WORD *)&dst[66 * v5++ - 2] = 13; /*0xffe2237f*/
}
if ( (v9 & 0x10) != 0 ) /*0xffe2238b*/
{
sub_FFE2783B(buf, src_5); /*0xffe2239b*/
sub_FFE238C8(&dst[66 * v5], src_5, 0x20u); /*0xffe223b0*/
*(_WORD *)&dst[66 * v5++ - 2] = 18; /*0xffe223b9*/
}
v20[2] = v5; /*0xffe223c2*/
}
v12 = (*a4)(this, a3, 0, 0, 0, 0, v20, v17); /*0xffe223f0*/
sub_FFE23AA9(64, "MeasureLogDxeFwVol - %r\n", v12); /*0xffe223fa*/
return v12; /*0xffe22404*/
}
// ============================================================================
// 0xffe2240f Tpm2GetCapability
// ============================================================================
int __cdecl Tpm2GetCapability(int n267, int a2, _BYTE *a3, char *dst)
{
int v4; // ecx
int result; // eax
int v6; // edx
int v7; // eax
_WORD v8[3]; // [esp+0h] [ebp-424h] BYREF
int v9; // [esp+6h] [ebp-41Eh]
char v10; // [esp+Ah] [ebp-41Ah]
char src[1025]; // [esp+Bh] [ebp-419h] BYREF
__int16 n384; // [esp+40Ch] [ebp-18h] BYREF
int v13; // [esp+40Eh] [ebp-16h]
int n2046885888; // [esp+412h] [ebp-12h]
int v15; // [esp+416h] [ebp-Eh]
int v16; // [esp+41Ah] [ebp-Ah]
int v17; // [esp+41Eh] [ebp-6h]
if ( !v4 ) /*0xffe2241c*/
return -2147483646; /*0xffe2241e*/
n2046885888 = 2046885888; /*0xffe22430*/
n384 = 384; /*0xffe22438*/
v15 = sub_FFE237F1(6); /*0xffe22444*/
v16 = sub_FFE237F1(n267); /*0xffe2244e*/
v17 = sub_FFE237F1(1); /*0xffe2245a*/
v13 = sub_FFE237F1(22); /*0xffe22462*/
result = (*(int (__cdecl **)(int, int, __int16 *, int, _WORD *))(v6 + 12))(v6, 22, &n384, 1035, v8); /*0xffe22478*/
if ( result >= 0 )
{
if ( v8[0] == 384 )
{
v7 = sub_FFE237F1(v9); /*0xffe22498*/
if ( v7 )
{
sub_FFE23AA9(0x80000000, "Tpm2GetCapability: Response Code error! 0x%08x\r\n", v7);
return -2147483641; /*0xffe224b4*/
}
else
{
*a3 = v10; /*0xffe224cf*/
sub_FFE238C8(dst, src, 0x400u); /*0xffe224d4*/
return 0; /*0xffe224da*/
}
}
else
{
return -2147483623; /*0xffe2248b*/
}
}
return result; /*0xffe224dd*/
}
// ============================================================================
// 0xffe224e1 Tpm2GetFwVersion
// ============================================================================
int __fastcall Tpm2GetFwVersion(int a1, int *p_n458812, int *p_n1229346816)
{
int result; // eax
int v5; // eax
int v6; // ecx
int v7; // eax
char dst[12]; // [esp+10h] [ebp-40Ch] BYREF
int v9; // [esp+1Ch] [ebp-400h]
_BYTE v10[5]; // [esp+417h] [ebp-5h] BYREF
if ( !p_n458812 || !p_n1229346816 ) /*0xffe224fe*/
return -2147483646; /*0xffe22584*/
*p_n458812 = 0; /*0xffe22504*/
*p_n1229346816 = 0; /*0xffe2250d*/
result = sub_FFE2240F(267, a1, v10, dst); /*0xffe2251b*/
if ( result >= 0 ) /*0xffe22525*/
{
v5 = sub_FFE237F1(v9); /*0xffe2252d*/
*p_n458812 = v5; /*0xffe2253a*/
sub_FFE23AA9(64, "\n TpmFwVersion1 = %x \n", v5); /*0xffe2253c*/
result = sub_FFE2240F(268, v6, v10, dst); /*0xffe22557*/
if ( result >= 0 ) /*0xffe22561*/
{
v7 = sub_FFE237F1(v9); /*0xffe22569*/
*p_n1229346816 = v7; /*0xffe22576*/
sub_FFE23AA9(64, "\n TpmFwVersion2 = %x \n", v7); /*0xffe22578*/
return 0; /*0xffe22580*/
}
}
return result; /*0xffe22589*/
}
// ============================================================================
// 0xffe22590 Tpm2SelfTest
// ============================================================================
int __fastcall Tpm2SelfTest(int a1, _DWORD *a2, int *a3, int *a4)
{
int v7; // ebx
int n1229346816; // esi
int n1229346816_2; // eax
int n458812; // edx
int v11; // esi
int v12; // [esp-4h] [ebp-440h]
char v13; // [esp+17h] [ebp-425h] BYREF
int n1229346816_1; // [esp+18h] [ebp-424h] BYREF
__int16 n384; // [esp+1Ch] [ebp-420h] BYREF
int n184549376; // [esp+1Eh] [ebp-41Eh]
int n1124139008; // [esp+22h] [ebp-41Ah]
char v18; // [esp+26h] [ebp-416h]
int n458812_1; // [esp+28h] [ebp-414h] BYREF
_WORD v20[3]; // [esp+2Ch] [ebp-410h] BYREF
unsigned int v21; // [esp+32h] [ebp-40Ah]
n184549376 = 184549376; /*0xffe2259d*/
n384 = 384; /*0xffe225a6*/
n1124139008 = 1124139008; /*0xffe225b2*/
if ( sub_FFE224E1(a1, &n458812_1, &n1229346816_1) == -2147483623 ) /*0xffe225cc*/
return -2147483641; /*0xffe225ce*/
v7 = sub_FFE2240F(261, v12, &v13); /*0xffe225ed*/
if ( v7 >= 0 ) /*0xffe225f4*/
{
n1229346816 = sub_FFE237F1(); /*0xffe22605*/
sub_FFE23AA9(64, "\n ManufactureId = %x \n", n1229346816); /*0xffe2260f*/
v7 = 0; /*0xffe22617*/
}
else
{
n1229346816 = n1229346816_1; /*0xffe225f6*/
}
n1229346816_2 = n1229346816_1; /*0xffe22620*/
n458812 = n458812_1; /*0xffe22624*/
*a2 = n458812_1; /*0xffe22628*/
*a3 = n1229346816_2; /*0xffe2262b*/
*a4 = n1229346816; /*0xffe22634*/
if ( v7 >= 0 && n1229346816 == 1229346816 ) /*0xffe22640*/
{
if ( n458812 == 458812 || (v18 = 0, n458812 == 327740) ) /*0xffe22655*/
v18 = 1; /*0xffe22657*/
}
sub_FFE23937(v20, 10); /*0xffe22663*/
sub_FFE23AA9(64, "\nsending TPM20 SelfTest To Tpm \n"); /*0xffe22671*/
v11 = (*(int (__cdecl **)(int, int, __int16 *, int, _WORD *))(a1 + 12))(a1, 11, &n384, 10, v20); /*0xffe22688*/
if ( v11 >= 0 ) /*0xffe2268f*/
{
if ( v20[0] == 384 ) /*0xffe226a2*/
{
if ( v21 ) /*0xffe226b0*/
v11 = -2147483642; /*0xffe226b2*/
}
else
{
v11 = -2147483641; /*0xffe226a4*/
}
sub_FFE23AA9(64, "SelfTestReponse.Tag = %x \n", (v20[0] << 8) | HIBYTE(v20[0])); /*0xffe226cb*/
sub_FFE23AA9( /*0xffe22702*/
64,
"SelfTestReponse.ResponseCode = %x \n",
((v21 & 0xFF00 | (v21 << 16)) << 8) | ((HIWORD(v21) | v21 & 0xFF0000) >> 8));
sub_FFE23AA9(64, "SelfTestReponse.Status = %r \n", v11); /*0xffe22711*/
}
return v11; /*0xffe2271b*/
}
// ============================================================================
// 0xffe22726 Tpm2HierarchyChangeAuth
// ============================================================================
int __cdecl Tpm2HierarchyChangeAuth(int a1, char *p_n20)
{
int v2; // ecx
int v3; // ebx
unsigned int v4; // eax
_BYTE *v5; // esi
char *dst; // esi
unsigned int v7; // ecx
int result; // eax
int v9; // eax
int v10; // eax
__int16 n640; // [esp+10h] [ebp-174h] BYREF
unsigned __int32 v12; // [esp+12h] [ebp-172h]
int n687931392; // [esp+16h] [ebp-16Eh]
int n201326656; // [esp+1Ah] [ebp-16Ah]
unsigned __int32 v15; // [esp+1Eh] [ebp-166h]
_BYTE v16[206]; // [esp+22h] [ebp-162h] BYREF
_BYTE v17[2]; // [esp+F0h] [ebp-94h] BYREF
unsigned int v18; // [esp+F2h] [ebp-92h]
unsigned int v19; // [esp+F6h] [ebp-8Eh]
v12 = -587202560; /*0xffe22734*/
n640 = 640; /*0xffe22741*/
v3 = v2; /*0xffe22746*/
n687931392 = 687931392; /*0xffe22748*/
n201326656 = 201326656; /*0xffe22750*/
v4 = sub_FFE21EFD(v2, (int)v16); /*0xffe22758*/
v5 = &v16[v4]; /*0xffe22768*/
v15 = _byteswap_ulong(v4); /*0xffe2276e*/
sub_FFE2380A(&v16[v4], __ROL2__(*(_WORD *)p_n20, 8)); /*0xffe22779*/
dst = v5 + 2; /*0xffe22781*/
if ( *(_WORD *)p_n20 ) /*0xffe2277e*/
sub_FFE238C8(dst, p_n20 + 2, *(unsigned __int16 *)p_n20); /*0xffe2278e*/
v7 = (unsigned int)&dst[*(unsigned __int16 *)p_n20 - (_DWORD)&n640]; /*0xffe227a2*/
v12 = _byteswap_ulong(v7); /*0xffe227a8*/
result = (*(int (__cdecl **)(int, unsigned int, __int16 *, int, _BYTE *))(v3 + 12))(v3, v7, &n640, 147, v17); /*0xffe227bc*/
if ( result >= 0 )
{
sub_FFE23AA9(0x80000000, "HierarchyChangeAuth: Response code %x\r\n", v19);
v9 = (v18 & 0xFF00 | (v18 << 16)) << 8; /*0xffe2280c*/
if ( (v9 | ((HIWORD(v18) | v18 & 0xFF0000) >> 8)) <= 0x93 )
{
v10 = (v19 & 0xFF00 | (v19 << 16)) << 8; /*0xffe22849*/
if ( v10 | ((HIWORD(v19) | v19 & 0xFF0000) >> 8) )
{
sub_FFE23AA9(
0x80000000,
"HierarchyChangeAuth: Response Code error! 0x%08x\r\n",
v10 | ((HIWORD(v19) | v19 & 0xFF0000) >> 8));
return -2147483641; /*0xffe2285f*/
}
else
{
return 0; /*0xffe22866*/
}
}
else
{
sub_FFE23AA9(
0x80000000,
"HierarchyChangeAuth: Response size too large! %d\r\n",
v9 | ((HIWORD(v18) | v18 & 0xFF0000) >> 8));
return -2147483643; /*0xffe22824*/
}
}
return result; /*0xffe22868*/
}
// ============================================================================
// 0xffe22873 Tpm2GetRandom
// ============================================================================
int __usercall Tpm2GetRandom@<eax>(int a1@<edx>, unsigned int n0x40, _WORD *a3)
{
int v5; // ebx
unsigned int i; // esi
int v8; // eax
int v9; // eax
int v10; // edi
int v11; // eax
_BYTE v12[6]; // [esp+8h] [ebp-70h] BYREF
unsigned int v13; // [esp+Eh] [ebp-6Ah]
char v14[18]; // [esp+54h] [ebp-24h] BYREF
int n1229870147; // [esp+66h] [ebp-12h]
__int16 n384; // [esp+6Ch] [ebp-Ch] BYREF
int n201326592; // [esp+6Eh] [ebp-Ah]
int n2063663104; // [esp+72h] [ebp-6h]
__int16 v19; // [esp+76h] [ebp-2h]
if ( n0x40 > 0x40 ) /*0xffe22883*/
{
sub_FFE23AA9(0x80000000, "Tpm2GetRandom Error. Request too large\n"); /*0xffe2288f*/
return -2147483643; /*0xffe2289b*/
}
v14[0] = 22; /*0xffe228a4*/
v5 = (*(int (__cdecl **)(int, char *))a1)(a1, v14); /*0xffe228ac*/
if ( v5 < 0 ) /*0xffe228b2*/
{
sub_FFE23AA9(0x80000000, "TCG get Capability failed. Aborting. ..\n"); /*0xffe228be*/
return v5; /*0xffe228c7*/
}
sub_FFE23AA9(64, "ManufacturerID = %x\n", n1229870147); /*0xffe228d6*/
if ( n1229870147 == 1229870147 ) /*0xffe228e5*/
{
sub_FFE23AA9(0x80000000, "Matched. ..\n"); /*0xffe228f1*/
for ( i = n0x40 >> 1; i; --i ) /*0xffe228f6*/
{
if ( !a3 ) /*0xffe22901*/
{
v8 = sub_FFE23A81(); /*0xffe22903*/
if ( v8 ) /*0xffe2290a*/
(*(void (__cdecl **)(const char *, int, const char *))(v8 + 4))( /*0xffe22918*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\X86RdRand.c",
35,
"Rand != ((void *) 0)");
}
sub_FFE21C74(a3); /*0xffe2291f*/
a3 = (_WORD *)((char *)a3 + 1); /*0xffe22924*/
}
return 0; /*0xffe2292b*/
}
else
{
sub_FFE23937(&n384, 12); /*0xffe22938*/
sub_FFE23937(v12, 76); /*0xffe22943*/
n2063663104 = 2063663104; /*0xffe2294d*/
n384 = 384; /*0xffe22954*/
v19 = __ROL2__(n0x40, 8); /*0xffe2295f*/
n201326592 = 201326592; /*0xffe2296c*/
v9 = (*(int (__cdecl **)(int, int, __int16 *, int, _BYTE *))(a1 + 12))(a1, 12, &n384, 76, v12); /*0xffe22977*/
v10 = v9; /*0xffe2297a*/
if ( v9 >= 0 ) /*0xffe22981*/
{
v11 = (v13 & 0xFF00 | (v13 << 16)) << 8; /*0xffe229ba*/
if ( v11 | ((HIWORD(v13) | v13 & 0xFF0000) >> 8) ) /*0xffe229bd*/
{
sub_FFE23AA9( /*0xffe229cc*/
0x80000000,
"Tpm2GetRandom TrEEPeiPpi->SubmitCommand Response Code error! = %x \n",
v11 | ((HIWORD(v13) | v13 & 0xFF0000) >> 8));
return -2147483641; /*0xffe229d9*/
}
if ( n0x40 ) /*0xffe229dd*/
sub_FFE238C8(n0x40); /*0xffe229e6*/
}
else
{
sub_FFE23AA9(0x80000000, "Tpm2GetRandom TrEEPeiPpi->SubmitCommand = %r \n", v9); /*0xffe2298e*/
}
return v10; /*0xffe229ec*/
}
}
// ============================================================================
// 0xffe229f5 Tpm2SetPhRandomization
// ============================================================================
int __fastcall Tpm2SetPhRandomization(int a1, int a2)
{
int n20_1; // eax
int result; // eax
int v6; // ecx
int n20; // [esp-4h] [ebp-80h]
__int16 n20_2; // [esp+8h] [ebp-74h] BYREF
_WORD v9[33]; // [esp+Ah] [ebp-72h] BYREF
_BYTE v10[5]; // [esp+4Ch] [ebp-30h] BYREF
char n2; // [esp+51h] [ebp-2Bh]
_DWORD v12[4]; // [esp+68h] [ebp-14h] BYREF
int v13; // [esp+78h] [ebp-4h] BYREF
v12[0] = -1486139870; /*0xffe22a06*/
v12[1] = 1075688714; /*0xffe22a0f*/
v12[2] = 609301899; /*0xffe22a16*/
v12[3] = 71416496; /*0xffe22a1d*/
sub_FFE23AA9(64, "Setting PhRandomization\n"); /*0xffe22a24*/
n20_1 = n20; /*0xffe22a29*/
if ( n20 != -1 ) /*0xffe22a33*/
goto LABEL_11; /*0xffe22a33*/
result = (*(int (__cdecl **)(int, _DWORD *, _DWORD, _DWORD, int *))(*(_DWORD *)a1 + 32))(a1, v12, 0, 0, &v13); /*0xffe22a44*/
if ( result >= 0 ) /*0xffe22a4c*/
{
result = v13; /*0xffe22a4e*/
if ( v13 ) /*0xffe22a53*/
{
if ( (*(int (__cdecl **)(int, _BYTE *))(v13 + 4))(a1, v10) < 0 || n2 == 1 ) /*0xffe22a68*/
{
n20 = 20; /*0xffe22a6a*/
}
else
{
if ( n2 != 2 ) /*0xffe22a76*/
{
n20_1 = n20; /*0xffe22a7c*/
goto LABEL_11; /*0xffe22a7c*/
}
n20 = 32; /*0xffe22a78*/
}
n20_1 = n20; /*0xffe22a6c*/
n20 = n20; /*0xffe22a6d*/
LABEL_11:
sub_FFE23AA9(0x80000000, "HashPolicysize = %x \n", n20_1); /*0xffe22a81*/
n20_2 = n20; /*0xffe22a99*/
sub_FFE22873(a2, (unsigned __int16)n20, v9); /*0xffe22aa4*/
return sub_FFE22726(v6, &n20_2); /*0xffe22ab3*/
}
}
return result; /*0xffe22aba*/
}
// ============================================================================
// 0xffe22ac0 AmiTpm20PlatformPeiCheckError
// ============================================================================
int AmiTpm20PlatformPeiCheckError()
{
int v0; // eax
int v1; // esi
int v2; // eax
int v3; // eax
int v4; // eax
int n16; // [esp+10h] [ebp-2Ch] BYREF
int (__cdecl **v7)(_DWORD, const __int16 *, _DWORD *, _DWORD, int *, unsigned __int64 *); // [esp+14h] [ebp-28h] BYREF
unsigned __int64 v8; // [esp+18h] [ebp-24h] BYREF
__int16 n255; // [esp+20h] [ebp-1Ch]
_DWORD v10[5]; // [esp+28h] [ebp-14h] BYREF
n255 = 255; /*0xffe22ac9*/
v8 = 0; /*0xffe22ad4*/
v7 = 0; /*0xffe22ae3*/
v10[0] = 20351105; /*0xffe22ae7*/
v10[1] = 1260242093; /*0xffe22aef*/
v10[2] = 2060792246; /*0xffe22af7*/
v10[3] = 1809565838; /*0xffe22aff*/
n16 = 16; /*0xffe22b07*/
v0 = sub_FFE23A05(0, &v7); /*0xffe22b0f*/
v1 = v0; /*0xffe22b14*/
if ( v0 < 0 ) /*0xffe22b1f*/
{
sub_FFE23AA9(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v0); /*0xffe22b28*/
v2 = sub_FFE23A81(); /*0xffe22b30*/
if ( v2 ) /*0xffe22b37*/
(*(void (__cdecl **)(const char *, int, const char *))(v2 + 4))( /*0xffe22b48*/
"e:\\hs\\AmiModulePkg\\TCG2\\Common\\AmiTcgPlatformPei\\AmiTpm20PlatformPei.c",
1267,
"!EFI_ERROR (Status)");
}
sub_FFE23AA9(0x80000000, "VarSize = %x \n", n16); /*0xffe22b59*/
if ( v7 ) /*0xffe22b67*/
v1 = (*v7)(v7, L"AcpiResetVar", v10, 0, &n16, &v8); /*0xffe22b84*/
sub_FFE23AA9(0x80000000, "VarSize = %x \n", n16); /*0xffe22b8c*/
if ( v1 < 0 ) /*0xffe22b96*/
{
sub_FFE23AA9(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v1); /*0xffe22b9f*/
v3 = sub_FFE23A81(); /*0xffe22ba7*/
if ( v3 ) /*0xffe22bae*/
(*(void (__cdecl **)(const char *, int, const char *))(v3 + 4))( /*0xffe22bbf*/
"e:\\hs\\AmiModulePkg\\TCG2\\Common\\AmiTcgPlatformPei\\AmiTpm20PlatformPei.c",
1283,
"!EFI_ERROR (Status)");
}
sub_FFE23AA9(
0x80000000,
"Getting AcpiResetVar: Status=%r Addess=%lx AccessSize=%x Type=%x \n",
v1,
v8,
HIBYTE(n255),
(unsigned __int8)n255);
if ( HIBYTE(n255) == 2 && (unsigned __int8)n255 < 2u && v8 < 0xFFFFFFFF ) /*0xffe22c07*/
{
if ( (_BYTE)n255 == 1 ) /*0xffe22c0c*/
{
v4 = sub_FFE23A23(v8); /*0xffe22c10*/
sub_FFE23A4F(v8, v4 & 0xFFFFE3FF); /*0xffe22c20*/
}
else
{
*(_DWORD *)v8 &= 0xFFFFE3FF; /*0xffe22c27*/
}
}
else
{
sub_FFE23AA9(0x80000000, "Performing reset without clearing SLP_TYPx bits in PM1 Control Register! \n"); /*0xffe22c35*/
sub_FFE23AA9( /*0xffe22c40*/
0x80000000,
"After system will resets, it may still be on S3 resume path and can asserts or hang somewhere in memory initializa"
"tion or elsewhere! \n");
}
return v1; /*0xffe22c48*/
}
// ============================================================================
// 0xffe22c52 AmiTpm20HandleTpmResume
// ============================================================================
int __fastcall AmiTpm20HandleTpmResume(int *a1, int a2)
{
bool v4; // sf
int v5; // eax
int v6; // esi
int v7; // eax
_BYTE v9[4]; // [esp+14h] [ebp-8h] BYREF
int v10; // [esp+18h] [ebp-4h]
sub_FFE23AA9(64, "Handling TPM resume failure \n"); /*0xffe22c64*/
if ( sub_FFE21E34((int)a1, a2, 1) < 0 ) /*0xffe22c79*/
{
if ( sub_FFE22AC0() >= 0 ) /*0xffe22c8f*/
{
v4 = (int)sub_FFE23A05(0, v9) < 0; /*0xffe22caf*/
v5 = *a1; /*0xffe22cb1*/
if ( !v4 ) /*0xffe22cb4*/
{
(*(void (__cdecl **)(_DWORD, int, _DWORD, _DWORD))(v5 + 128))(0, -2147483622, 0, 0); /*0xffe22cbe*/
goto LABEL_9; /*0xffe22cbe*/
}
}
else
{
v4 = (int)sub_FFE23A05(0, v9) < 0; /*0xffe22c97*/
v5 = *a1; /*0xffe22c99*/
if ( !v4 ) /*0xffe22c9c*/
{
(*(void (__cdecl **)(int, int, _DWORD, _DWORD))(v5 + 128))(2, -2147483622, 0, 0); /*0xffe22ca7*/
LABEL_9:
v10 = 0; /*0xffe22cce*/
while ( 1 ) /*0xffe22cd2*/
; /*0xffe22cd2*/
}
}
(*(void (__cdecl **)(int *))(v5 + 92))(a1); /*0xffe22cca*/
goto LABEL_9; /*0xffe22cca*/
}
v6 = -2147483646; /*0xffe22cd8*/
if ( !a2 ) /*0xffe22ce2*/
{
v7 = -2147483646; /*0xffe22ce4*/
LABEL_14:
sub_FFE23AA9(0x80000000, "Tcg2 Boot in recovery Disable EH Status =%r \n", v7); /*0xffe22cf8*/
goto LABEL_15; /*0xffe22cff*/
}
v7 = sub_FFE21F2D(a2, 0x4000000Bu); /*0xffe22cef*/
if ( v7 < 0 ) /*0xffe22cf6*/
goto LABEL_14; /*0xffe22cf6*/
LABEL_15:
if ( !a2 || (v6 = sub_FFE21F2D(a2, 0x40000001u), v6 < 0) ) /*0xffe22d1b*/
sub_FFE23AA9(0x80000000, "Tcg2 Boot in recovery Disable SH Status =%r \n", v6); /*0xffe22d24*/
sub_FFE229F5((int)a1, a2); /*0xffe22d30*/
return v6; /*0xffe22d35*/
}
// ============================================================================
// 0xffe22d3f Tpm2Startup
// ============================================================================
int __fastcall Tpm2Startup(int *a1, int a2, int n17)
{
int result; // eax
int v6; // esi
__int16 n256; // ax
unsigned int n256_2; // ecx
int v9; // eax
int v10; // eax
int v11; // eax
int v12; // edi
char v13; // al
bool v14; // zf
char v15; // [esp+17h] [ebp-61h]
int v16; // [esp+18h] [ebp-60h] BYREF
int v17; // [esp+1Ch] [ebp-5Ch] BYREF
int v18; // [esp+20h] [ebp-58h] BYREF
int v19; // [esp+24h] [ebp-54h] BYREF
int v20; // [esp+28h] [ebp-50h] BYREF
_BYTE v21[4]; // [esp+2Ch] [ebp-4Ch] BYREF
_BYTE v22[4]; // [esp+30h] [ebp-48h] BYREF
unsigned __int16 v23; // [esp+34h] [ebp-44h] BYREF
int v24; // [esp+36h] [ebp-42h]
unsigned int v25; // [esp+3Ah] [ebp-3Eh]
__int16 n384; // [esp+40h] [ebp-38h] BYREF
int n201326592; // [esp+42h] [ebp-36h]
int n1140916224; // [esp+46h] [ebp-32h]
__int16 n256_1; // [esp+4Ah] [ebp-2Eh]
_DWORD v30[4]; // [esp+4Ch] [ebp-2Ch] BYREF
_BYTE v31[28]; // [esp+5Ch] [ebp-1Ch] BYREF
v30[0] = -1486139870; /*0xffe22d48*/
v30[1] = 1075688714; /*0xffe22d52*/
v15 = 0; /*0xffe22d61*/
v30[2] = 609301899; /*0xffe22d65*/
v30[3] = 71416496; /*0xffe22d6d*/
v16 = 0; /*0xffe22d75*/
v17 = 0; /*0xffe22d79*/
v18 = 0; /*0xffe22d7d*/
if ( n17 == 17 /*0xffe22d9a*/
&& (*(int (__cdecl **)(int *, void *, _DWORD, _DWORD, _BYTE *))(*a1 + 32))(a1, &unk_FFE2C544, 0, 0, v21) >= 0 )
{
return sub_FFE22C52(a1, a2); /*0xffe22da5*/
}
if ( (*(int (__cdecl **)(int *, void *, _DWORD, _DWORD, _BYTE *))(*a1 + 32))(a1, &unk_FFE2C5B4, 0, 0, v22) >= 0 ) /*0xffe22dc3*/
v15 = 1; /*0xffe22dc5*/
result = (*(int (__cdecl **)(int *, _DWORD *, _DWORD, _DWORD, int *))(*a1 + 32))(a1, v30, 0, 0, &v20); /*0xffe22ddb*/
if ( result >= 0 && v20 )
{
v6 = (*(int (__cdecl **)(int *, _BYTE *))(v20 + 4))(a1, v31); /*0xffe22dfe*/
if ( v6 >= 0 )
{
if ( !a2 ) /*0xffe22e0c*/
return -2147483646; /*0xffe22e13*/
n201326592 = 201326592; /*0xffe22e1d*/
n384 = 384; /*0xffe22e25*/
n256 = 256; /*0xffe22e2a*/
n1140916224 = 1140916224; /*0xffe22e32*/
if ( n17 != 17 ) /*0xffe22e3a*/
n256 = 0; /*0xffe22e3c*/
n256_1 = n256; /*0xffe22e45*/
sub_FFE23937(&v23, 10); /*0xffe22e4a*/
if ( v15 )
{
LABEL_19:
if ( n17 == 17 && v31[18] == 1 )
{
if ( v25 ) /*0xffe22f17*/
{
n256_1 = 0; /*0xffe22f1f*/
v6 = (*(int (__cdecl **)(int, int, __int16 *, int, unsigned __int16 *))(a2 + 12))(a2, 12, &n384, 10, &v23); /*0xffe22f36*/
if ( v6 >= 0 ) /*0xffe22f3d*/
{
if ( v25 ) /*0xffe22f49*/
{
sub_FFE23AA9( /*0xffe22f76*/
64,
"StartupReponse.ResponseCode = %x \n",
((v25 & 0xFF00 | (v25 << 16)) << 8) | ((HIWORD(v25) | v25 & 0xFF0000) >> 8));
sub_FFE23AA9(64, "StartupReponse.Status = %r \n", v6); /*0xffe22f85*/
sub_FFE28C1B(-2147483646, 50563586); /*0xffe22f97*/
return -2147483641; /*0xffe22fa1*/
}
return sub_FFE22C52(a1, a2); /*0xffe22faf*/
}
}
}
else
{
if ( v6 >= 0 )
{
v9 = sub_FFE22590(a2, &v16, &v17, &v18); /*0xffe22fca*/
v6 = v9 != -2147483642 ? v9 : 0;
if ( v6 >= 0 ) /*0xffe22fdf*/
sub_FFE28C1B(1, 50563589); /*0xffe22fe9*/
}
v10 = sub_FFE22064((int)a1, dword_FFE2C594, 15, &v19); /*0xffe22ffc*/
if ( v10 < 0 ) /*0xffe23005*/
{
sub_FFE23AA9(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v10); /*0xffe23012*/
v11 = sub_FFE23A81(); /*0xffe2301a*/
if ( v11 ) /*0xffe23021*/
(*(void (__cdecl **)(const char *, int, const char *))(v11 + 4))( /*0xffe23032*/
"e:\\hs\\AmiModulePkg\\TCG2\\Common\\AmiTcgPlatformPei\\AmiTpm20PlatformPei.c",
1593,
"!EFI_ERROR (Status2)");
}
v12 = v19 + 24; /*0xffe23048*/
if ( v6 < 0 ) /*0xffe2303e*/
{
*(_BYTE *)(v19 + 24) = 0; /*0xffe2307a*/
*(_BYTE *)(v12 + 1) = v31[22]; /*0xffe23081*/
}
else
{
*(_BYTE *)(v19 + 24) = 1; /*0xffe2304b*/
*(_BYTE *)(v12 + 1) = (unsigned __int8)sub_FFE28A68() == 0; /*0xffe23059*/
*(_DWORD *)(v12 + 3) = v16; /*0xffe23060*/
*(_DWORD *)(v12 + 11) = v17; /*0xffe23067*/
*(_DWORD *)(v12 + 7) = v18; /*0xffe2306e*/
}
v13 = sub_FFE230D5(a1); /*0xffe23086*/
v14 = *(_BYTE *)v12 == 0; /*0xffe2308b*/
*(_BYTE *)(v12 + 2) = v13; /*0xffe2308e*/
if ( !v14 ) /*0xffe23091*/
{
sub_FFE23AA9(64, "StartupReponse.Tag = %x \n", v23); /*0xffe2309f*/
sub_FFE23AA9(64, "StartupReponse.Size = %x \n", v24); /*0xffe230b1*/
sub_FFE23AA9(64, "StartupReponse.ResponseCode = %x \n", v25); /*0xffe230c3*/
}
}
return v6; /*0xffe22fb1*/
}
sub_FFE23AA9(64, "sending TPM20 b4 TCGPassThroughToTpm \n"); /*0xffe22e63*/
v6 = (*(int (__cdecl **)(int, int, __int16 *, int, unsigned __int16 *))(a2 + 12))(a2, 12, &n384, 10, &v23); /*0xffe22e7a*/
if ( v6 >= 0 ) /*0xffe22e81*/
{
if ( !v25 /*0xffe22eb9*/
|| (n256_2 = ((v25 & 0xFF00 | (v25 << 16)) << 8) | ((HIWORD(v25) | v25 & 0xFF0000) >> 8), n256_2 == 256) )
{
sub_FFE28C1B(1, 50563586); /*0xffe22ef7*/
}
else
{
sub_FFE23AA9(64, "StartupReponse.ResponseCode = %x \n", n256_2); /*0xffe22ec2*/
sub_FFE23AA9(64, "StartupReponse.Status = %r \n", v6); /*0xffe22ed1*/
sub_FFE28C1B(-2147483646, 50563586); /*0xffe22ee3*/
v6 = -2147483641; /*0xffe22ee8*/
}
goto LABEL_19; /*0xffe22eed*/
}
}
return v6; /*0xffe230cb*/
}
return result; /*0xffe230cd*/
}
// ============================================================================
// 0xffe230d5 AmiTpm20IsFirstBoot
// ============================================================================
char __thiscall AmiTpm20IsFirstBoot(int *this)
{
int v1; // eax
int v2; // eax
_BYTE MonotonicCounter[32]; // [esp+8h] [ebp-40h] BYREF
__int16 v5; // [esp+28h] [ebp-20h]
_DWORD v6[4]; // [esp+2Ch] [ebp-1Ch] BYREF
_BYTE v7[4]; // [esp+3Ch] [ebp-Ch] BYREF
int n4; // [esp+40h] [ebp-8h] BYREF
int (__cdecl **v9)(_DWORD, _BYTE *, _DWORD *, _DWORD, int *, _BYTE *); // [esp+44h] [ebp-4h] BYREF
n4 = 4; /*0xffe230e1*/
qmemcpy(MonotonicCounter, L"MonotonicCounter", sizeof(MonotonicCounter)); /*0xffe230f1*/
v1 = *this; /*0xffe230f3*/
v5 = aMonotoniccount[16]; /*0xffe230f9*/
v6[0] = unk_FFE2A72C; /*0xffe23103*/
v6[1] = unk_FFE2A730; /*0xffe23104*/
v6[2] = unk_FFE2A734; /*0xffe23105*/
v6[3] = unk_FFE2A738; /*0xffe23106*/
v2 = (*(int (__cdecl **)(int *, void *, _DWORD, _DWORD, int (__cdecl ***)(_DWORD, _BYTE *, _DWORD *, _DWORD, int *, _BYTE *)))(v1 + 32))( /*0xffe23111*/
this,
&this_,
0,
0,
&v9);
if ( v2 >= 0 && v9 ) /*0xffe23120*/
{
if ( (*v9)(v9, MonotonicCounter, v6, 0, &n4, v7) >= 0 ) /*0xffe2313b*/
{
sub_FFE23AA9(64, "TPM20::Not First boot Scenario\n"); /*0xffe23154*/
LOBYTE(v2) = -1; /*0xffe23159*/
}
else
{
sub_FFE23AA9(64, "TPM20::First boot Scenario determined \n"); /*0xffe23144*/
LOBYTE(v2) = 1; /*0xffe23149*/
}
}
return v2; /*0xffe2315d*/
}
// ============================================================================
// 0xffe23163 MeasureTcgPcClientSpecId
// ============================================================================
int __thiscall MeasureTcgPcClientSpecId(void *this)
{
int v2; // edi
int v3; // eax
int v4; // eax
int result; // eax
char v6; // bl
int v7; // esi
int v8; // eax
int v9; // [esp+10h] [ebp-4Ch] BYREF
int v10; // [esp+14h] [ebp-48h] BYREF
int v11; // [esp+18h] [ebp-44h] BYREF
_DWORD v12[3]; // [esp+1Ch] [ebp-40h] BYREF
__int16 v13; // [esp+28h] [ebp-34h]
char n65; // [esp+2Ah] [ebp-32h]
char n4; // [esp+2Bh] [ebp-31h]
char Spec_ID_Event03[16]; // [esp+2Ch] [ebp-30h] BYREF
_BYTE v17[32]; // [esp+3Ch] [ebp-20h] BYREF
v12[0] = -1486139870; /*0xffe2316f*/
v12[1] = 1075688714; /*0xffe2317b*/
strcpy(Spec_ID_Event03, "Spec ID Event03"); /*0xffe23186*/
v10 = 0; /*0xffe23192*/
v12[2] = 609301899; /*0xffe23197*/
v13 = -17744; /*0xffe2319f*/
n65 = 65; /*0xffe231a6*/
n4 = 4; /*0xffe231ac*/
v2 = 0; /*0xffe231b3*/
sub_FFE23AA9(64, "TCG Pei: MeasureTCGPcClientSpecID\n");
v3 = (*(int (__cdecl **)(void *, void *, _DWORD, _DWORD, int *))(*(_DWORD *)this + 32))( /*0xffe231ca*/
this,
&unk_FFE2C564,
0,
0,
&v10);
if ( !v10 ) /*0xffe231d4*/
return -2147483634; /*0xffe231d4*/
if ( v3 < 0 ) /*0xffe231dc*/
return -2147483634; /*0xffe231dc*/
v4 = (*(int (__cdecl **)(void *, _DWORD *, _DWORD, _DWORD, int *))(*(_DWORD *)this + 32))(this, v12, 0, 0, &v11); /*0xffe231f2*/
if ( !v11 || v4 < 0 ) /*0xffe23206*/
return -2147483634; /*0xffe23385*/
result = (*(int (__cdecl **)(void *, _BYTE *))(v11 + 4))(this, v17); /*0xffe23212*/
if ( result >= 0 )
{
v6 = v17[23]; /*0xffe2321f*/
sub_FFE23AA9(64, "TCG Pei: TCG_PcClientSpecID\n");
result = (*(int (__cdecl **)(void *, int, int *))(*(_DWORD *)this + 76))(this, 67, &v9); /*0xffe23239*/
if ( result >= 0 ) /*0xffe23241*/
{
v7 = v9; /*0xffe23247*/
sub_FFE23937(v9, 67); /*0xffe23250*/
*(_DWORD *)(v9 + 10) = 0; /*0xffe2325c*/
*(_DWORD *)(v9 + 14) = 3; /*0xffe23263*/
*(_DWORD *)(v9 + 4) = 14; /*0xffe2326e*/
*(_WORD *)(v9 + 8) = 1; /*0xffe23279*/
sub_FFE23AA9(64, "TrEEEventData->Size = %x \n", *(_DWORD *)v9); /*0xffe2328c*/
sub_FFE23AA9(64, "TPML_DIGEST_VALUES Size = %x \n", 334); /*0xffe2329c*/
v8 = sub_FFE23796(Spec_ID_Event03); /*0xffe232a8*/
if ( v8 ) /*0xffe232af*/
sub_FFE238C8(v8); /*0xffe232b9*/
*(_DWORD *)(v7 + 38) = 33554944; /*0xffe232c1*/
*(_DWORD *)(v7 + 34) = 0; /*0xffe232c8*/
if ( v17[5] == 2 ) /*0xffe232d0*/
{
if ( (v6 & 1) != 0 ) /*0xffe232d5*/
{
*(_WORD *)(v7 + 46) = 4; /*0xffe232dc*/
*(_WORD *)(v7 + 48) = 20; /*0xffe232e3*/
v2 = 1; /*0xffe232e7*/
}
if ( (v6 & 2) != 0 ) /*0xffe232ee*/
{
*(_WORD *)(v7 + 4 * v2 + 46) = 11; /*0xffe232f3*/
*(_WORD *)(v7 + 4 * v2++ + 48) = 32; /*0xffe232f8*/
}
if ( (v6 & 4) != 0 ) /*0xffe23301*/
{
*(_WORD *)(v7 + 4 * v2 + 46) = 12; /*0xffe23306*/
*(_WORD *)(v7 + 4 * v2++ + 48) = 48; /*0xffe2330e*/
}
if ( (v6 & 8) != 0 ) /*0xffe23317*/
{
*(_WORD *)(v7 + 4 * v2 + 46) = 13; /*0xffe2331c*/
*(_WORD *)(v7 + 4 * v2++ + 48) = 64; /*0xffe23321*/
}
if ( (v6 & 0x10) != 0 ) /*0xffe2332a*/
{
*(_WORD *)(v7 + 4 * v2 + 46) = 18; /*0xffe2332f*/
*(_WORD *)(v7 + 4 * v2++ + 48) = 32; /*0xffe23334*/
}
*(_DWORD *)(v7 + 42) = v2; /*0xffe2333a*/
}
else
{
*(_WORD *)(v7 + 46) = 4; /*0xffe23342*/
*(_WORD *)(v7 + 48) = 20; /*0xffe23349*/
*(_DWORD *)(v7 + 42) = 1; /*0xffe2334d*/
}
*(_DWORD *)v9 = 4 * *(_DWORD *)(v7 + 42) + 47; /*0xffe23362*/
*(_BYTE *)(v7 + 4 * *(_DWORD *)(v7 + 42) + 46) = 0; /*0xffe23367*/
return (*(int (__cdecl **)(int, _DWORD, _DWORD, int, _DWORD, _DWORD, _DWORD, int))(v10 + 8))( /*0xffe2337d*/
v10,
0,
0,
v7 + 67,
0,
0,
0,
v9);
}
}
return result; /*0xffe2338a*/
}
// ============================================================================
// 0xffe23392 AmiTpm20GetTpmFwVolHobFromGuid
// ============================================================================
int __fastcall AmiTpm20GetTpmFwVolHobFromGuid(int a1, _DWORD *a2, int a3)
{
int v6; // eax
if ( !a1 ) /*0xffe2339a*/
return -2147483646; /*0xffe2339c*/
if ( a3 ) /*0xffe233a9*/
v6 = sub_FFE28BDA(); /*0xffe233bd*/
else
v6 = sub_FFE28BB7(); /*0xffe233ab*/
*(_DWORD *)a1 = v6; /*0xffe233b0*/
if ( !v6 ) /*0xffe233b4*/
return -2147483634; /*0xffe233b6*/
*a2 = *(_DWORD *)(*(_DWORD *)a1 + 28); /*0xffe233c9*/
return 0; /*0xffe233cd*/
}
// ============================================================================
// 0xffe233d0 AmiTpm20InstallTpmFwVolHobs
// ============================================================================
int __thiscall AmiTpm20InstallTpmFwVolHobs(_DWORD *this)
{
int this_1; // edi
int v2; // eax
unsigned int v3; // ebx
int v4; // eax
_DWORD *v5; // esi
_DWORD *v6; // ebp
int v7; // ecx
int v8; // eax
int result; // eax
int v10; // eax
int v11; // ebp
unsigned int *v12; // esi
unsigned int v13; // ebp
unsigned int v14; // edi
unsigned int v15; // eax
int v16; // [esp-8h] [ebp-14Ch]
unsigned int v17; // [esp+10h] [ebp-134h] BYREF
_DWORD *v18; // [esp+14h] [ebp-130h] BYREF
int (__cdecl **v19)(int, int, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD *, _DWORD *); // [esp+18h] [ebp-12Ch] BYREF
int v20; // [esp+1Ch] [ebp-128h] BYREF
int v21; // [esp+20h] [ebp-124h] BYREF
int v22; // [esp+24h] [ebp-120h] BYREF
_DWORD *this_2; // [esp+28h] [ebp-11Ch]
int v24; // [esp+2Ch] [ebp-118h]
int v25; // [esp+30h] [ebp-114h]
_BYTE v26[23]; // [esp+34h] [ebp-110h] BYREF
unsigned int v27; // [esp+4Bh] [ebp-F9h]
int v28; // [esp+5Ch] [ebp-E8h]
unsigned int v29; // [esp+60h] [ebp-E4h]
_DWORD v30[56]; // [esp+64h] [ebp-E0h] BYREF
this_1 = (int)this; /*0xffe233da*/
this_2 = this; /*0xffe233e2*/
v2 = *this; /*0xffe233e8*/
v3 = 0; /*0xffe233ea*/
v20 = 0; /*0xffe233f3*/
v19 = 0; /*0xffe233f7*/
if ( (*(int (__cdecl **)(_DWORD *, void *, _DWORD, _DWORD, int *))(v2 + 32))(this, &unk_FFE2C564, 0, 0, &v20) < 0 /*0xffe23420*/
|| (*(int (__cdecl **)(int, void *, _DWORD, _DWORD, int (__cdecl ***)(int, int, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD *, _DWORD *)))(*(_DWORD *)this_1 + 32))(
this_1,
&unk_FFE2C584,
0,
0,
&v19) < 0 )
{
return -2147483634; /*0xffe23420*/
}
v4 = sub_FFE28BB7(); /*0xffe23426*/
v5 = (_DWORD *)v4; /*0xffe2342b*/
v18 = (_DWORD *)v4; /*0xffe2342d*/
if ( v4 ) /*0xffe23433*/
{
v6 = v30; /*0xffe23438*/
v17 = *(_DWORD *)(v4 + 28); /*0xffe2343c*/
do /*0xffe234a9*/
{
if ( (v5[9] & 0x8200) == 0x8200 || (v5[9] & 0xA) != 0 && (v5[9] & 0x400) == 0 ) /*0xffe2345c*/
{
v8 = v5[7]; /*0xffe23464*/
v7 = v5[5]; /*0xffe2345e*/
v16 = v5[4]; /*0xffe23468*/
*(v6 - 2) = v16; /*0xffe23470*/
*(v6 - 1) = v7; /*0xffe23473*/
*v6 = v8; /*0xffe23476*/
sub_FFE23AA9(64, "RomArea->Address = %x \n", v16); /*0xffe23479*/
sub_FFE23AA9(64, "RomArea->Size = %x \n", v5[7]); /*0xffe23488*/
++v3; /*0xffe23490*/
v6 += 6; /*0xffe23491*/
}
sub_FFE23392((int)&v18, &v17, (int)v5); /*0xffe2349d*/
v5 = v18; /*0xffe234a2*/
}
while ( v18 ); /*0xffe234a9*/
}
else
{
v28 = -15663104; /*0xffe234b1*/
v29 = 0; /*0xffe234b9*/
v3 = 1; /*0xffe234bd*/
v30[0] = 11137024; /*0xffe234be*/
}
v25 = 24 * v3; /*0xffe234d6*/
result = sub_FFE22064(this_1, dword_FFE2C574, 24 * v3, &v22); /*0xffe234da*/
if ( result >= 0 ) /*0xffe234e3*/
{
v10 = (*(int (__cdecl **)(int, void *, _DWORD, _DWORD, int *))(*(_DWORD *)this_1 + 32))( /*0xffe234f8*/
this_1,
&unk_FFE2C4F4,
0,
0,
&v21);
if ( v21 && v10 >= 0 ) /*0xffe2350c*/
{
v11 = (*(int (__cdecl **)(int, _BYTE *))(v21 + 4))(this_1, v26); /*0xffe2351b*/
v24 = v11; /*0xffe2351d*/
if ( v11 >= 0 ) /*0xffe23525*/
{
v17 = 0; /*0xffe23532*/
v12 = (unsigned int *)(v22 + 24); /*0xffe23537*/
if ( v3 ) /*0xffe2353c*/
{
v13 = v17; /*0xffe23542*/
v14 = v30[0]; /*0xffe23546*/
do /*0xffe235e1*/
{
if ( v13 ) /*0xffe2354c*/
{
*v12 = 0; /*0xffe23572*/
v12[1] = 0; /*0xffe23575*/
v12[2] = 0; /*0xffe2357c*/
v12[5] = v30[6 * v13]; /*0xffe23584*/
v12[3] = *(&v28 + 6 * v13); /*0xffe2358b*/
v12[4] = v30[6 * v13 - 1]; /*0xffe23592*/
}
else
{
v12[3] = v28; /*0xffe23552*/
v15 = v29; /*0xffe23555*/
v12[5] = v14; /*0xffe23559*/
v12[4] = v15; /*0xffe2355c*/
*v12 = v3; /*0xffe2355f*/
v12[1] = v26[5]; /*0xffe23566*/
v12[2] = v27; /*0xffe2356d*/
}
sub_FFE23AA9(64, "TpmFwVolHob->Size = %x \n", v12[5]); /*0xffe2359f*/
sub_FFE23AA9(64, "TpmFwVolHob->baseAddress = %x \n", v12[3]); /*0xffe235b4*/
sub_FFE23AA9(64, "TpmFwVolHob->Tcg2SpecVersion = %x \n", v12[1]); /*0xffe235c3*/
sub_FFE23AA9(64, "TpmFwVolHob address = %x \n", v12); /*0xffe235d3*/
v12 += 6; /*0xffe235db*/
++v13; /*0xffe235de*/
}
while ( v13 < v3 ); /*0xffe235e1*/
this_1 = (int)this_2; /*0xffe235e7*/
v11 = v24; /*0xffe235eb*/
}
sub_FFE220BA(this_1, (int *)&v12[v25 / 0xFFFFFFFC], v20, v19); /*0xffe235ff*/
}
return v11; /*0xffe23529*/
}
return -2147483634; /*0xffe2360b*/
}
return result; /*0xffe23610*/
}
// ============================================================================
// 0xffe2361b AmiTpm20PlatformPeiEntry
// ============================================================================
int __fastcall AmiTpm20PlatformPeiEntry(int a1, int *a2)
{
int v3; // eax
int result; // eax
int v5; // eax
int v6; // eax
int v7; // edi
int v8; // eax
int v9; // eax
int v10; // [esp+8h] [ebp-28h] BYREF
int n17; // [esp+Ch] [ebp-24h] BYREF
int v12; // [esp+10h] [ebp-20h] BYREF
_BYTE v13[28]; // [esp+14h] [ebp-1Ch] BYREF
v3 = *a2; /*0xffe23630*/
v10 = 0; /*0xffe23639*/
result = (*(int (__cdecl **)(int *, void *, _DWORD, _DWORD, int *))(v3 + 32))(a2, &unk_FFE2C564, 0, 0, &v10); /*0xffe2363d*/
if ( result >= 0 && v10 )
{
v5 = (*(int (__cdecl **)(int *, void *, _DWORD, _DWORD, int *))(*a2 + 32))(a2, &unk_FFE2C4F4, 0, 0, &v12); /*0xffe23664*/
if ( !v12 || v5 < 0 ) /*0xffe23678*/
return -2147483634; /*0xffe2378b*/
result = (*(int (__cdecl **)(int *, _BYTE *))(v12 + 4))(a2, v13); /*0xffe23684*/
if ( result >= 0 )
{
result = (*(int (__cdecl **)(int *, int *))(*a2 + 40))(a2, &n17); /*0xffe23699*/
if ( result >= 0 )
{
if ( (int)sub_FFE22D3F(n17) < 0 || n17 == 17 ) /*0xffe236c6*/
return 0; /*0xffe236bc*/
if ( n17 != 32 ) /*0xffe236cd*/
goto LABEL_18; /*0xffe236cd*/
v6 = sub_FFE21E34(0); /*0xffe236d6*/
sub_FFE23AA9(64, "Tcg2 Boot in recovery CapPcrs Status =%r \n", v6); /*0xffe236e4*/
v7 = -2147483646; /*0xffe236f0*/
if ( v10 )
{
v8 = sub_FFE21F2D(v10, 1073741835); /*0xffe23702*/
if ( v8 >= 0 )
{
LABEL_15:
if ( !v10 || (v7 = sub_FFE21F2D(v10, 1073741825), v7 < 0) ) /*0xffe23731*/
sub_FFE23AA9(64, "Tcg2 Boot in recovery Disable SH Status =%r \n", v7); /*0xffe2373b*/
LABEL_18:
if ( v13[5] == 2 )
{
v9 = sub_FFE23163(a2); /*0xffe2374c*/
if ( v9 < 0 )
sub_FFE23AA9(0x80000000, "Error: Failure %d %a Status = %r\n", 2394, "AmiTpm20PlatformPeiEntry", v9);
}
result = sub_FFE29FCD(a2); /*0xffe23777*/
if ( result >= 0 ) /*0xffe23780*/
return sub_FFE233D0(a2); /*0xffe23784*/
return result; /*0xffe23789*/
}
}
else
{
v8 = -2147483646; /*0xffe236f9*/
}
sub_FFE23AA9(64, "Tcg2 Boot in recovery Disable EH Status =%r \n", v8); /*0xffe23713*/
goto LABEL_15; /*0xffe23713*/
}
}
}
return result; /*0xffe23790*/
}
// ============================================================================
// 0xffe23796 AsciiStrnCpy_s
// ============================================================================
unsigned int __thiscall AsciiStrnCpy_s(char *Spec_ID_Event03)
{
char *Spec_ID_Event03_1; // esi
int v2; // eax
unsigned int n0xF4240; // edi
int v4; // eax
Spec_ID_Event03_1 = Spec_ID_Event03; /*0xffe23798*/
if ( !Spec_ID_Event03 ) /*0xffe237a2*/
{
v2 = sub_FFE23A81(); /*0xffe237a4*/
if ( v2 ) /*0xffe237ab*/
(*(void (__cdecl **)(const char *, int, const char *))(v2 + 4))( /*0xffe237b8*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c",
1082,
"String != ((void *) 0)");
}
n0xF4240 = 0; /*0xffe237be*/
while ( *Spec_ID_Event03_1 ) /*0xffe237e9*/
{
if ( n0xF4240 >= 0xF4240 ) /*0xffe237c8*/
{
v4 = sub_FFE23A81(); /*0xffe237ca*/
if ( v4 ) /*0xffe237d1*/
(*(void (__cdecl **)(const char *, int, const char *))(v4 + 4))( /*0xffe237de*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c",
1090,
"Length < _gPcd_FixedAtBuild_PcdMaximumAsciiStringLength");
}
++Spec_ID_Event03_1; /*0xffe237e4*/
++n0xF4240; /*0xffe237e5*/
}
return n0xF4240; /*0xffe237ed*/
}
// ============================================================================
// 0xffe237f1 SwapBytes16
// ============================================================================
int __fastcall SwapBytes16(int a1)
{
return ((unsigned __int16)__ROL2__(a1, 8) << 16) | (unsigned __int16)__ROL2__(HIWORD(a1), 8); /*0xffe23809*/
}
// ============================================================================
// 0xffe2380a WriteUnaligned16
// ============================================================================
__int16 __fastcall WriteUnaligned16(_WORD *a1, __int16 a2)
{
int v4; // eax
if ( !a1 ) /*0xffe23813*/
{
v4 = sub_FFE23A81(); /*0xffe23815*/
if ( v4 ) /*0xffe2381c*/
(*(void (__cdecl **)(const char *, int, const char *))(v4 + 4))( /*0xffe2382a*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c",
65,
"Buffer != ((void *) 0)");
}
*a1 = a2; /*0xffe23830*/
return a2; /*0xffe23836*/
}
// ============================================================================
// 0xffe23839 ReadUnaligned32
// ============================================================================
int __fastcall ReadUnaligned32(_DWORD *a1, int n150995008)
{
int v4; // eax
if ( !a1 ) /*0xffe23841*/
{
v4 = sub_FFE23A81(); /*0xffe23843*/
if ( v4 ) /*0xffe2384a*/
(*(void (__cdecl **)(const char *, int, const char *))(v4 + 4))( /*0xffe2385b*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c",
168,
"Buffer != ((void *) 0)");
}
*a1 = n150995008; /*0xffe23861*/
return n150995008; /*0xffe23865*/
}
// ============================================================================
// 0xffe23868 ReadUnaligned64
// ============================================================================
__int64 __thiscall ReadUnaligned64(void *this)
{
int v2; // eax
if ( !this ) /*0xffe2386d*/
{
v2 = sub_FFE23A81(); /*0xffe2386f*/
if ( v2 ) /*0xffe23876*/
(*(void (__cdecl **)(const char *, int, const char *))(v2 + 4))( /*0xffe23887*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c",
192,
"Buffer != ((void *) 0)");
}
return *(_QWORD *)this; /*0xffe23892*/
}
// ============================================================================
// 0xffe23894 WriteUnaligned32
// ============================================================================
int __cdecl WriteUnaligned32(int a1, int a2)
{
_DWORD *v2; // ecx
_DWORD *v3; // esi
int v4; // eax
v3 = v2; /*0xffe23895*/
if ( !v2 ) /*0xffe23899*/
{
v4 = sub_FFE23A81(); /*0xffe2389b*/
if ( v4 ) /*0xffe238a2*/
(*(void (__cdecl **)(const char *, int, const char *))(v4 + 4))( /*0xffe238b3*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c",
219,
"Buffer != ((void *) 0)");
}
*v3 = a1; /*0xffe238c1*/
v3[1] = a2; /*0xffe238c3*/
return a1; /*0xffe238c6*/
}
// ============================================================================
// 0xffe238c8 CopyMem
// ============================================================================
char *__fastcall CopyMem(char *dst, char *src, unsigned int count)
{
int v5; // eax
int v6; // eax
if ( count - 1 > -1 - (int)dst ) /*0xffe238de*/
{
v5 = sub_FFE23A81(); /*0xffe238e0*/
if ( v5 ) /*0xffe238e7*/
(*(void (__cdecl **)(const char *, int, const char *))(v5 + 4))( /*0xffe238f5*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CopyMemWrapper.c",
56,
"(Length - 1) <= (0xFFFFFFFF - (UINTN)DestinationBuffer)");
}
if ( count - 1 > -1 - (int)src ) /*0xffe238ff*/
{
v6 = sub_FFE23A81(); /*0xffe23901*/
if ( v6 ) /*0xffe23908*/
(*(void (__cdecl **)(const char *, int, const char *))(v6 + 4))( /*0xffe23916*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CopyMemWrapper.c",
57,
"(Length - 1) <= (0xFFFFFFFF - (UINTN)SourceBuffer)");
}
if ( dst == src ) /*0xffe2391e*/
return dst; /*0xffe23920*/
else
return sub_FFE21CC4(dst, src, count); /*0xffe2392a*/
}
// ============================================================================
// 0xffe23937 SetMem
// ============================================================================
void *__fastcall SetMem(void *buf, unsigned int count)
{
int v4; // eax
if ( count - 1 > -1 - (int)buf ) /*0xffe23948*/
{
v4 = sub_FFE23A81(); /*0xffe2394a*/
if ( v4 ) /*0xffe23951*/
(*(void (__cdecl **)(const char *, int, const char *))(v4 + 4))( /*0xffe2395f*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\SetMemWrapper.c",
54,
"(Length - 1) <= (0xFFFFFFFF - (UINTN)Buffer)");
}
return sub_FFE21D04(buf, count, 0); /*0xffe23971*/
}
// ============================================================================
// 0xffe23975 BaseIsEqualMemGuid
// ============================================================================
void *__thiscall BaseIsEqualMemGuid(void *this)
{
__int64 v2; // rax
__int64 v3; // rax
v2 = sub_FFE23868(&unk_FFE2C534); /*0xffe2397d*/
sub_FFE23894(v2, SHIDWORD(v2)); /*0xffe23986*/
v3 = sub_FFE23868(&unk_FFE2C53C); /*0xffe23990*/
sub_FFE23894(v3, SHIDWORD(v3)); /*0xffe2399a*/
return this; /*0xffe239a4*/
}
// ============================================================================
// 0xffe239a6 BaseIsZeroGuid
// ============================================================================
bool __fastcall BaseIsZeroGuid(int a1, int a2)
{
__int64 v4; // rax
int v5; // ebp
__int64 v6; // rax
int v7; // edi
__int64 v8; // kr00_8
__int64 v9; // rax
int v11; // [esp+10h] [ebp-Ch]
int v12; // [esp+14h] [ebp-8h]
v4 = sub_FFE23868((void *)a1); /*0xffe239b1*/
v12 = HIDWORD(v4); /*0xffe239b8*/
v5 = v4; /*0xffe239bc*/
v6 = sub_FFE23868((void *)a2); /*0xffe239be*/
v11 = HIDWORD(v6); /*0xffe239c6*/
v7 = v6; /*0xffe239ca*/
v8 = sub_FFE23868((void *)(a1 + 8)); /*0xffe239d8*/
v9 = sub_FFE23868((void *)(a2 + 8)); /*0xffe239da*/
return v5 == v7 && v12 == v11 && v8 == v9; /*0xffe239fd*/
}
// ============================================================================
// 0xffe23a05 InternalGetBestGuid
// ============================================================================
int __cdecl InternalGetBestGuid(int a1, int p_this)
{
int v2; // ecx
int v3; // esi
int v4; // eax
v3 = v2; /*0xffe23a06*/
v4 = sub_FFE2A23F(); /*0xffe23a08*/
return (*(int (__cdecl **)(int, int, _DWORD, int, int))(*(_DWORD *)v4 + 32))(v4, v3, 0, a1, p_this); /*0xffe23a21*/
}
// ============================================================================
// 0xffe23a23 IoRead32
// ============================================================================
unsigned __int32 __fastcall IoRead32(unsigned __int16 a1)
{
int v2; // eax
if ( (a1 & 3) != 0 ) /*0xffe23a29*/
{
v2 = sub_FFE23A81(); /*0xffe23a2b*/
if ( v2 ) /*0xffe23a32*/
(*(void (__cdecl **)(const char *, int, const char *))(v2 + 4))( /*0xffe23a43*/
"e:\\hs\\MdePkg\\Library\\BaseIoLibIntrinsic\\IoLibMsc.c",
193,
"(Port & 3) == 0");
}
return __indword(a1); /*0xffe23a4d*/
}
// ============================================================================
// 0xffe23a4f IoWrite32
// ============================================================================
unsigned int __fastcall IoWrite32(unsigned __int16 a1, unsigned int a2)
{
int v4; // eax
if ( (a1 & 3) != 0 ) /*0xffe23a58*/
{
v4 = sub_FFE23A81(); /*0xffe23a5a*/
if ( v4 ) /*0xffe23a61*/
(*(void (__cdecl **)(const char *, int, const char *))(v4 + 4))( /*0xffe23a72*/
"e:\\hs\\MdePkg\\Library\\BaseIoLibIntrinsic\\IoLibMsc.c",
223,
"(Port & 3) == 0");
}
__outdword(a1, a2); /*0xffe23a7d*/
return a2; /*0xffe23a7e*/
}
// ============================================================================
// 0xffe23a81 BaseReadMsr64
// ============================================================================
int BaseReadMsr64()
{
_BYTE v1[4]; // [esp+0h] [ebp-8h] BYREF
int v2; // [esp+4h] [ebp-4h] BYREF
if ( sub_FFE23A05((int)v1, (int)&v2) >= 0 ) /*0xffe23a9c*/
return v2; /*0xffe23aa2*/
else
return 0; /*0xffe23a9e*/
}
// ============================================================================
// 0xffe23aa9 DebugPrint
// ============================================================================
int DebugPrint(int a1, const char *a2, ...)
{
int result; // eax
int (__cdecl **v3)(int, const char *, char *); // esi
va_list va; // [esp+10h] [ebp+Ch] BYREF
va_start(va, a2);
result = sub_FFE23A81(); /*0xffe23aaa*/
v3 = (int (__cdecl **)(int, const char *, char *))result; /*0xffe23aaf*/
if ( result ) /*0xffe23ab3*/
{
result = sub_FFE2A1F0(); /*0xffe23ab5*/
if ( (result & a1) != 0 ) /*0xffe23ac0*/
return (*v3)(a1, a2, (char *)va); /*0xffe23acc*/
}
return result; /*0xffe23ad1*/
}
// ============================================================================
// 0xffe23ad3 AmiTpm20LocatePpi
// ============================================================================
int __fastcall AmiTpm20LocatePpi(
int e:__hs__MdePkg__Library__PeiServicesTablePointerLibIdt__PeiServ,
int n48,
int PeiServices____((void__)_0))
{
int result; // eax
result = sub_FFE23A81(); /*0xffe23ad9*/
if ( result ) /*0xffe23ae0*/
return (*(int (__cdecl **)(int, int, int))(result + 4))( /*0xffe23ae8*/
e:__hs__MdePkg__Library__PeiServicesTablePointerLibIdt__PeiServ,
n48,
PeiServices____((void__)_0));
return result; /*0xffe23aee*/
}
// ============================================================================
// 0xffe23af1 GetGuidHobDataSize
// ============================================================================
int __fastcall GetGuidHobDataSize(int a1, int a2, int a3, int a4)
{
int v6; // edi
_BYTE v8[92]; // [esp+8h] [ebp-5Ch] BYREF
sub_FFE24D71(v8); /*0xffe23b00*/
if ( a1 ) /*0xffe23b07*/
{
v6 = a3 - a2; /*0xffe23b0d*/
do /*0xffe23b23*/
{
sub_FFE24D9C(*(_DWORD *)(v6 + a2)); /*0xffe23b17*/
a2 += 4; /*0xffe23b1c*/
--a1; /*0xffe23b20*/
}
while ( a1 ); /*0xffe23b23*/
}
return sub_FFE24E32(a4, v8); /*0xffe23b31*/
}
// ============================================================================
// 0xffe23b37 Tpm20MeasureDigest
// ============================================================================
void *__fastcall Tpm20MeasureDigest(_DWORD *a1, char *src)
{
int v3; // edi
int v4; // edx
int v5; // eax
int v6; // edx
int v7; // ebp
int v8; // ebx
int v9; // esi
int v10; // eax
int v11; // ebp
int v12; // edi
int v13; // eax
int v14; // esi
int v15; // edx
int v16; // eax
int v17; // edi
int v18; // ebx
int v19; // eax
int v20; // edx
int v21; // ebp
int v22; // eax
int v23; // ebx
int v24; // esi
int v25; // eax
int v26; // ebp
int v27; // edi
int v28; // eax
int v29; // esi
int v30; // edx
int v31; // ebx
int v32; // eax
int v33; // edx
int v34; // ebp
int v35; // edi
int v36; // ecx
int v37; // ebx
int v38; // ebp
int v39; // edi
int v40; // ebp
int v41; // edx
int v42; // ebx
int v43; // esi
int v44; // ebp
int v45; // eax
int v46; // edx
int v47; // edi
int v48; // eax
int v49; // esi
int v50; // ebx
int v51; // eax
int v52; // edi
int v53; // ebp
int v54; // eax
int v55; // ebx
int v56; // edx
int v57; // eax
int v58; // ebp
int v59; // esi
int v60; // eax
int v61; // edx
int v62; // edi
int v63; // eax
int v64; // esi
int v65; // ebx
int v66; // eax
int v67; // edi
int v68; // ebp
int v69; // eax
int v70; // ebx
int v71; // edx
int v72; // eax
int v73; // ebp
int v74; // esi
int v75; // eax
int v76; // edx
int v77; // edi
int v78; // eax
int v79; // esi
int v80; // ebx
int v81; // eax
int v82; // edi
int v83; // ebp
int v84; // eax
int v85; // ebx
int v86; // edx
int v87; // eax
int v88; // ebp
int v89; // esi
int v90; // eax
int v91; // edx
int v92; // edi
int v93; // eax
int v94; // esi
int v95; // ebx
int v96; // eax
int v97; // edi
int v98; // ebp
int v99; // eax
int v100; // ebx
int v101; // edx
int v102; // eax
int v103; // ebp
int v104; // esi
int v105; // eax
int v106; // edx
int v107; // edi
int v108; // eax
int v109; // esi
int v110; // ebx
int v111; // eax
int v112; // edi
int v113; // ebp
int v114; // eax
int v115; // ebx
int v116; // ecx
int v117; // ebp
int v118; // esi
int v119; // edi
int v120; // ebx
int v121; // ebp
int v122; // esi
int v123; // edi
int v124; // ebx
int v125; // ebp
int v126; // esi
int v127; // edi
int v128; // ebx
int v129; // ebp
int v130; // ecx
int v131; // edi
int v132; // ecx
int v133; // esi
int v134; // ecx
int v135; // ebx
int v136; // ecx
int v137; // esi
int v138; // ebp
int v139; // edi
int v140; // ebx
int v141; // eax
int v142; // ecx
int v143; // ebp
int v144; // edx
int v145; // esi
int v146; // edi
int v147; // eax
int v148; // edx
int v149; // ebx
int v150; // eax
int v151; // esi
int v152; // ebp
int v153; // eax
int v154; // ebx
int v155; // edi
int v156; // eax
int v157; // ebp
int v158; // edx
int v159; // esi
int v160; // edi
int v161; // eax
int v162; // edx
int v163; // ebx
int v164; // eax
int v165; // esi
int v166; // ebp
int v167; // eax
int v168; // ebx
int v169; // edi
int v170; // eax
int v171; // ebp
int v172; // edx
int v173; // eax
int v174; // edi
int v175; // esi
int v176; // eax
int v177; // edx
int v178; // eax
int v179; // edx
int v180; // esi
int v181; // ebx
int v182; // eax
int v183; // edi
int v184; // eax
int v185; // ebx
int v186; // edx
int v187; // edi
int v188; // ebp
int v189; // esi
int v190; // edx
int v191; // eax
int v192; // ebp
int v193; // edx
int v194; // eax
unsigned int v196; // [esp+10h] [ebp-94h]
int v197; // [esp+10h] [ebp-94h]
int v198; // [esp+10h] [ebp-94h]
int v199; // [esp+10h] [ebp-94h]
int v200; // [esp+10h] [ebp-94h]
unsigned int v201; // [esp+14h] [ebp-90h]
int v202; // [esp+14h] [ebp-90h]
int v203; // [esp+14h] [ebp-90h]
int v204; // [esp+14h] [ebp-90h]
int v205; // [esp+14h] [ebp-90h]
int v206; // [esp+14h] [ebp-90h]
int v207; // [esp+14h] [ebp-90h]
int v208; // [esp+14h] [ebp-90h]
int v209; // [esp+14h] [ebp-90h]
int v210; // [esp+14h] [ebp-90h]
int v211; // [esp+14h] [ebp-90h]
unsigned int v212; // [esp+18h] [ebp-8Ch]
int v213; // [esp+18h] [ebp-8Ch]
int v214; // [esp+18h] [ebp-8Ch]
int v215; // [esp+18h] [ebp-8Ch]
int v216; // [esp+18h] [ebp-8Ch]
int v217; // [esp+18h] [ebp-8Ch]
int v218; // [esp+18h] [ebp-8Ch]
int v219; // [esp+18h] [ebp-8Ch]
int v220; // [esp+18h] [ebp-8Ch]
int v221; // [esp+1Ch] [ebp-88h]
int v222; // [esp+1Ch] [ebp-88h]
int v223; // [esp+1Ch] [ebp-88h]
int v224; // [esp+1Ch] [ebp-88h]
int v225; // [esp+1Ch] [ebp-88h]
unsigned int v226; // [esp+20h] [ebp-84h]
int v227; // [esp+20h] [ebp-84h]
int v228; // [esp+20h] [ebp-84h]
int v229; // [esp+20h] [ebp-84h]
unsigned int v230; // [esp+24h] [ebp-80h]
int v231; // [esp+24h] [ebp-80h]
int v232; // [esp+24h] [ebp-80h]
int v233; // [esp+24h] [ebp-80h]
unsigned int v234; // [esp+28h] [ebp-7Ch]
int v235; // [esp+28h] [ebp-7Ch]
int v236; // [esp+28h] [ebp-7Ch]
int v237; // [esp+28h] [ebp-7Ch]
int v238; // [esp+28h] [ebp-7Ch]
unsigned int v239; // [esp+2Ch] [ebp-78h]
int v240; // [esp+2Ch] [ebp-78h]
int v241; // [esp+2Ch] [ebp-78h]
int v242; // [esp+2Ch] [ebp-78h]
unsigned int v243; // [esp+30h] [ebp-74h]
int v244; // [esp+30h] [ebp-74h]
int v245; // [esp+30h] [ebp-74h]
int v246; // [esp+30h] [ebp-74h]
unsigned int v247; // [esp+34h] [ebp-70h]
int v248; // [esp+34h] [ebp-70h]
int v249; // [esp+34h] [ebp-70h]
int v250; // [esp+34h] [ebp-70h]
unsigned int v251; // [esp+38h] [ebp-6Ch]
int v252; // [esp+38h] [ebp-6Ch]
int v253; // [esp+38h] [ebp-6Ch]
int v254; // [esp+38h] [ebp-6Ch]
unsigned int v255; // [esp+3Ch] [ebp-68h]
int v256; // [esp+3Ch] [ebp-68h]
int v257; // [esp+3Ch] [ebp-68h]
int v258; // [esp+3Ch] [ebp-68h]
unsigned int v259; // [esp+40h] [ebp-64h]
int v260; // [esp+40h] [ebp-64h]
int v261; // [esp+40h] [ebp-64h]
int v262; // [esp+40h] [ebp-64h]
int v263; // [esp+44h] [ebp-60h]
int v264; // [esp+44h] [ebp-60h]
int v265; // [esp+44h] [ebp-60h]
int v266; // [esp+44h] [ebp-60h]
unsigned int v267; // [esp+48h] [ebp-5Ch]
int v268; // [esp+48h] [ebp-5Ch]
int v269; // [esp+48h] [ebp-5Ch]
int v270; // [esp+48h] [ebp-5Ch]
int v271; // [esp+48h] [ebp-5Ch]
unsigned int v272; // [esp+4Ch] [ebp-58h]
int v273; // [esp+4Ch] [ebp-58h]
int v274; // [esp+4Ch] [ebp-58h]
int v275; // [esp+4Ch] [ebp-58h]
int v276; // [esp+50h] [ebp-54h]
int v277; // [esp+50h] [ebp-54h]
int v278; // [esp+50h] [ebp-54h]
int v279; // [esp+54h] [ebp-50h]
int v280; // [esp+54h] [ebp-50h]
int v281; // [esp+54h] [ebp-50h]
unsigned int v282; // [esp+58h] [ebp-4Ch]
int v283; // [esp+58h] [ebp-4Ch]
int v284; // [esp+58h] [ebp-4Ch]
int v285; // [esp+58h] [ebp-4Ch]
int v286; // [esp+58h] [ebp-4Ch]
unsigned int v287; // [esp+5Ch] [ebp-48h]
int v288; // [esp+5Ch] [ebp-48h]
int v289; // [esp+5Ch] [ebp-48h]
int dst_; // [esp+64h] [ebp-40h] BYREF
int v292; // [esp+68h] [ebp-3Ch]
int v293; // [esp+6Ch] [ebp-38h]
int v294; // [esp+70h] [ebp-34h]
int v295; // [esp+74h] [ebp-30h]
int v296; // [esp+78h] [ebp-2Ch]
int v297; // [esp+7Ch] [ebp-28h]
int v298; // [esp+80h] [ebp-24h]
int v299; // [esp+84h] [ebp-20h]
int v300; // [esp+88h] [ebp-1Ch]
int v301; // [esp+8Ch] [ebp-18h]
int v302; // [esp+90h] [ebp-14h]
int v303; // [esp+94h] [ebp-10h]
int v304; // [esp+98h] [ebp-Ch]
int v305; // [esp+9Ch] [ebp-8h]
int v306; // [esp+A0h] [ebp-4h]
sub_FFE238C8((char *)&dst_, src, 0x40u); /*0xffe23b4d*/
v3 = a1[3]; /*0xffe23b58*/
v4 = a1[1]; /*0xffe23b5d*/
v226 = __ROL4__(dst_, 8) & 0xFF00FF | __ROR4__(dst_, 8) & 0xFF00FF00; /*0xffe23b78*/
v5 = v3 ^ v4 & (a1[2] ^ v3); /*0xffe23b91*/
v6 = __ROR4__(v4, 2); /*0xffe23b93*/
v7 = a1[4] + __ROL4__(*a1, 5) + v5 + v226 + 1518500249; /*0xffe23b9e*/
v247 = __ROL4__(v292, 8) & 0xFF00FF | __ROR4__(v292, 8) & 0xFF00FF00; /*0xffe23bc4*/
v8 = __ROR4__(*a1, 2); /*0xffe23bd3*/
v9 = v3 + 1518500249 + (a1[2] ^ *a1 & (v6 ^ a1[2])) + __ROL4__(v7, 5) + v247; /*0xffe23be5*/
v243 = __ROL4__(v293, 8) & 0xFF00FF | __ROR4__(v293, 8) & 0xFF00FF00; /*0xffe23c05*/
v10 = v7 & (v8 ^ v6); /*0xffe23c0f*/
v11 = __ROR4__(v7, 2); /*0xffe23c11*/
v12 = v243 + __ROL4__(v9, 5) + (v6 ^ v10) + a1[2] + 1518500249; /*0xffe23c21*/
v201 = __ROL4__(v294, 8) & 0xFF00FF | __ROR4__(v294, 8) & 0xFF00FF00; /*0xffe23c46*/
v13 = v8 ^ v9 & (v8 ^ v11); /*0xffe23c4e*/
v14 = __ROR4__(v9, 2); /*0xffe23c5f*/
v15 = v201 + __ROL4__(v12, 5) + v13 + v6 + 1518500249; /*0xffe23c62*/
v287 = __ROL4__(v295, 8) & 0xFF00FF | __ROR4__(v295, 8) & 0xFF00FF00; /*0xffe23c7f*/
v16 = v287 + __ROL4__(v15, 5) + (v11 ^ v12 & (v14 ^ v11)); /*0xffe23c92*/
v17 = __ROR4__(v12, 2); /*0xffe23c94*/
v18 = v16 + v8 + 1518500249; /*0xffe23c97*/
v196 = __ROL4__(v296, 8) & 0xFF00FF | __ROR4__(v296, 8) & 0xFF00FF00; /*0xffe23cb4*/
v19 = v14 ^ v15 & (v17 ^ v14); /*0xffe23cc1*/
v20 = __ROR4__(v15, 2); /*0xffe23cc9*/
v21 = v196 + __ROL4__(v18, 5) + 1518500249 + v19 + v11; /*0xffe23cd2*/
v234 = __ROL4__(v297, 8) & 0xFF00FF | __ROR4__(v297, 8) & 0xFF00FF00; /*0xffe23cef*/
v22 = v17 ^ v18 & (v20 ^ v17); /*0xffe23cfc*/
v23 = __ROR4__(v18, 2); /*0xffe23d04*/
v24 = v234 + __ROL4__(v21, 5) + 1518500249 + v22 + v14; /*0xffe23d0d*/
v230 = __ROL4__(v298, 8) & 0xFF00FF | __ROR4__(v298, 8) & 0xFF00FF00; /*0xffe23d2b*/
v25 = v20 ^ v21 & (v23 ^ v20); /*0xffe23d44*/
v26 = __ROR4__(v21, 2); /*0xffe23d46*/
v27 = v230 + __ROL4__(v24, 5) + 1518500249 + v25 + v17; /*0xffe23d4b*/
v251 = __ROL4__(v299, 8) & 0xFF00FF | __ROR4__(v299, 8) & 0xFF00FF00; /*0xffe23d6b*/
v28 = v23 ^ v24 & (v23 ^ v26); /*0xffe23d78*/
v29 = __ROR4__(v24, 2); /*0xffe23d80*/
v30 = v251 + __ROL4__(v27, 5) + 1518500249 + v28 + v20; /*0xffe23d89*/
v272 = __ROL4__(v300, 8) & 0xFF00FF | __ROR4__(v300, 8) & 0xFF00FF00; /*0xffe23da9*/
v221 = __ROR4__(v27, 2); /*0xffe23dc7*/
v31 = v272 + __ROL4__(v30, 5) + 1518500249 + (v26 ^ v27 & (v29 ^ v26)) + v23; /*0xffe23dcb*/
v267 = __ROL4__(v301, 8) & 0xFF00FF | __ROR4__(v301, 8) & 0xFF00FF00; /*0xffe23deb*/
v32 = v29 ^ v30 & (v221 ^ v29); /*0xffe23df8*/
v33 = __ROR4__(v30, 2); /*0xffe23e00*/
v34 = v267 + __ROL4__(v31, 5) + 1518500249 + v32 + v26; /*0xffe23e09*/
v282 = __ROL4__(v302, 8) & 0xFF00FF | __ROR4__(v302, 8) & 0xFF00FF00; /*0xffe23e29*/
v35 = v29 + 1518500249 + v282 + __ROL4__(v34, 5) + (v31 & (v33 ^ v221) ^ v221); /*0xffe23e4e*/
v263 = __ROR4__(v31, 2); /*0xffe23e50*/
v212 = __ROL4__(v303, 8) & 0xFF00FF | __ROR4__(v303, 8) & 0xFF00FF00; /*0xffe23e86*/
v36 = v221 + 1518500249; /*0xffe23e94*/
v222 = __ROR4__(v34, 2); /*0xffe23e9a*/
v37 = v36 + v212 + __ROL4__(v35, 5) + (v33 ^ v34 & (v33 ^ v263)); /*0xffe23e9e*/
v38 = v263 ^ v35 & (v263 ^ v222); /*0xffe23ea9*/
v39 = __ROR4__(v35, 2); /*0xffe23eb9*/
v255 = __ROL4__(v304, 8) & 0xFF00FF | __ROR4__(v304, 8) & 0xFF00FF00; /*0xffe23ecb*/
v40 = v33 + 1518500249 + v255 + __ROL4__(v37, 5) + v38; /*0xffe23edf*/
v259 = __ROL4__(v305, 8) & 0xFF00FF | __ROR4__(v305, 8) & 0xFF00FF00; /*0xffe23ef9*/
v41 = v263 + 1518500249 + v259 + __ROL4__(v40, 5) + (v37 & (v39 ^ v222) ^ v222); /*0xffe23f13*/
v42 = __ROR4__(v37, 2); /*0xffe23f15*/
v239 = __ROL4__(v306, 8) & 0xFF00FF | __ROR4__(v306, 8) & 0xFF00FF00; /*0xffe23f36*/
v43 = v222 + 1518500249 + (v39 ^ v40 & (v42 ^ v39)) + __ROL4__(v41, 5) + v239; /*0xffe23f54*/
v227 = __ROL4__(v243 ^ v251 ^ v255 ^ v226, 1); /*0xffe23f62*/
v44 = __ROR4__(v40, 2); /*0xffe23f71*/
v45 = v41 & (v44 ^ v42); /*0xffe23f7a*/
v46 = __ROR4__(v41, 2); /*0xffe23f7c*/
v47 = v227 + __ROL4__(v43, 5) + 1518500249 + (v42 ^ v45) + v39; /*0xffe23f83*/
v276 = __ROL4__(v247 ^ v201 ^ v272 ^ v259, 1); /*0xffe23f99*/
v48 = v276 + __ROL4__(v47, 5) + 1518500249 + (v44 ^ v43 & (v46 ^ v44)); /*0xffe23fb2*/
v49 = __ROR4__(v43, 2); /*0xffe23fb4*/
v50 = v48 + v42; /*0xffe23fb7*/
v279 = __ROL4__(v243 ^ v287 ^ v267 ^ v239, 1); /*0xffe23fcd*/
v51 = v279 + __ROL4__(v50, 5) + 1518500249 + (v46 ^ v47 & (v46 ^ v49)); /*0xffe23fe6*/
v52 = __ROR4__(v47, 2); /*0xffe23fe8*/
v53 = v51 + v44; /*0xffe23feb*/
v264 = __ROL4__(v201 ^ v196 ^ v282 ^ v227, 1); /*0xffe24001*/
v54 = v264 + __ROL4__(v53, 5) + 1518500249 + (v49 ^ v50 & (v52 ^ v49)); /*0xffe2401a*/
v55 = __ROR4__(v50, 2); /*0xffe2401c*/
v56 = v54 + v46; /*0xffe2401f*/
v244 = __ROL4__(v276 ^ v287 ^ v234 ^ v212, 1); /*0xffe24035*/
v57 = v53 ^ v55 ^ v52; /*0xffe2404a*/
v58 = __ROR4__(v53, 2); /*0xffe2404c*/
v59 = v244 + __ROL4__(v56, 5) + 1859775393 + v57 + v49; /*0xffe24051*/
v248 = __ROL4__(v279 ^ v196 ^ v230 ^ v255, 1); /*0xffe24067*/
v60 = v248 + __ROL4__(v59, 5) + 1859775393 + (v56 ^ v58 ^ v55); /*0xffe2407e*/
v61 = __ROR4__(v56, 2); /*0xffe24080*/
v62 = v60 + v52; /*0xffe24083*/
v223 = __ROL4__(v264 ^ v234 ^ v251 ^ v259, 1); /*0xffe24099*/
v63 = v61 ^ v58 ^ v59; /*0xffe240a4*/
v64 = __ROR4__(v59, 2); /*0xffe240a6*/
v65 = v223 + __ROL4__(v62, 5) + 1859775393 + v63 + v55; /*0xffe240b5*/
v231 = __ROL4__(v244 ^ v230 ^ v272 ^ v239, 1); /*0xffe240cb*/
v66 = v61 ^ v62 ^ v64; /*0xffe240d6*/
v67 = __ROR4__(v62, 2); /*0xffe240d8*/
v68 = v231 + __ROL4__(v65, 5) + 1859775393 + v66 + v58; /*0xffe240e7*/
v235 = __ROL4__(v248 ^ v251 ^ v267 ^ v227, 1); /*0xffe240fd*/
v69 = v235 + __ROL4__(v68, 5) + 1859775393 + (v65 ^ v67 ^ v64); /*0xffe24114*/
v70 = __ROR4__(v65, 2); /*0xffe24116*/
v71 = v69 + v61; /*0xffe24119*/
v197 = __ROL4__(v276 ^ v223 ^ v272 ^ v282, 1); /*0xffe2412f*/
v72 = v197 + __ROL4__(v71, 5) + 1859775393 + (v68 ^ v70 ^ v67); /*0xffe24146*/
v73 = __ROR4__(v68, 2); /*0xffe24148*/
v74 = v72 + v64; /*0xffe2414b*/
v268 = __ROL4__(v279 ^ v231 ^ v267 ^ v212, 1); /*0xffe24161*/
v75 = v268 + __ROL4__(v74, 5) + 1859775393 + (v71 ^ v73 ^ v70); /*0xffe24178*/
v76 = __ROR4__(v71, 2); /*0xffe2417a*/
v77 = v75 + v67; /*0xffe2417d*/
v273 = __ROL4__(v264 ^ v235 ^ v282 ^ v255, 1); /*0xffe24193*/
v78 = v76 ^ v73 ^ v74; /*0xffe2419e*/
v79 = __ROR4__(v74, 2); /*0xffe241a0*/
v80 = v273 + __ROL4__(v77, 5) + 1859775393 + v78 + v70; /*0xffe241af*/
v252 = __ROL4__(v244 ^ v197 ^ v212 ^ v259, 1); /*0xffe241c5*/
v81 = v76 ^ v77 ^ v79; /*0xffe241d0*/
v82 = __ROR4__(v77, 2); /*0xffe241d2*/
v83 = v252 + __ROL4__(v80, 5) + 1859775393 + v81 + v73; /*0xffe241e1*/
v256 = __ROL4__(v248 ^ v268 ^ v255 ^ v239, 1); /*0xffe241f7*/
v84 = v256 + __ROL4__(v83, 5) + 1859775393 + (v80 ^ v82 ^ v79); /*0xffe2420e*/
v85 = __ROR4__(v80, 2); /*0xffe24210*/
v86 = v84 + v76; /*0xffe24213*/
v260 = __ROL4__(v223 ^ v273 ^ v259 ^ v227, 1); /*0xffe24229*/
v87 = v260 + __ROL4__(v86, 5) + 1859775393 + (v83 ^ v85 ^ v82); /*0xffe24240*/
v88 = __ROR4__(v83, 2); /*0xffe24242*/
v89 = v87 + v79; /*0xffe24245*/
v240 = __ROL4__(v276 ^ v231 ^ v252 ^ v239, 1); /*0xffe2425b*/
v90 = v240 + __ROL4__(v89, 5) + 1859775393 + (v86 ^ v88 ^ v85); /*0xffe24272*/
v91 = __ROR4__(v86, 2); /*0xffe24274*/
v92 = v90 + v82; /*0xffe24277*/
v228 = __ROL4__(v279 ^ v235 ^ v256 ^ v227, 1); /*0xffe2428d*/
v93 = v91 ^ v88 ^ v89; /*0xffe24298*/
v94 = __ROR4__(v89, 2); /*0xffe2429a*/
v95 = v228 + __ROL4__(v92, 5) + 1859775393 + v93 + v85; /*0xffe242a9*/
v277 = __ROL4__(v276 ^ v264 ^ v197 ^ v260, 1); /*0xffe242bf*/
v96 = v91 ^ v92 ^ v94; /*0xffe242ca*/
v97 = __ROR4__(v92, 2); /*0xffe242cc*/
v98 = v277 + __ROL4__(v95, 5) + 1859775393 + v96 + v88; /*0xffe242db*/
v280 = __ROL4__(v279 ^ v244 ^ v268 ^ v240, 1); /*0xffe242f1*/
v99 = v280 + __ROL4__(v98, 5) + 1859775393 + (v95 ^ v97 ^ v94); /*0xffe24308*/
v100 = __ROR4__(v95, 2); /*0xffe2430a*/
v101 = v99 + v91; /*0xffe2430d*/
v265 = __ROL4__(v264 ^ v248 ^ v273 ^ v228, 1); /*0xffe24323*/
v102 = v98 ^ v100 ^ v97; /*0xffe2432e*/
v103 = __ROR4__(v98, 2); /*0xffe24336*/
v104 = v265 + __ROL4__(v101, 5) + 1859775393 + v102 + v94; /*0xffe2433f*/
v245 = __ROL4__(v277 ^ v244 ^ v223 ^ v252, 1); /*0xffe24355*/
v105 = v245 + __ROL4__(v104, 5) + 1859775393 + (v101 ^ v103 ^ v100); /*0xffe2436c*/
v106 = __ROR4__(v101, 2); /*0xffe2436e*/
v107 = v105 + v97; /*0xffe24371*/
v249 = __ROL4__(v280 ^ v248 ^ v231 ^ v256, 1); /*0xffe24387*/
v108 = v106 ^ v103 ^ v104; /*0xffe24392*/
v109 = __ROR4__(v104, 2); /*0xffe24394*/
v110 = v249 + __ROL4__(v107, 5) + 1859775393 + v108 + v100; /*0xffe243a3*/
v224 = __ROL4__(v265 ^ v223 ^ v235 ^ v260, 1); /*0xffe243b9*/
v111 = v106 ^ v107 ^ v109; /*0xffe243c4*/
v112 = __ROR4__(v107, 2); /*0xffe243c6*/
v113 = v224 + __ROL4__(v110, 5) + 1859775393 + v111 + v103; /*0xffe243d5*/
v232 = __ROL4__(v245 ^ v231 ^ v197 ^ v240, 1); /*0xffe243eb*/
v114 = v232 + __ROL4__(v113, 5) + 1859775393 + (v110 ^ v112 ^ v109); /*0xffe24402*/
v115 = __ROR4__(v110, 2); /*0xffe24404*/
v236 = __ROL4__(v249 ^ v235 ^ v268 ^ v228, 1); /*0xffe24423*/
v116 = v113 & v115 | v112 & (v113 | v115); /*0xffe24436*/
v117 = __ROR4__(v113, 2); /*0xffe24438*/
v198 = __ROL4__(v277 ^ v224 ^ v197 ^ v273, 1); /*0xffe24465*/
v202 = v109 - 1894007588 + v236 + v116 + __ROL4__(v114 + v106, 5); /*0xffe24471*/
v118 = __ROR4__(v114 + v106, 2); /*0xffe2447c*/
v269 = __ROL4__(v280 ^ v232 ^ v268 ^ v252, 1); /*0xffe244a1*/
v213 = v112 - 1894007588 + v198 + ((v114 + v106) & v117 | v115 & ((v114 + v106) | v117)) + __ROL4__(v202, 5); /*0xffe244a9*/
v119 = __ROR4__(v202, 2); /*0xffe244b4*/
v274 = __ROL4__(v265 ^ v236 ^ v273 ^ v256, 1); /*0xffe244db*/
v203 = v115 - 1894007588 + v269 + (v118 & v202 | v117 & (v118 | v202)) + __ROL4__(v213, 5); /*0xffe244e3*/
v120 = __ROR4__(v213, 2); /*0xffe2450e*/
v253 = __ROL4__(v245 ^ v198 ^ v252 ^ v260, 1); /*0xffe24515*/
v214 = v117 + v274 + (v213 & v119 | v118 & (v213 | v119)) - 1894007588 + __ROL4__(v203, 5); /*0xffe2451b*/
v121 = __ROR4__(v203, 2); /*0xffe2452a*/
v257 = __ROL4__(v249 ^ v269 ^ v256 ^ v240, 1); /*0xffe2455d*/
v204 = v118 - 1894007588 + v253 + (v203 & v120 | v119 & (v203 | v120)) + __ROL4__(v214, 5); /*0xffe24569*/
v122 = __ROR4__(v214, 2); /*0xffe24574*/
v261 = __ROL4__(v224 ^ v274 ^ v260 ^ v228, 1); /*0xffe2459b*/
v215 = v119 - 1894007588 + v257 + (v214 & v121 | v120 & (v214 | v121)) + __ROL4__(v204, 5); /*0xffe245a7*/
v123 = __ROR4__(v204, 2); /*0xffe245b2*/
v241 = __ROL4__(v277 ^ v232 ^ v253 ^ v240, 1); /*0xffe245d7*/
v205 = v120 - 1894007588 + v261 + (v204 & v122 | v121 & (v204 | v122)) + __ROL4__(v215, 5); /*0xffe245df*/
v124 = __ROR4__(v215, 2); /*0xffe245ea*/
v229 = __ROL4__(v280 ^ v236 ^ v257 ^ v228, 1); /*0xffe2460f*/
v216 = v121 - 1894007588 + v241 + (v123 & v215 | v122 & (v123 | v215)) + __ROL4__(v205, 5); /*0xffe24617*/
v278 = __ROL4__(v277 ^ v265 ^ v198 ^ v261, 1); /*0xffe2464c*/
v125 = __ROR4__(v205, 2); /*0xffe24650*/
v206 = v122 - 1894007588 + v229 + (v205 & v124 | v123 & (v205 | v124)) + __ROL4__(v216, 5); /*0xffe24655*/
v126 = __ROR4__(v216, 2); /*0xffe2466c*/
v281 = __ROL4__(v280 ^ v245 ^ v269 ^ v241, 1); /*0xffe24693*/
v217 = v123 - 1894007588 + v278 + (v216 & v125 | v124 & (v216 | v125)) + __ROL4__(v206, 5); /*0xffe2469b*/
v127 = __ROR4__(v206, 2); /*0xffe246c2*/
v266 = __ROL4__(v265 ^ v249 ^ v274 ^ v229, 1); /*0xffe246c5*/
v207 = v124 - 1894007588 + v281 + (v206 & v126 | v125 & (v206 | v126)) + __ROL4__(v217, 5); /*0xffe246cd*/
v128 = __ROR4__(v217, 2); /*0xffe246da*/
v246 = __ROL4__(v278 ^ v245 ^ v224 ^ v253, 1); /*0xffe24705*/
v218 = v125 + v266 + (v217 & v127 | v126 & (v217 | v127)) + __ROL4__(v207, 5) - 1894007588; /*0xffe2470b*/
v250 = __ROL4__(v281 ^ v249 ^ v232 ^ v257, 1); /*0xffe24740*/
v129 = __ROR4__(v207, 2); /*0xffe24744*/
v208 = v126 - 1894007588 + v246 + (v128 & v207 | v127 & (v128 | v207)) + __ROL4__(v218, 5); /*0xffe24747*/
v130 = v218 & v129 | v128 & (v218 | v129); /*0xffe2475b*/
v219 = __ROR4__(v218, 2); /*0xffe2475d*/
v225 = __ROL4__(v266 ^ v224 ^ v236 ^ v261, 1); /*0xffe24787*/
v283 = v127 + v250 + v130 + __ROL4__(v208, 5) - 1894007588; /*0xffe2478f*/
v131 = __ROR4__(v208, 2); /*0xffe2479c*/
v233 = __ROL4__(v246 ^ v232 ^ v198 ^ v241, 1); /*0xffe247c7*/
v288 = v128 + v225 + (v208 & v219 | v129 & (v208 | v219)) + __ROL4__(v283, 5) - 1894007588; /*0xffe247cd*/
v132 = v283 & v131 | v219 & (v283 | v131); /*0xffe247df*/
v284 = __ROR4__(v283, 2); /*0xffe247e1*/
v133 = v129 + v233 + v132 + __ROL4__(v288, 5) - 1894007588; /*0xffe247f9*/
v237 = __ROL4__(v250 ^ v236 ^ v269 ^ v229, 1); /*0xffe24814*/
v134 = v288 & v284 | v131 & (v288 | v284); /*0xffe2481d*/
v289 = __ROR4__(v288, 2); /*0xffe2481f*/
v135 = v219 + v237 + v134 + __ROL4__(v133, 5) - 1894007588; /*0xffe24833*/
v199 = __ROL4__(v278 ^ v225 ^ v198 ^ v274, 1); /*0xffe2484d*/
v136 = v289 & v133 | v284 & (v289 | v133); /*0xffe24858*/
v137 = __ROR4__(v133, 2); /*0xffe2485a*/
v138 = v131 + v199 + v136 + __ROL4__(v135, 5) - 1894007588; /*0xffe24875*/
v275 = __ROL4__(v266 ^ v237 ^ v274 ^ v257, 1); /*0xffe248a4*/
v209 = __ROL4__(v281 ^ v233 ^ v269 ^ v253, 1); /*0xffe248ac*/
v139 = v284 + v209 + (v135 & v137 | v289 & (v135 | v137)) + __ROL4__(v138, 5) - 1894007588; /*0xffe248b6*/
v140 = __ROR4__(v135, 2); /*0xffe248b8*/
v141 = v138 & v140; /*0xffe248bf*/
v142 = v137 & (v138 | v140); /*0xffe248c3*/
v143 = __ROR4__(v138, 2); /*0xffe248c5*/
v254 = __ROL4__(v246 ^ v199 ^ v253 ^ v261, 1); /*0xffe248ec*/
v144 = v289 + v275 + (v141 | v142) - 1894007588 + __ROL4__(v139, 5); /*0xffe248f7*/
v145 = v137 + v254 + (v139 ^ v143 ^ v140) + __ROL4__(v144, 5) - 899497514; /*0xffe2490c*/
v146 = __ROR4__(v139, 2); /*0xffe2490e*/
v258 = __ROL4__(v250 ^ v209 ^ v257 ^ v241, 1); /*0xffe24925*/
v147 = v144 ^ v146 ^ v143; /*0xffe24930*/
v148 = __ROR4__(v144, 2); /*0xffe24932*/
v149 = v140 + v258 + v147 + __ROL4__(v145, 5) - 899497514; /*0xffe24941*/
v262 = __ROL4__(v225 ^ v275 ^ v261 ^ v229, 1); /*0xffe24957*/
v150 = v148 ^ v146 ^ v145; /*0xffe24962*/
v151 = __ROR4__(v145, 2); /*0xffe24964*/
v152 = v143 + v262 + v150 + __ROL4__(v149, 5) - 899497514; /*0xffe24973*/
v242 = __ROL4__(v278 ^ v233 ^ v254 ^ v241, 1); /*0xffe24989*/
v153 = v148 ^ v149 ^ v151; /*0xffe24994*/
v154 = __ROR4__(v149, 2); /*0xffe24996*/
v155 = v146 + v242 + v153 + __ROL4__(v152, 5) - 899497514; /*0xffe249a5*/
dst_ = __ROL4__(v281 ^ v237 ^ v258 ^ v229, 1); /*0xffe249bf*/
v156 = v152 ^ v154 ^ v151; /*0xffe249ca*/
v157 = __ROR4__(v152, 2); /*0xffe249cc*/
v158 = v148 + dst_ + v156 + __ROL4__(v155, 5) - 899497514; /*0xffe249db*/
v292 = __ROL4__(v278 ^ v266 ^ v199 ^ v262, 1); /*0xffe249f5*/
v159 = v151 + v292 + (v155 ^ v157 ^ v154) + __ROL4__(v158, 5) - 899497514; /*0xffe24a0e*/
v293 = __ROL4__(v281 ^ v246 ^ v209 ^ v242, 1); /*0xffe24a28*/
v160 = __ROR4__(v155, 2); /*0xffe24a2e*/
v161 = v158 ^ v160 ^ v157; /*0xffe24a36*/
v162 = __ROR4__(v158, 2); /*0xffe24a38*/
v163 = v154 + v293 + v161 + __ROL4__(v159, 5) - 899497514; /*0xffe24a47*/
v294 = __ROL4__(v266 ^ v250 ^ v275 ^ dst_, 1); /*0xffe24a61*/
v164 = v162 ^ v160 ^ v159; /*0xffe24a6c*/
v165 = __ROR4__(v159, 2); /*0xffe24a6e*/
v166 = v157 + v294 + v164 + __ROL4__(v163, 5) - 899497514; /*0xffe24a7d*/
v295 = __ROL4__(v292 ^ v246 ^ v225 ^ v254, 1); /*0xffe24a97*/
v167 = v162 ^ v163 ^ v165; /*0xffe24aa2*/
v168 = __ROR4__(v163, 2); /*0xffe24aa4*/
v169 = v160 + v295 + v167 + __ROL4__(v166, 5) - 899497514; /*0xffe24ab3*/
v296 = __ROL4__(v293 ^ v250 ^ v233 ^ v258, 1); /*0xffe24acd*/
v170 = v166 ^ v168 ^ v165; /*0xffe24ad8*/
v171 = __ROR4__(v166, 2); /*0xffe24ada*/
v172 = v162 + v296 + v170 + __ROL4__(v169, 5) - 899497514; /*0xffe24ae9*/
v297 = __ROL4__(v294 ^ v225 ^ v237 ^ v262, 1); /*0xffe24b03*/
v173 = v165 + v297 + (v169 ^ v171 ^ v168); /*0xffe24b14*/
v174 = __ROR4__(v169, 2); /*0xffe24b16*/
v175 = v173 + __ROL4__(v172, 5) - 899497514; /*0xffe24b1f*/
v298 = __ROL4__(v295 ^ v233 ^ v199 ^ v242, 1); /*0xffe24b39*/
v176 = v298 + (v172 ^ v174 ^ v171); /*0xffe24b4f*/
v285 = __ROR4__(v172, 2); /*0xffe24b60*/
v177 = v296 ^ v237 ^ v209 ^ dst_; /*0xffe24b72*/
v270 = __ROL4__(v175, 5) - 899497514 + v168 + v176; /*0xffe24b76*/
v178 = v174 ^ v175; /*0xffe24b7c*/
v238 = __ROR4__(v175, 2); /*0xffe24b85*/
v179 = __ROL4__(v177, 1); /*0xffe24b99*/
v180 = __ROL4__(v292 ^ v297 ^ v199 ^ v275, 1); /*0xffe24ba2*/
v181 = v171 - 899497514 + v179 + (v285 ^ v178) + __ROL4__(v270, 5); /*0xffe24ba8*/
v182 = v174 + v180 + (v285 ^ v270 ^ v238); /*0xffe24bbe*/
v271 = __ROR4__(v270, 2); /*0xffe24bc0*/
v183 = v182 + __ROL4__(v181, 5) - 899497514; /*0xffe24bd2*/
v184 = v181 ^ v271 ^ v238; /*0xffe24be2*/
v220 = __ROR4__(v181, 2); /*0xffe24beb*/
v299 = v179; /*0xffe24c0e*/
v300 = v180; /*0xffe24c17*/
v301 = __ROL4__(v293 ^ v298 ^ v209 ^ v254, 1); /*0xffe24c1e*/
v185 = __ROL4__(v294 ^ v179 ^ v275 ^ v258, 1); /*0xffe24c25*/
v186 = __ROL4__(v183, 5) - 899497514 + v285 + v301 + v184; /*0xffe24c27*/
v302 = v185; /*0xffe24c29*/
v286 = __ROR4__(v183, 2); /*0xffe24c50*/
v210 = __ROL4__(v186, 5) - 899497514 + v238 + v185 + (v183 ^ v220 ^ v271); /*0xffe24c5e*/
v200 = __ROR4__(v186, 2); /*0xffe24c75*/
v187 = __ROL4__(v295 ^ v180 ^ v254 ^ v262, 1); /*0xffe24c81*/
v304 = __ROL4__(v296 ^ v301 ^ v258 ^ v242, 1); /*0xffe24c9c*/
v188 = __ROL4__(v210, 5) - 899497514 + v271 + v187 + (v186 ^ v286 ^ v220); /*0xffe24ca3*/
v303 = v187; /*0xffe24ca5*/
v189 = v220 + v304 + (v200 ^ v286 ^ v210) + __ROL4__(v188, 5) - 899497514; /*0xffe24ccd*/
v211 = __ROR4__(v210, 2); /*0xffe24ce2*/
v190 = __ROL4__(v297 ^ v185 ^ v262 ^ dst_, 1); /*0xffe24cf0*/
v191 = v286 + v190 + (v200 ^ v188 ^ v211); /*0xffe24cf7*/
v305 = v190; /*0xffe24cfb*/
v192 = __ROR4__(v188, 2); /*0xffe24d02*/
v193 = v191 + __ROL4__(v189, 5) - 899497514; /*0xffe24d0b*/
v306 = __ROL4__(v292 ^ v298 ^ v187 ^ v242, 1); /*0xffe24d27*/
v194 = v306 + *a1 + (v189 ^ v192 ^ v211); /*0xffe24d39*/
a1[1] += v193; /*0xffe24d3d*/
a1[3] += v192; /*0xffe24d4a*/
a1[4] += v211; /*0xffe24d4f*/
a1[2] += __ROR4__(v189, 2); /*0xffe24d59*/
*a1 = v200 + __ROL4__(v193, 5) - 899497514 + v194; /*0xffe24d5f*/
return sub_FFE23937(&dst_, 0x40u); /*0xffe24d66*/
}
// ============================================================================
// 0xffe24d71 InitHashContext
// ============================================================================
void __thiscall InitHashContext(_DWORD *this)
{
*(this + 6) = 0; /*0xffe24d71*/
*(this + 5) = 0; /*0xffe24d75*/
*this = 1732584193; /*0xffe24d79*/
*(this + 1) = -271733879; /*0xffe24d7f*/
*(this + 2) = -1732584194; /*0xffe24d86*/
*(this + 3) = 271733878; /*0xffe24d8d*/
*(this + 4) = -1009589776; /*0xffe24d94*/
}
// ============================================================================
// 0xffe24d9c HashUpdateSha256
// ============================================================================
char *__fastcall HashUpdateSha256(int a1, char *src, unsigned int i_1)
{
int v4; // ebx
unsigned int v5; // ecx
char *result; // eax
int i_2; // esi
unsigned int i; // ebx
char *src_1; // [esp+10h] [ebp-4h]
src_1 = src; /*0xffe24da7*/
v4 = (*(_DWORD *)(a1 + 20) >> 3) & 0x3F; /*0xffe24db3*/
v5 = *(_DWORD *)(a1 + 20) + 8 * i_1; /*0xffe24db6*/
*(_DWORD *)(a1 + 20) = v5; /*0xffe24dbe*/
if ( v5 < 8 * i_1 ) /*0xffe24dc3*/
++*(_DWORD *)(a1 + 24); /*0xffe24dc5*/
*(_DWORD *)(a1 + 24) += i_1 >> 29; /*0xffe24dcd*/
result = (char *)(v4 + i_1); /*0xffe24dd0*/
if ( v4 + i_1 <= 0x3F ) /*0xffe24dd6*/
{
i_2 = 0; /*0xffe24e18*/
}
else
{
i_2 = 64 - v4; /*0xffe24ddb*/
sub_FFE238C8((char *)(v4 + a1 + 28), src, 64 - v4); /*0xffe24de5*/
result = (char *)sub_FFE23B37((_DWORD *)a1, (char *)(a1 + 28)); /*0xffe24df0*/
for ( i = i_2 + 63; ; i += 64 ) /*0xffe24df5*/
{
src = src_1; /*0xffe24e0c*/
if ( i >= i_1 ) /*0xffe24e12*/
break; /*0xffe24e12*/
result = (char *)sub_FFE23B37((_DWORD *)a1, &src_1[i - 63]); /*0xffe24e01*/
i_2 += 64; /*0xffe24e06*/
}
v4 = 0; /*0xffe24e14*/
}
if ( i_1 != i_2 ) /*0xffe24e1a*/
return sub_FFE238C8((char *)(v4 + a1 + 28), &src[i_2], i_1 - i_2); /*0xffe24e26*/
return result; /*0xffe24e2c*/
}
// ============================================================================
// 0xffe24e32 HashUpdateSha1
// ============================================================================
void *__fastcall HashUpdateSha1(int src, _DWORD *buf)
{
unsigned int n0x14; // edi
unsigned int i; // edx
char src_1[8]; // [esp+10h] [ebp-8h] BYREF
n0x14 = 0; /*0xffe24e38*/
for ( i = 0; i < 8; ++i )
src_1[i] = *(_DWORD *)((char *)buf + (i < 4 ? 4 : 0) + 20) >> (8 * (3 - (i & 3)));
sub_FFE24D9C((int)buf, ::src, 1u); /*0xffe24e6e*/
while ( (buf[5] & 0x1F8) != 0x1C0 ) /*0xffe24e93*/
sub_FFE24D9C((int)buf, src_0, 1u); /*0xffe24e7f*/
sub_FFE24D9C((int)buf, src_1, 8u); /*0xffe24e9b*/
do /*0xffe24ebf*/
{
*(_BYTE *)(n0x14 + src) = buf[n0x14 >> 2] >> (8 * (3 - (n0x14 & 3))); /*0xffe24eb8*/
++n0x14; /*0xffe24ebb*/
}
while ( n0x14 < 0x14 ); /*0xffe24ebf*/
sub_FFE23937(buf + 7, 0x40u); /*0xffe24ec7*/
sub_FFE23937(buf, 0x14u); /*0xffe24ed1*/
sub_FFE23937(buf + 5, 8u); /*0xffe24edb*/
return sub_FFE23937(src_1, 8u); /*0xffe24eec*/
}
// ============================================================================
// 0xffe24ef3 HashUpdateSha384
// ============================================================================
void *__fastcall HashUpdateSha384(int a1, unsigned __int8 **p_src, int p_n256, _BYTE *src)
{
int v6; // edi
_BYTE buf[112]; // [esp+10h] [ebp-70h] BYREF
sub_FFE27758(buf); /*0xffe24f03*/
if ( a1 ) /*0xffe24f0a*/
{
v6 = p_n256 - (_DWORD)p_src; /*0xffe24f0f*/
do /*0xffe24f25*/
{
sub_FFE2779B((int)buf, *p_src, *(unsigned int *)((char *)p_src + v6)); /*0xffe24f19*/
++p_src; /*0xffe24f1e*/
--a1; /*0xffe24f22*/
}
while ( a1 ); /*0xffe24f25*/
}
sub_FFE2783B(buf, src); /*0xffe24f2d*/
return sub_FFE23937(buf, 0x70u); /*0xffe24f3d*/
}
// ============================================================================
// 0xffe24f44 Tpm20HashAll
// ============================================================================
int __fastcall Tpm20HashAll(_DWORD *buf, unsigned __int8 *src)
{
int v2; // ebx
int v3; // edi
int v4; // edx
int v5; // ebp
int v6; // edx
int v7; // edi
int v8; // edx
int v9; // ebx
int v10; // edx
int v11; // edx
int v12; // edx
int v13; // edx
int v14; // edx
int v15; // edx
int v16; // edx
int v17; // edx
int v18; // edx
int v19; // edx
int v20; // edx
int v21; // edx
int v22; // edx
int v23; // edx
int v24; // edx
int v25; // edx
int v26; // edx
int v27; // edx
int v28; // edx
int v29; // edx
int v30; // edx
int v31; // edx
int v32; // edx
int v33; // edx
int v34; // edx
int v35; // edx
int v36; // edx
int v37; // edx
int v38; // edx
int v39; // edx
int v40; // edx
int v41; // edx
int v42; // edx
int v43; // edx
int v44; // edx
int v45; // edx
int v46; // edx
int v47; // edx
int v48; // edx
int v49; // edx
int v50; // edi
int v51; // edx
int v52; // ebx
int v53; // edx
int v54; // ebp
int v55; // edx
int v56; // edx
int v57; // edx
int v58; // ebx
int v59; // edx
int v60; // edx
unsigned int v61; // edi
int v62; // edx
unsigned int v63; // ebp
int v64; // edx
int v65; // ebx
int v66; // edx
int v67; // esi
int v68; // edx
int v69; // edx
int v70; // edx
int v71; // edx
unsigned int v72; // esi
int v73; // edx
unsigned int v74; // edi
int v75; // edx
unsigned int v76; // esi
int v77; // edx
unsigned int v78; // edi
int v79; // edx
int v80; // ebp
unsigned int v81; // esi
int v82; // edx
int v83; // ebx
int v84; // edx
int v85; // edi
int v86; // esi
int v87; // ecx
int v88; // eax
int v90; // [esp+10h] [ebp-7Ch]
int v91; // [esp+10h] [ebp-7Ch]
unsigned int v92; // [esp+10h] [ebp-7Ch]
int v93; // [esp+10h] [ebp-7Ch]
int v94; // [esp+10h] [ebp-7Ch]
int v95; // [esp+10h] [ebp-7Ch]
int v96; // [esp+10h] [ebp-7Ch]
int v97; // [esp+10h] [ebp-7Ch]
int v98; // [esp+14h] [ebp-78h]
int v99; // [esp+14h] [ebp-78h]
int v100; // [esp+14h] [ebp-78h]
int v101; // [esp+14h] [ebp-78h]
unsigned int v102; // [esp+14h] [ebp-78h]
int v103; // [esp+14h] [ebp-78h]
int v104; // [esp+14h] [ebp-78h]
int v105; // [esp+14h] [ebp-78h]
int v106; // [esp+18h] [ebp-74h]
int v107; // [esp+18h] [ebp-74h]
int v108; // [esp+18h] [ebp-74h]
int v109; // [esp+18h] [ebp-74h]
int v110; // [esp+18h] [ebp-74h]
int v111; // [esp+18h] [ebp-74h]
int v112; // [esp+18h] [ebp-74h]
int v113; // [esp+18h] [ebp-74h]
int v114; // [esp+18h] [ebp-74h]
int v115; // [esp+18h] [ebp-74h]
int v116; // [esp+18h] [ebp-74h]
int v117; // [esp+18h] [ebp-74h]
int v118; // [esp+1Ch] [ebp-70h]
int v119; // [esp+1Ch] [ebp-70h]
int v120; // [esp+1Ch] [ebp-70h]
int v121; // [esp+1Ch] [ebp-70h]
int v122; // [esp+1Ch] [ebp-70h]
int v123; // [esp+1Ch] [ebp-70h]
int v124; // [esp+1Ch] [ebp-70h]
int v125; // [esp+1Ch] [ebp-70h]
int v126; // [esp+1Ch] [ebp-70h]
int v127; // [esp+1Ch] [ebp-70h]
int v128; // [esp+1Ch] [ebp-70h]
int v129; // [esp+1Ch] [ebp-70h]
int v130; // [esp+1Ch] [ebp-70h]
int v131; // [esp+1Ch] [ebp-70h]
int v132; // [esp+20h] [ebp-6Ch]
int v133; // [esp+20h] [ebp-6Ch]
int v134; // [esp+20h] [ebp-6Ch]
int v135; // [esp+20h] [ebp-6Ch]
int v136; // [esp+20h] [ebp-6Ch]
int v137; // [esp+20h] [ebp-6Ch]
int v138; // [esp+20h] [ebp-6Ch]
int v139; // [esp+20h] [ebp-6Ch]
int v140; // [esp+20h] [ebp-6Ch]
int v141; // [esp+20h] [ebp-6Ch]
int v142; // [esp+24h] [ebp-68h]
int v143; // [esp+24h] [ebp-68h]
int v144; // [esp+24h] [ebp-68h]
int v145; // [esp+24h] [ebp-68h]
int v146; // [esp+24h] [ebp-68h]
int v147; // [esp+24h] [ebp-68h]
int v148; // [esp+24h] [ebp-68h]
int v149; // [esp+24h] [ebp-68h]
int v150; // [esp+24h] [ebp-68h]
int v151; // [esp+24h] [ebp-68h]
int v152; // [esp+24h] [ebp-68h]
int v153; // [esp+24h] [ebp-68h]
int v154; // [esp+28h] [ebp-64h]
int v155; // [esp+28h] [ebp-64h]
int v156; // [esp+28h] [ebp-64h]
int v157; // [esp+28h] [ebp-64h]
int v158; // [esp+28h] [ebp-64h]
int v159; // [esp+28h] [ebp-64h]
int v160; // [esp+28h] [ebp-64h]
int v161; // [esp+28h] [ebp-64h]
int v162; // [esp+28h] [ebp-64h]
int v163; // [esp+28h] [ebp-64h]
int v164; // [esp+28h] [ebp-64h]
int v165; // [esp+28h] [ebp-64h]
int v166; // [esp+2Ch] [ebp-60h]
int v167; // [esp+2Ch] [ebp-60h]
int v168; // [esp+2Ch] [ebp-60h]
int v169; // [esp+2Ch] [ebp-60h]
int v170; // [esp+2Ch] [ebp-60h]
int v171; // [esp+2Ch] [ebp-60h]
int v172; // [esp+2Ch] [ebp-60h]
int v173; // [esp+2Ch] [ebp-60h]
int v174; // [esp+2Ch] [ebp-60h]
int v175; // [esp+2Ch] [ebp-60h]
int v176; // [esp+2Ch] [ebp-60h]
int v177; // [esp+30h] [ebp-5Ch]
int v178; // [esp+30h] [ebp-5Ch]
int v179; // [esp+30h] [ebp-5Ch]
int v180; // [esp+30h] [ebp-5Ch]
int v181; // [esp+30h] [ebp-5Ch]
int v182; // [esp+30h] [ebp-5Ch]
int v183; // [esp+30h] [ebp-5Ch]
int v184; // [esp+30h] [ebp-5Ch]
int v185; // [esp+30h] [ebp-5Ch]
int v186; // [esp+30h] [ebp-5Ch]
int v187; // [esp+30h] [ebp-5Ch]
int v188; // [esp+30h] [ebp-5Ch]
int v189; // [esp+30h] [ebp-5Ch]
int v190; // [esp+30h] [ebp-5Ch]
int v192; // [esp+38h] [ebp-54h]
int v193; // [esp+38h] [ebp-54h]
int v194; // [esp+38h] [ebp-54h]
int v195; // [esp+38h] [ebp-54h]
int v196; // [esp+38h] [ebp-54h]
int v197; // [esp+38h] [ebp-54h]
int v198; // [esp+38h] [ebp-54h]
int v199; // [esp+38h] [ebp-54h]
int v200; // [esp+38h] [ebp-54h]
int v201; // [esp+38h] [ebp-54h]
int v202; // [esp+38h] [ebp-54h]
unsigned int v203; // [esp+3Ch] [ebp-50h]
int v204; // [esp+3Ch] [ebp-50h]
int v205; // [esp+3Ch] [ebp-50h]
int v206; // [esp+3Ch] [ebp-50h]
unsigned int v207; // [esp+40h] [ebp-4Ch]
unsigned int v208; // [esp+40h] [ebp-4Ch]
unsigned int v209; // [esp+44h] [ebp-48h]
unsigned int v210; // [esp+44h] [ebp-48h]
unsigned int v211; // [esp+48h] [ebp-44h]
unsigned int v212; // [esp+48h] [ebp-44h]
unsigned int v213; // [esp+48h] [ebp-44h]
unsigned int v214; // [esp+4Ch] [ebp-40h]
unsigned int v215; // [esp+4Ch] [ebp-40h]
unsigned int v216; // [esp+4Ch] [ebp-40h]
unsigned int v217; // [esp+50h] [ebp-3Ch]
unsigned int v218; // [esp+50h] [ebp-3Ch]
unsigned int v219; // [esp+50h] [ebp-3Ch]
unsigned int v220; // [esp+54h] [ebp-38h]
unsigned int v221; // [esp+54h] [ebp-38h]
unsigned int v222; // [esp+54h] [ebp-38h]
unsigned int v223; // [esp+58h] [ebp-34h]
unsigned int v224; // [esp+58h] [ebp-34h]
unsigned int v225; // [esp+58h] [ebp-34h]
unsigned int v226; // [esp+5Ch] [ebp-30h]
unsigned int v227; // [esp+5Ch] [ebp-30h]
unsigned int v228; // [esp+60h] [ebp-2Ch]
unsigned int v229; // [esp+60h] [ebp-2Ch]
int v230; // [esp+64h] [ebp-28h]
unsigned int v231; // [esp+64h] [ebp-28h]
unsigned int v232; // [esp+64h] [ebp-28h]
int v233; // [esp+68h] [ebp-24h]
int v234; // [esp+68h] [ebp-24h]
unsigned int v235; // [esp+68h] [ebp-24h]
unsigned int v236; // [esp+68h] [ebp-24h]
unsigned int v237; // [esp+68h] [ebp-24h]
unsigned int v238; // [esp+6Ch] [ebp-20h]
unsigned int v239; // [esp+6Ch] [ebp-20h]
unsigned int v240; // [esp+6Ch] [ebp-20h]
unsigned int v241; // [esp+6Ch] [ebp-20h]
unsigned int v242; // [esp+70h] [ebp-1Ch]
unsigned int v243; // [esp+70h] [ebp-1Ch]
unsigned int v244; // [esp+70h] [ebp-1Ch]
unsigned int v245; // [esp+74h] [ebp-18h]
unsigned int v246; // [esp+74h] [ebp-18h]
unsigned int v247; // [esp+74h] [ebp-18h]
unsigned int v248; // [esp+78h] [ebp-14h]
unsigned int v249; // [esp+78h] [ebp-14h]
unsigned int v250; // [esp+78h] [ebp-14h]
unsigned int v251; // [esp+7Ch] [ebp-10h]
unsigned int v252; // [esp+7Ch] [ebp-10h]
unsigned int v253; // [esp+7Ch] [ebp-10h]
unsigned int v254; // [esp+80h] [ebp-Ch]
unsigned int v255; // [esp+80h] [ebp-Ch]
unsigned int v256; // [esp+80h] [ebp-Ch]
unsigned int v257; // [esp+84h] [ebp-8h]
int v258; // [esp+84h] [ebp-8h]
unsigned int v259; // [esp+88h] [ebp-4h]
unsigned int v260; // [esp+88h] [ebp-4h]
v230 = src[3] | ((src[2] | ((src[1] | (*src << 8)) << 8)) << 8); /*0xffe24f79*/
v254 = src[7] | ((src[6] | ((src[5] | (src[4] << 8)) << 8)) << 8); /*0xffe24f93*/
v251 = src[11] | ((src[10] | ((src[9] | (src[8] << 8)) << 8)) << 8); /*0xffe24fb6*/
v248 = src[15] | ((src[14] | ((src[13] | (src[12] << 8)) << 8)) << 8); /*0xffe24fd9*/
v245 = src[19] | ((src[18] | ((src[17] | (src[16] << 8)) << 8)) << 8); /*0xffe24ffc*/
v242 = src[23] | ((src[22] | ((src[21] | (src[20] << 8)) << 8)) << 8); /*0xffe2501f*/
v238 = src[27] | ((src[26] | ((src[25] | (src[24] << 8)) << 8)) << 8); /*0xffe2503f*/
v257 = src[31] | ((src[30] | ((src[29] | (src[28] << 8)) << 8)) << 8); /*0xffe25066*/
v259 = src[35] | ((src[34] | ((src[33] | (src[32] << 8)) << 8)) << 8); /*0xffe2508c*/
v209 = src[39] | ((src[38] | ((src[37] | (src[36] << 8)) << 8)) << 8); /*0xffe250b2*/
v211 = src[43] | ((src[42] | ((src[41] | (src[40] << 8)) << 8)) << 8); /*0xffe250d5*/
v214 = src[47] | ((src[46] | ((src[45] | (src[44] << 8)) << 8)) << 8); /*0xffe250f8*/
v217 = src[51] | ((src[50] | ((src[49] | (src[48] << 8)) << 8)) << 8); /*0xffe2511b*/
v220 = src[55] | ((src[54] | ((src[53] | (src[52] << 8)) << 8)) << 8); /*0xffe2513e*/
v203 = src[59] | ((src[58] | ((src[57] | (src[56] << 8)) << 8)) << 8); /*0xffe25165*/
v2 = buf[3]; /*0xffe25191*/
v3 = buf[4]; /*0xffe25194*/
v207 = src[63] | ((src[62] | ((src[61] | (src[60] << 8)) << 8)) << 8); /*0xffe25197*/
v177 = buf[2]; /*0xffe251a6*/
v4 = buf[9] /*0xffe251ce*/
+ (__ROR4__(buf[6], 6) ^ __ROL4__(buf[6], 7) ^ __ROR4__(buf[6], 11))
+ (buf[8] ^ buf[6] & (buf[7] ^ buf[8]))
+ v230
+ 1116352408;
v233 = v4 + buf[5]; /*0xffe251e1*/
v5 = v4 + (__ROR4__(v177, 2) ^ __ROL4__(v177, 10) ^ __ROR4__(v177, 13)) + (v177 & v2 | v3 & (v177 | v2)); /*0xffe25200*/
v6 = v254 /*0xffe25246*/
+ (__ROR4__(v233, 6) ^ __ROL4__(v233, 7) ^ __ROR4__(v233, 11))
+ (buf[7] ^ v233 & (buf[6] ^ buf[7]))
+ buf[8]
+ 1899447441;
v7 = v6 + v3; /*0xffe2524d*/
v154 = v6 + (__ROR4__(v5, 2) ^ __ROL4__(v5, 10) ^ __ROR4__(v5, 13)) + (v177 & v5 | v2 & (v177 | v5)); /*0xffe25272*/
v8 = v251 /*0xffe252a9*/
+ (__ROR4__(v7, 6) ^ __ROL4__(v7, 7) ^ __ROR4__(v7, 11))
+ (buf[6] ^ v7 & (v233 ^ buf[6]))
+ buf[7]
- 1245643825;
v9 = v8 + v2; /*0xffe252b1*/
v142 = v8 + (__ROR4__(v154, 2) ^ __ROL4__(v154, 10) ^ __ROR4__(v154, 13)) + (v154 & v5 | v177 & (v154 | v5)); /*0xffe252e4*/
v10 = v248 + (__ROR4__(v9, 6) ^ __ROL4__(v9, 7) ^ __ROR4__(v9, 11)) + (v233 ^ v9 & (v7 ^ v233)) + buf[6] - 373957723; /*0xffe25310*/
v178 = v10 + v177; /*0xffe25316*/
v118 = v10 + (__ROR4__(v142, 2) ^ __ROL4__(v142, 10) ^ __ROR4__(v142, 13)) + (v142 & v154 | v5 & (v142 | v154)); /*0xffe2534e*/
v11 = v245 + (__ROR4__(v178, 6) ^ __ROL4__(v178, 7) ^ __ROR4__(v178, 11)) + (v7 ^ v178 & (v9 ^ v7)) + v233 + 961987163; /*0xffe2537e*/
v234 = v11 + v5; /*0xffe2538c*/
v98 = v11 + (__ROR4__(v118, 2) ^ __ROL4__(v118, 10) ^ __ROR4__(v118, 13)) + (v118 & v142 | v154 & (v118 | v142)); /*0xffe253bd*/
v12 = v242 /*0xffe253e8*/
+ (__ROR4__(v11 + v5, 6) ^ __ROL4__(v11 + v5, 7) ^ __ROR4__(v11 + v5, 11))
+ (v9 ^ (v11 + v5) & (v178 ^ v9))
+ v7
+ 1508970993;
v155 = v12 + v154; /*0xffe253f6*/
v106 = v12 + (__ROR4__(v98, 2) ^ __ROL4__(v98, 10) ^ __ROR4__(v98, 13)) + (v98 & v118 | v142 & (v98 | v118)); /*0xffe25427*/
v13 = v238 /*0xffe25454*/
+ (__ROR4__(v155, 6) ^ __ROL4__(v155, 7) ^ __ROR4__(v155, 11))
+ (v178 ^ v155 & (v178 ^ v234))
+ v9
- 1841331548;
v143 = v13 + v142; /*0xffe25462*/
v90 = v13 + (__ROR4__(v106, 2) ^ __ROL4__(v106, 10) ^ __ROR4__(v106, 13)) + (v106 & v98 | v118 & (v106 | v98)); /*0xffe2548d*/
v14 = v257 /*0xffe254bd*/
+ (__ROR4__(v143, 6) ^ __ROL4__(v143, 7) ^ __ROR4__(v143, 11))
+ (v234 ^ v143 & (v155 ^ v234))
+ v178
- 1424204075;
v119 = v14 + v118; /*0xffe254cf*/
v132 = v14 + (__ROR4__(v90, 2) ^ __ROL4__(v90, 10) ^ __ROR4__(v90, 13)) + (v90 & v106 | v98 & (v90 | v106)); /*0xffe254f6*/
v15 = v259 /*0xffe2552c*/
+ (__ROR4__(v119, 6) ^ __ROL4__(v119, 7) ^ __ROR4__(v119, 11))
+ (v155 ^ v119 & (v143 ^ v155))
+ v234
- 670586216;
v99 = v15 + v98; /*0xffe2553e*/
v192 = v15 + (__ROR4__(v132, 2) ^ __ROL4__(v132, 10) ^ __ROR4__(v132, 13)) + (v132 & v90 | v106 & (v132 | v90)); /*0xffe2556b*/
v16 = v209 /*0xffe25598*/
+ (__ROR4__(v99, 6) ^ __ROL4__(v99, 7) ^ __ROR4__(v99, 11))
+ (v143 ^ v99 & (v119 ^ v143))
+ v155
+ 310598401;
v107 = v16 + v106; /*0xffe255aa*/
v179 = v16 + (__ROR4__(v192, 2) ^ __ROL4__(v192, 10) ^ __ROR4__(v192, 13)) + (v132 & v192 | v90 & (v132 | v192)); /*0xffe255d3*/
v17 = v211 /*0xffe25604*/
+ (__ROR4__(v107, 6) ^ __ROL4__(v107, 7) ^ __ROR4__(v107, 11))
+ (v119 ^ v107 & (v99 ^ v119))
+ v143
+ 607225278;
v91 = v17 + v90; /*0xffe25616*/
v166 = v17 + (__ROR4__(v179, 2) ^ __ROL4__(v179, 10) ^ __ROR4__(v179, 13)) + (v179 & v192 | v132 & (v179 | v192)); /*0xffe25643*/
v18 = v214 /*0xffe25670*/
+ (__ROR4__(v91, 6) ^ __ROL4__(v91, 7) ^ __ROR4__(v91, 11))
+ (v99 ^ v91 & (v107 ^ v99))
+ v119
+ 1426881987;
v133 = v18 + v132; /*0xffe25682*/
v144 = v18 + (__ROR4__(v166, 2) ^ __ROL4__(v166, 10) ^ __ROR4__(v166, 13)) + (v166 & v179 | v192 & (v166 | v179)); /*0xffe256af*/
v19 = v217 /*0xffe256dc*/
+ (__ROR4__(v133, 6) ^ __ROL4__(v133, 7) ^ __ROR4__(v133, 11))
+ (v107 ^ v133 & (v91 ^ v107))
+ v99
+ 1925078388;
v193 = v19 + v192; /*0xffe256ee*/
v120 = v19 + (__ROR4__(v144, 2) ^ __ROL4__(v144, 10) ^ __ROR4__(v144, 13)) + (v144 & v166 | v179 & (v144 | v166)); /*0xffe2571b*/
v20 = v220 /*0xffe25748*/
+ (__ROR4__(v193, 6) ^ __ROL4__(v193, 7) ^ __ROR4__(v193, 11))
+ (v91 ^ v193 & (v133 ^ v91))
+ v107
- 2132889090;
v180 = v20 + v179; /*0xffe2575a*/
v108 = v20 + (__ROR4__(v120, 2) ^ __ROL4__(v120, 10) ^ __ROR4__(v120, 13)) + (v120 & v144 | v166 & (v120 | v144)); /*0xffe25787*/
v21 = v203 /*0xffe257b4*/
+ (__ROR4__(v180, 6) ^ __ROL4__(v180, 7) ^ __ROR4__(v180, 11))
+ (v133 ^ v180 & (v133 ^ v193))
+ v91
- 1680079193;
v167 = v21 + v166; /*0xffe257be*/
v100 = v21 + (__ROR4__(v108, 2) ^ __ROL4__(v108, 10) ^ __ROR4__(v108, 13)) + (v108 & v120 | v144 & (v108 | v120)); /*0xffe257f3*/
v22 = v207 /*0xffe25820*/
+ (__ROR4__(v167, 6) ^ __ROL4__(v167, 7) ^ __ROR4__(v167, 11))
+ (v193 ^ v167 & (v180 ^ v193))
+ v133
- 1046744716;
v145 = v22 + v144; /*0xffe25832*/
v156 = v22 + (__ROR4__(v100, 2) ^ __ROL4__(v100, 10) ^ __ROR4__(v100, 13)) + (v100 & v108 | v120 & (v100 | v108)); /*0xffe25859*/
v92 = v230 /*0xffe258a4*/
+ ((v254 >> 3) ^ __ROR4__(v254, 7) ^ __ROL4__(v254, 14))
+ v209
+ ((v203 >> 10) ^ __ROL4__(v203, 13) ^ __ROL4__(v203, 15));
v23 = v92 /*0xffe258c9*/
+ (__ROR4__(v145, 6) ^ __ROL4__(v145, 7) ^ __ROR4__(v145, 11))
+ (v180 ^ v145 & (v167 ^ v180))
+ v193
- 459576895;
v121 = v23 + v120; /*0xffe258db*/
v194 = v23 + (__ROR4__(v156, 2) ^ __ROL4__(v156, 10) ^ __ROR4__(v156, 13)) + (v156 & v100 | v108 & (v156 | v100)); /*0xffe25902*/
v223 = v211 /*0xffe2594e*/
+ ((v207 >> 10) ^ __ROL4__(v207, 13) ^ __ROL4__(v207, 15))
+ ((v251 >> 3) ^ __ROR4__(v251, 7) ^ __ROL4__(v251, 14))
+ v254;
v24 = v223 /*0xffe25974*/
+ (__ROR4__(v121, 6) ^ __ROL4__(v121, 7) ^ __ROR4__(v121, 11))
+ (v167 ^ v121 & (v145 ^ v167))
+ v180
- 272742522;
v109 = v24 + v108; /*0xffe25986*/
v181 = v24 + (__ROR4__(v194, 2) ^ __ROL4__(v194, 10) ^ __ROR4__(v194, 13)) + (v156 & v194 | v100 & (v156 | v194)); /*0xffe259ad*/
v226 = v214 /*0xffe259f6*/
+ ((v92 >> 10) ^ __ROL4__(v92, 13) ^ __ROL4__(v92, 15))
+ ((v248 >> 3) ^ __ROR4__(v248, 7) ^ __ROL4__(v248, 14))
+ v251;
v25 = v226 /*0xffe25a1c*/
+ (__ROR4__(v109, 6) ^ __ROL4__(v109, 7) ^ __ROR4__(v109, 11))
+ (v145 ^ v109 & (v121 ^ v145))
+ v167
+ 264347078;
v101 = v25 + v100; /*0xffe25a2e*/
v168 = v25 + (__ROR4__(v181, 2) ^ __ROL4__(v181, 10) ^ __ROR4__(v181, 13)) + (v181 & v194 | v156 & (v181 | v194)); /*0xffe25a55*/
v228 = v217 /*0xffe25a9e*/
+ ((v223 >> 10) ^ __ROL4__(v223, 13) ^ __ROL4__(v223, 15))
+ ((v245 >> 3) ^ __ROR4__(v245, 7) ^ __ROL4__(v245, 14))
+ v248;
v26 = v228 /*0xffe25ac4*/
+ (__ROR4__(v101, 6) ^ __ROL4__(v101, 7) ^ __ROR4__(v101, 11))
+ (v121 ^ v101 & (v109 ^ v121))
+ v145
+ 604807628;
v157 = v26 + v156; /*0xffe25ad6*/
v146 = v26 + (__ROR4__(v168, 2) ^ __ROL4__(v168, 10) ^ __ROR4__(v168, 13)) + (v168 & v181 | v194 & (v168 | v181)); /*0xffe25afd*/
v231 = v220 /*0xffe25b47*/
+ ((v226 >> 10) ^ __ROL4__(v226, 13) ^ __ROL4__(v226, 15))
+ ((v242 >> 3) ^ __ROR4__(v242, 7) ^ __ROL4__(v242, 14))
+ v245;
v27 = v231 /*0xffe25b6c*/
+ (__ROR4__(v157, 6) ^ __ROL4__(v157, 7) ^ __ROR4__(v157, 11))
+ (v109 ^ v157 & (v101 ^ v109))
+ v121
+ 770255983;
v195 = v27 + v194; /*0xffe25b7e*/
v134 = v27 + (__ROR4__(v146, 2) ^ __ROL4__(v146, 10) ^ __ROR4__(v146, 13)) + (v146 & v168 | v181 & (v146 | v168)); /*0xffe25ba5*/
v235 = v203 /*0xffe25bee*/
+ ((v228 >> 10) ^ __ROL4__(v228, 13) ^ __ROL4__(v228, 15))
+ ((v238 >> 3) ^ __ROR4__(v238, 7) ^ __ROL4__(v238, 14))
+ v242;
v28 = v235 /*0xffe25c14*/
+ (__ROR4__(v195, 6) ^ __ROL4__(v195, 7) ^ __ROR4__(v195, 11))
+ (v101 ^ v195 & (v157 ^ v101))
+ v109
+ 1249150122;
v182 = v28 + v181; /*0xffe25c26*/
v122 = v28 + (__ROR4__(v134, 2) ^ __ROL4__(v134, 10) ^ __ROR4__(v134, 13)) + (v134 & v146 | v168 & (v134 | v146)); /*0xffe25c4d*/
v239 = v207 /*0xffe25c99*/
+ ((v231 >> 10) ^ __ROL4__(v231, 13) ^ __ROL4__(v231, 15))
+ ((v257 >> 3) ^ __ROR4__(v257, 7) ^ __ROL4__(v257, 14))
+ v238;
v29 = v239 /*0xffe25cbf*/
+ (__ROR4__(v182, 6) ^ __ROL4__(v182, 7) ^ __ROR4__(v182, 11))
+ (v157 ^ v182 & (v157 ^ v195))
+ v101
+ 1555081692;
v169 = v29 + v168; /*0xffe25cd1*/
v110 = v29 + (__ROR4__(v122, 2) ^ __ROL4__(v122, 10) ^ __ROR4__(v122, 13)) + (v122 & v134 | v146 & (v122 | v134)); /*0xffe25cf8*/
v102 = v92 /*0xffe25d47*/
+ ((v235 >> 10) ^ __ROL4__(v235, 13) ^ __ROL4__(v235, 15))
+ ((v259 >> 3) ^ __ROR4__(v259, 7) ^ __ROL4__(v259, 14))
+ v257;
v30 = v102 /*0xffe25d6d*/
+ (__ROR4__(v169, 6) ^ __ROL4__(v169, 7) ^ __ROR4__(v169, 11))
+ (v195 ^ v169 & (v182 ^ v195))
+ v157
+ 1996064986;
v147 = v30 + v146; /*0xffe25d7f*/
v158 = v30 + (__ROR4__(v110, 2) ^ __ROL4__(v110, 10) ^ __ROR4__(v110, 13)) + (v110 & v122 | v134 & (v110 | v122)); /*0xffe25da6*/
v243 = v223 /*0xffe25df3*/
+ ((v239 >> 10) ^ __ROL4__(v239, 13) ^ __ROL4__(v239, 15))
+ ((v209 >> 3) ^ __ROR4__(v209, 7) ^ __ROL4__(v209, 14))
+ v259;
v31 = v243 /*0xffe25e18*/
+ (__ROR4__(v147, 6) ^ __ROL4__(v147, 7) ^ __ROR4__(v147, 11))
+ (v182 ^ v147 & (v169 ^ v182))
+ v195
- 1740746414;
v135 = v31 + v134; /*0xffe25e2a*/
v196 = v31 + (__ROR4__(v158, 2) ^ __ROL4__(v158, 10) ^ __ROR4__(v158, 13)) + (v158 & v110 | v122 & (v158 | v110)); /*0xffe25e51*/
v210 = v209 /*0xffe25e9d*/
+ ((v211 >> 3) ^ __ROR4__(v211, 7) ^ __ROL4__(v211, 14))
+ v226
+ ((v102 >> 10) ^ __ROL4__(v102, 13) ^ __ROL4__(v102, 15));
v32 = v210 /*0xffe25ebe*/
+ (__ROR4__(v135, 6) ^ __ROL4__(v135, 7) ^ __ROR4__(v135, 11))
+ (v169 ^ v135 & (v147 ^ v169))
+ v182
- 1473132947;
v123 = v32 + v122; /*0xffe25ed0*/
v183 = v32 + (__ROR4__(v196, 2) ^ __ROL4__(v196, 10) ^ __ROR4__(v196, 13)) + (v158 & v196 | v110 & (v158 | v196)); /*0xffe25efb*/
v212 = v211 /*0xffe25f43*/
+ ((v214 >> 3) ^ __ROR4__(v214, 7) ^ __ROL4__(v214, 14))
+ v228
+ ((v243 >> 10) ^ __ROL4__(v243, 13) ^ __ROL4__(v243, 15));
v33 = v212 /*0xffe25f64*/
+ (__ROR4__(v123, 6) ^ __ROL4__(v123, 7) ^ __ROR4__(v123, 11))
+ (v147 ^ v123 & (v135 ^ v147))
+ v169
- 1341970488;
v111 = v33 + v110; /*0xffe25f76*/
v170 = v33 + (__ROR4__(v183, 2) ^ __ROL4__(v183, 10) ^ __ROR4__(v183, 13)) + (v183 & v196 | v158 & (v183 | v196)); /*0xffe25f9d*/
v215 = v214 /*0xffe25fe5*/
+ ((v217 >> 3) ^ __ROR4__(v217, 7) ^ __ROL4__(v217, 14))
+ v231
+ ((v210 >> 10) ^ __ROL4__(v210, 13) ^ __ROL4__(v210, 15));
v34 = v215 /*0xffe2600a*/
+ (__ROR4__(v111, 6) ^ __ROL4__(v111, 7) ^ __ROR4__(v111, 11))
+ (v135 ^ v111 & (v123 ^ v135))
+ v147
- 1084653625;
v159 = v34 + v158; /*0xffe2601c*/
v148 = v34 + (__ROR4__(v170, 2) ^ __ROL4__(v170, 10) ^ __ROR4__(v170, 13)) + (v170 & v183 | v196 & (v170 | v183)); /*0xffe26043*/
v218 = v217 /*0xffe2608f*/
+ ((v220 >> 3) ^ __ROR4__(v220, 7) ^ __ROL4__(v220, 14))
+ v235
+ ((v212 >> 10) ^ __ROL4__(v212, 13) ^ __ROL4__(v212, 15));
v35 = v218 /*0xffe260b0*/
+ (__ROR4__(v159, 6) ^ __ROL4__(v159, 7) ^ __ROR4__(v159, 11))
+ (v123 ^ v159 & (v111 ^ v123))
+ v135
- 958395405;
v197 = v35 + v196; /*0xffe260b4*/
v136 = v35 + (__ROR4__(v148, 2) ^ __ROL4__(v148, 10) ^ __ROR4__(v148, 13)) + (v148 & v170 | v183 & (v148 | v170)); /*0xffe260e9*/
v221 = v220 /*0xffe26135*/
+ ((v203 >> 3) ^ __ROR4__(v203, 7) ^ __ROL4__(v203, 14))
+ v239
+ ((v215 >> 10) ^ __ROL4__(v215, 13) ^ __ROL4__(v215, 15));
v36 = v221 /*0xffe26156*/
+ (__ROR4__(v197, 6) ^ __ROL4__(v197, 7) ^ __ROR4__(v197, 11))
+ (v111 ^ v197 & (v159 ^ v111))
+ v123
- 710438585;
v184 = v36 + v183; /*0xffe26168*/
v124 = v36 + (__ROR4__(v136, 2) ^ __ROL4__(v136, 10) ^ __ROR4__(v136, 13)) + (v136 & v148 | v170 & (v136 | v148)); /*0xffe2618f*/
v246 = v203 /*0xffe261db*/
+ ((v207 >> 3) ^ __ROR4__(v207, 7) ^ __ROL4__(v207, 14))
+ v102
+ ((v218 >> 10) ^ __ROL4__(v218, 13) ^ __ROL4__(v218, 15));
v37 = v246 /*0xffe261fc*/
+ (__ROR4__(v184, 6) ^ __ROL4__(v184, 7) ^ __ROR4__(v184, 11))
+ (v159 ^ v184 & (v159 ^ v197))
+ v111
+ 113926993;
v171 = v37 + v170; /*0xffe2620e*/
v112 = v37 + (__ROR4__(v124, 2) ^ __ROL4__(v124, 10) ^ __ROR4__(v124, 13)) + (v124 & v136 | v148 & (v124 | v136)); /*0xffe26235*/
v249 = v207 /*0xffe2627b*/
+ ((v92 >> 3) ^ __ROR4__(v92, 7) ^ __ROL4__(v92, 14))
+ v243
+ ((v221 >> 10) ^ __ROL4__(v221, 13) ^ __ROL4__(v221, 15));
v38 = v249 /*0xffe262a2*/
+ (__ROR4__(v171, 6) ^ __ROL4__(v171, 7) ^ __ROR4__(v171, 11))
+ (v197 ^ v171 & (v184 ^ v197))
+ v159
+ 338241895;
v149 = v38 + v148; /*0xffe262b4*/
v160 = v38 + (__ROR4__(v112, 2) ^ __ROL4__(v112, 10) ^ __ROR4__(v112, 13)) + (v112 & v124 | v136 & (v112 | v124)); /*0xffe262db*/
v252 = v92 /*0xffe26327*/
+ ((v223 >> 3) ^ __ROR4__(v223, 7) ^ __ROL4__(v223, 14))
+ v210
+ ((v246 >> 10) ^ __ROL4__(v246, 13) ^ __ROL4__(v246, 15));
v39 = v252 /*0xffe26348*/
+ (__ROR4__(v149, 6) ^ __ROL4__(v149, 7) ^ __ROR4__(v149, 11))
+ (v184 ^ v149 & (v171 ^ v184))
+ v197
+ 666307205;
v137 = v39 + v136; /*0xffe2635a*/
v198 = v39 + (__ROR4__(v160, 2) ^ __ROL4__(v160, 10) ^ __ROR4__(v160, 13)) + (v160 & v112 | v124 & (v160 | v112)); /*0xffe26381*/
v224 = v223 /*0xffe263cd*/
+ ((v226 >> 3) ^ __ROR4__(v226, 7) ^ __ROL4__(v226, 14))
+ v212
+ ((v249 >> 10) ^ __ROL4__(v249, 13) ^ __ROL4__(v249, 15));
v40 = v224 /*0xffe263ee*/
+ (__ROR4__(v137, 6) ^ __ROL4__(v137, 7) ^ __ROR4__(v137, 11))
+ (v171 ^ v137 & (v149 ^ v171))
+ v184
+ 773529912;
v125 = v40 + v124; /*0xffe26400*/
v185 = v40 + (__ROR4__(v198, 2) ^ __ROL4__(v198, 10) ^ __ROR4__(v198, 13)) + (v160 & v198 | v112 & (v160 | v198)); /*0xffe26427*/
v227 = v226 /*0xffe26473*/
+ ((v228 >> 3) ^ __ROR4__(v228, 7) ^ __ROL4__(v228, 14))
+ v215
+ ((v252 >> 10) ^ __ROL4__(v252, 13) ^ __ROL4__(v252, 15));
v41 = v227 /*0xffe26494*/
+ (__ROR4__(v125, 6) ^ __ROL4__(v125, 7) ^ __ROR4__(v125, 11))
+ (v149 ^ v125 & (v137 ^ v149))
+ v171
+ 1294757372;
v113 = v41 + v112; /*0xffe264a6*/
v172 = v41 + (__ROR4__(v185, 2) ^ __ROL4__(v185, 10) ^ __ROR4__(v185, 13)) + (v185 & v198 | v160 & (v185 | v198)); /*0xffe264cd*/
v229 = v228 /*0xffe26515*/
+ ((v231 >> 3) ^ __ROR4__(v231, 7) ^ __ROL4__(v231, 14))
+ v218
+ ((v224 >> 10) ^ __ROL4__(v224, 13) ^ __ROL4__(v224, 15));
v42 = v229 /*0xffe2653a*/
+ (__ROR4__(v113, 6) ^ __ROL4__(v113, 7) ^ __ROR4__(v113, 11))
+ (v137 ^ v113 & (v125 ^ v137))
+ v149
+ 1396182291;
v161 = v42 + v160; /*0xffe2654c*/
v150 = v42 + (__ROR4__(v172, 2) ^ __ROL4__(v172, 10) ^ __ROR4__(v172, 13)) + (v172 & v185 | v198 & (v172 | v185)); /*0xffe26573*/
v232 = v231 /*0xffe265bf*/
+ ((v235 >> 3) ^ __ROR4__(v235, 7) ^ __ROL4__(v235, 14))
+ v221
+ ((v227 >> 10) ^ __ROL4__(v227, 13) ^ __ROL4__(v227, 15));
v43 = v232 /*0xffe265e0*/
+ (__ROR4__(v161, 6) ^ __ROL4__(v161, 7) ^ __ROR4__(v161, 11))
+ (v125 ^ v161 & (v113 ^ v125))
+ v137
+ 1695183700;
v199 = v43 + v198; /*0xffe265f2*/
v138 = v43 + (__ROR4__(v150, 2) ^ __ROL4__(v150, 10) ^ __ROR4__(v150, 13)) + (v150 & v172 | v185 & (v150 | v172)); /*0xffe26619*/
v236 = v235 /*0xffe26665*/
+ ((v239 >> 3) ^ __ROR4__(v239, 7) ^ __ROL4__(v239, 14))
+ v246
+ ((v229 >> 10) ^ __ROL4__(v229, 13) ^ __ROL4__(v229, 15));
v44 = v236 /*0xffe26686*/
+ (__ROR4__(v199, 6) ^ __ROL4__(v199, 7) ^ __ROR4__(v199, 11))
+ (v113 ^ v199 & (v161 ^ v113))
+ v125
+ 1986661051;
v186 = v44 + v185; /*0xffe26698*/
v126 = v44 + (__ROR4__(v138, 2) ^ __ROL4__(v138, 10) ^ __ROR4__(v138, 13)) + (v138 & v150 | v172 & (v138 | v150)); /*0xffe266bf*/
v240 = v239 /*0xffe2670b*/
+ ((v102 >> 3) ^ __ROR4__(v102, 7) ^ __ROL4__(v102, 14))
+ v249
+ ((v232 >> 10) ^ __ROL4__(v232, 13) ^ __ROL4__(v232, 15));
v45 = v240 /*0xffe2672c*/
+ (__ROR4__(v186, 6) ^ __ROL4__(v186, 7) ^ __ROR4__(v186, 11))
+ (v161 ^ v186 & (v161 ^ v199))
+ v113
- 2117940946;
v173 = v45 + v172; /*0xffe2673e*/
v93 = v45 + (__ROR4__(v126, 2) ^ __ROL4__(v126, 10) ^ __ROR4__(v126, 13)) + (v126 & v138 | v150 & (v126 | v138)); /*0xffe26765*/
v255 = v102 /*0xffe267b1*/
+ ((v243 >> 3) ^ __ROR4__(v243, 7) ^ __ROL4__(v243, 14))
+ v252
+ ((v236 >> 10) ^ __ROL4__(v236, 13) ^ __ROL4__(v236, 15));
v46 = v255 /*0xffe267d5*/
+ (__ROR4__(v173, 6) ^ __ROL4__(v173, 7) ^ __ROR4__(v173, 11))
+ (v199 ^ v173 & (v186 ^ v199))
+ v161
- 1838011259;
v151 = v46 + v150; /*0xffe267e7*/
v103 = v46 + (__ROR4__(v93, 2) ^ __ROL4__(v93, 10) ^ __ROR4__(v93, 13)) + (v93 & v126 | v138 & (v93 | v126)); /*0xffe2680e*/
v208 = v243 /*0xffe2685a*/
+ ((v210 >> 3) ^ __ROR4__(v210, 7) ^ __ROL4__(v210, 14))
+ v224
+ ((v240 >> 10) ^ __ROL4__(v240, 13) ^ __ROL4__(v240, 15));
v47 = v208 /*0xffe2687b*/
+ (__ROR4__(v151, 6) ^ __ROL4__(v151, 7) ^ __ROR4__(v151, 11))
+ (v186 ^ v151 & (v173 ^ v186))
+ v199
- 1564481375;
v139 = v47 + v138; /*0xffe2688d*/
v204 = v47 + (__ROR4__(v103, 2) ^ __ROL4__(v103, 10) ^ __ROR4__(v103, 13)) + (v103 & v93 | v126 & (v103 | v93)); /*0xffe268b4*/
v244 = v210 /*0xffe26903*/
+ ((v212 >> 3) ^ __ROR4__(v212, 7) ^ __ROL4__(v212, 14))
+ v227
+ ((v255 >> 10) ^ __ROL4__(v255, 13) ^ __ROL4__(v255, 15));
v48 = v244 /*0xffe26924*/
+ (__ROR4__(v139, 6) ^ __ROL4__(v139, 7) ^ __ROR4__(v139, 11))
+ (v173 ^ v139 & (v151 ^ v173))
+ v186
- 1474664885;
v127 = v48 + v126; /*0xffe26936*/
v114 = v48 + (__ROR4__(v204, 2) ^ __ROL4__(v204, 10) ^ __ROR4__(v204, 13)) + (v103 & v204 | v93 & (v103 | v204)); /*0xffe2695d*/
v213 = v212 /*0xffe269a0*/
+ ((v215 >> 3) ^ __ROR4__(v215, 7) ^ __ROL4__(v215, 14))
+ v229
+ ((v208 >> 10) ^ __ROL4__(v208, 13) ^ __ROL4__(v208, 15));
v49 = v213 /*0xffe269ca*/
+ (__ROR4__(v127, 6) ^ __ROL4__(v127, 7) ^ __ROR4__(v127, 11))
+ (v151 ^ v127 & (v139 ^ v151))
+ v173
- 1035236496;
v50 = v49 + v93; /*0xffe269d2*/
v162 = v49 + (__ROR4__(v114, 2) ^ __ROL4__(v114, 10) ^ __ROR4__(v114, 13)) + (v114 & v204 | v103 & (v114 | v204)); /*0xffe269ff*/
v216 = v215 /*0xffe26a4b*/
+ ((v218 >> 3) ^ __ROR4__(v218, 7) ^ __ROL4__(v218, 14))
+ v232
+ ((v244 >> 10) ^ __ROL4__(v244, 13) ^ __ROL4__(v244, 15));
v51 = v216 /*0xffe26a6c*/
+ (__ROR4__(v49 + v93, 6) ^ __ROL4__(v50, 7) ^ __ROR4__(v50, 11))
+ (v139 ^ v50 & (v127 ^ v139))
+ v151
- 949202525;
v52 = v51 + v103; /*0xffe26a74*/
v200 = v51 + (__ROR4__(v162, 2) ^ __ROL4__(v162, 10) ^ __ROR4__(v162, 13)) + (v162 & v114 | v204 & (v162 | v114)); /*0xffe26aa1*/
v219 = v218 /*0xffe26aed*/
+ ((v221 >> 3) ^ __ROR4__(v221, 7) ^ __ROL4__(v221, 14))
+ v236
+ ((v213 >> 10) ^ __ROL4__(v213, 13) ^ __ROL4__(v213, 15));
v53 = v219 /*0xffe26b0e*/
+ (__ROR4__(v51 + v103, 6) ^ __ROL4__(v52, 7) ^ __ROR4__(v52, 11))
+ (v127 ^ v52 & (v50 ^ v127))
+ v139
- 778901479;
v54 = v53 + v204; /*0xffe26b16*/
v174 = v53 + (__ROR4__(v200, 2) ^ __ROL4__(v200, 10) ^ __ROR4__(v200, 13)) + (v200 & v162 | v114 & (v200 | v162)); /*0xffe26b43*/
v222 = v221 /*0xffe26b8b*/
+ ((v246 >> 3) ^ __ROR4__(v246, 7) ^ __ROL4__(v246, 14))
+ v240
+ ((v216 >> 10) ^ __ROL4__(v216, 13) ^ __ROL4__(v216, 15));
v55 = v222 /*0xffe26bac*/
+ (__ROR4__(v53 + v204, 6) ^ __ROL4__(v54, 7) ^ __ROR4__(v54, 11))
+ (v50 ^ v54 & (v52 ^ v50))
+ v127
- 694614492;
v115 = v55 + v114; /*0xffe26bb4*/
v128 = v55 + (__ROR4__(v174, 2) ^ __ROL4__(v174, 10) ^ __ROR4__(v174, 13)) + (v174 & v200 | v162 & (v174 | v200)); /*0xffe26be3*/
v247 = v246 /*0xffe26c32*/
+ ((v249 >> 3) ^ __ROR4__(v249, 7) ^ __ROL4__(v249, 14))
+ v255
+ ((v219 >> 10) ^ __ROL4__(v219, 13) ^ __ROL4__(v219, 15));
v56 = v247 /*0xffe26c4f*/
+ (__ROR4__(v115, 6) ^ __ROL4__(v115, 7) ^ __ROR4__(v115, 11))
+ (v52 ^ v115 & (v52 ^ v54))
+ v50
- 200395387;
v163 = v56 + v162; /*0xffe26c5d*/
v94 = v56 + (__ROR4__(v128, 2) ^ __ROL4__(v128, 10) ^ __ROR4__(v128, 13)) + (v128 & v174 | v200 & (v128 | v174)); /*0xffe26c8c*/
v250 = v249 /*0xffe26cd4*/
+ ((v252 >> 3) ^ __ROR4__(v252, 7) ^ __ROL4__(v252, 14))
+ v208
+ ((v222 >> 10) ^ __ROL4__(v222, 13) ^ __ROL4__(v222, 15));
v57 = v250 /*0xffe26cf7*/
+ (__ROR4__(v163, 6) ^ __ROL4__(v163, 7) ^ __ROR4__(v163, 11))
+ (v54 ^ v163 & (v115 ^ v54))
+ v52
+ 275423344;
v58 = v57 + v200; /*0xffe26cff*/
v187 = v57 + (__ROR4__(v94, 2) ^ __ROL4__(v94, 10) ^ __ROR4__(v94, 13)) + (v94 & v128 | v174 & (v94 | v128)); /*0xffe26d2c*/
v260 = v252 /*0xffe26d78*/
+ ((v224 >> 3) ^ __ROR4__(v224, 7) ^ __ROL4__(v224, 14))
+ v244
+ ((v247 >> 10) ^ __ROL4__(v247, 13) ^ __ROL4__(v247, 15));
v59 = v260 /*0xffe26da0*/
+ (__ROR4__(v57 + v200, 6) ^ __ROL4__(v58, 7) ^ __ROR4__(v58, 11))
+ (v115 ^ v58 & (v163 ^ v115))
+ v54
+ 430227734;
v175 = v59 + v174; /*0xffe26db0*/
v104 = v59 + (__ROR4__(v187, 2) ^ __ROL4__(v187, 10) ^ __ROR4__(v187, 13)) + (v187 & v94 | v128 & (v187 | v94)); /*0xffe26dd7*/
v225 = v224 /*0xffe26e0f*/
+ v213
+ ((v250 >> 10) ^ __ROL4__(v250, 13) ^ __ROL4__(v250, 15))
+ (__ROR4__(v227, 7) ^ __ROL4__(v227, 14) ^ (v227 >> 3));
v60 = v225 /*0xffe26e42*/
+ (__ROR4__(v175, 6) ^ __ROL4__(v175, 7) ^ __ROR4__(v175, 11))
+ (v163 ^ v175 & (v58 ^ v163))
+ v115
+ 506948616;
v129 = v60 + v128; /*0xffe26e47*/
v140 = v60 + (__ROR4__(v104, 2) ^ __ROL4__(v104, 10) ^ __ROR4__(v104, 13)) + (v187 & v104 | v94 & (v187 | v104)); /*0xffe26e80*/
v61 = v227 /*0xffe26eb4*/
+ v216
+ ((v260 >> 10) ^ __ROL4__(v260, 13) ^ __ROL4__(v260, 15))
+ (__ROR4__(v229, 7) ^ __ROL4__(v229, 14) ^ (v229 >> 3));
v62 = v61 /*0xffe26ee5*/
+ (__ROR4__(v129, 6) ^ __ROL4__(v129, 7) ^ __ROR4__(v129, 11))
+ (v58 ^ v129 & (v175 ^ v58))
+ v163
+ 659060556;
v95 = v62 + v94; /*0xffe26ee9*/
v116 = v62 + (__ROR4__(v140, 2) ^ __ROL4__(v140, 10) ^ __ROR4__(v140, 13)) + (v140 & v104 | v187 & (v140 | v104)); /*0xffe26f28*/
v63 = v229 /*0xffe26f52*/
+ v219
+ ((v225 >> 10) ^ __ROL4__(v225, 13) ^ __ROL4__(v225, 15))
+ (__ROR4__(v232, 7) ^ __ROL4__(v232, 14) ^ (v232 >> 3));
v64 = v63 + (__ROR4__(v95, 6) ^ __ROL4__(v95, 7) ^ __ROR4__(v95, 11)) + (v175 ^ v95 & (v129 ^ v175)) + v58 + 883997877; /*0xffe26f85*/
v188 = v64 + v187; /*0xffe26f89*/
v152 = v64 + (__ROR4__(v116, 2) ^ __ROL4__(v116, 10) ^ __ROR4__(v116, 13)) + (v116 & v140 | v104 & (v116 | v140)); /*0xffe26fc0*/
v65 = v222 /*0xffe26fe4*/
+ ((v61 >> 10) ^ __ROL4__(v61, 13) ^ __ROL4__(v61, 15))
+ (__ROR4__(v236, 7) ^ __ROL4__(v236, 14) ^ (v236 >> 3));
v66 = v232 /*0xffe27024*/
+ v65
+ (__ROR4__(v188, 6) ^ __ROL4__(v188, 7) ^ __ROR4__(v188, 11))
+ (v129 ^ v188 & (v95 ^ v129))
+ v175
+ 958139571;
v105 = v66 + v104; /*0xffe2702a*/
v67 = v66 + (__ROR4__(v152, 2) ^ __ROL4__(v152, 10) ^ __ROR4__(v152, 13)) + (v152 & v116 | v140 & (v152 | v116)); /*0xffe27062*/
v253 = v236 /*0xffe270a1*/
+ ((v240 >> 3) ^ __ROR4__(v240, 7) ^ __ROL4__(v240, 14))
+ v247
+ ((v63 >> 10) ^ __ROL4__(v63, 13) ^ __ROL4__(v63, 15));
v68 = v253 /*0xffe270ce*/
+ (__ROR4__(v105, 6) ^ __ROL4__(v105, 7) ^ __ROR4__(v105, 11))
+ (v95 ^ v105 & (v188 ^ v95))
+ v129
+ 1322822218;
v141 = v68 + v140; /*0xffe270d3*/
v130 = v68 + (__ROR4__(v67, 2) ^ __ROL4__(v67, 10) ^ __ROR4__(v67, 13)) + (v67 & v152 | v116 & (v67 | v152)); /*0xffe270f9*/
v237 = v240 /*0xffe27149*/
+ v250
+ (((v232 + v65) >> 10) ^ __ROL4__(v232 + v65, 13) ^ __ROL4__(v232 + v65, 15))
+ (__ROR4__(v255, 7) ^ __ROL4__(v255, 14) ^ (v255 >> 3));
v69 = v237 /*0xffe27170*/
+ (__ROR4__(v141, 6) ^ __ROL4__(v141, 7) ^ __ROR4__(v141, 11))
+ (v188 ^ v141 & (v188 ^ v105))
+ v95
+ 1537002063;
v117 = v69 + v116; /*0xffe27176*/
v96 = v69 + (__ROR4__(v130, 2) ^ __ROL4__(v130, 10) ^ __ROR4__(v130, 13)) + (v130 & v67 | v152 & (v130 | v67)); /*0xffe271a7*/
v256 = v255 /*0xffe271f7*/
+ ((v208 >> 3) ^ __ROR4__(v208, 7) ^ __ROL4__(v208, 14))
+ v260
+ ((v253 >> 10) ^ __ROL4__(v253, 13) ^ __ROL4__(v253, 15));
v70 = v256 /*0xffe27225*/
+ (__ROR4__(v117, 6) ^ __ROL4__(v117, 7) ^ __ROR4__(v117, 11))
+ (v105 ^ v117 & (v141 ^ v105))
+ v188
+ 1747873779;
v153 = v70 + v152; /*0xffe2722d*/
v164 = v70 + (__ROR4__(v96, 2) ^ __ROL4__(v96, 10) ^ __ROR4__(v96, 13)) + (v96 & v130 | v67 & (v96 | v130)); /*0xffe27262*/
v241 = v208 /*0xffe272a8*/
+ ((v244 >> 3) ^ __ROR4__(v244, 7) ^ __ROL4__(v244, 14))
+ ((v237 >> 10) ^ __ROL4__(v237, 13) ^ __ROL4__(v237, 15))
+ v225;
v71 = v241 /*0xffe272d5*/
+ (__ROR4__(v153, 6) ^ __ROL4__(v153, 7) ^ __ROR4__(v153, 11))
+ (v141 ^ v153 & (v117 ^ v141))
+ v105
+ 1955562222;
v176 = v71 + v67; /*0xffe272da*/
v201 = v71 + (__ROR4__(v164, 2) ^ __ROL4__(v164, 10) ^ __ROR4__(v164, 13)) + (v164 & v96 | v130 & (v164 | v96)); /*0xffe2730d*/
v72 = v244 /*0xffe27345*/
+ v61
+ ((v256 >> 10) ^ __ROL4__(v256, 13) ^ __ROL4__(v256, 15))
+ (__ROR4__(v213, 7) ^ __ROL4__(v213, 14) ^ (v213 >> 3));
v73 = v72 /*0xffe27370*/
+ (__ROR4__(v176, 6) ^ __ROL4__(v176, 7) ^ __ROR4__(v176, 11))
+ (v117 ^ v176 & (v153 ^ v117))
+ v141
+ 2024104815;
v131 = v73 + v130; /*0xffe27375*/
v205 = v73 + (__ROR4__(v201, 2) ^ __ROL4__(v201, 10) ^ __ROR4__(v201, 13)) + (v164 & v201 | v96 & (v164 | v201)); /*0xffe273a7*/
v74 = v213 /*0xffe273e1*/
+ v63
+ ((v241 >> 10) ^ __ROL4__(v241, 13) ^ __ROL4__(v241, 15))
+ (__ROR4__(v216, 7) ^ __ROL4__(v216, 14) ^ (v216 >> 3));
v75 = v74 /*0xffe2740a*/
+ (__ROR4__(v131, 6) ^ __ROL4__(v131, 7) ^ __ROR4__(v131, 11))
+ (v153 ^ v131 & (v176 ^ v153))
+ v117
- 2067236844;
v97 = v75 + v96; /*0xffe2740f*/
v189 = v75 + (__ROR4__(v205, 2) ^ __ROL4__(v205, 10) ^ __ROR4__(v205, 13)) + (v205 & v201 | v164 & (v205 | v201)); /*0xffe27444*/
v76 = v216 /*0xffe2746c*/
+ v232
+ v65
+ ((v72 >> 10) ^ __ROL4__(v72, 13) ^ __ROL4__(v72, 15))
+ (__ROR4__(v219, 7) ^ __ROL4__(v219, 14) ^ (v219 >> 3));
v77 = v76 /*0xffe274a7*/
+ (__ROR4__(v97, 6) ^ __ROL4__(v97, 7) ^ __ROR4__(v97, 11))
+ (v176 ^ v97 & (v131 ^ v176))
+ v153
- 1933114872;
v165 = v77 + v164; /*0xffe274ac*/
v258 = v77 + (__ROR4__(v189, 2) ^ __ROL4__(v189, 10) ^ __ROR4__(v189, 13)) + (v189 & v205 | v201 & (v189 | v205)); /*0xffe274d1*/
v78 = v219 /*0xffe27507*/
+ v253
+ ((v74 >> 10) ^ __ROL4__(v74, 13) ^ __ROL4__(v74, 15))
+ (__ROR4__(v222, 7) ^ __ROL4__(v222, 14) ^ (v222 >> 3));
v79 = v78 /*0xffe2753c*/
+ (__ROR4__(v165, 6) ^ __ROL4__(v165, 7) ^ __ROR4__(v165, 11))
+ (v131 ^ v165 & (v97 ^ v131))
+ v176
- 1866530822;
v202 = v79 + v201; /*0xffe27541*/
v80 = v79 + (__ROR4__(v258, 2) ^ __ROL4__(v258, 10) ^ __ROR4__(v258, 13)) + (v258 & v189 | v205 & (v258 | v189)); /*0xffe2755d*/
v81 = v222 /*0xffe27595*/
+ v237
+ ((v76 >> 10) ^ __ROL4__(v76, 13) ^ __ROL4__(v76, 15))
+ (__ROR4__(v247, 7) ^ __ROL4__(v247, 14) ^ (v247 >> 3));
v82 = v81 /*0xffe275ca*/
+ (__ROR4__(v202, 6) ^ __ROL4__(v202, 7) ^ __ROR4__(v202, 11))
+ (v97 ^ v202 & (v165 ^ v97))
+ v131
- 1538233109;
v206 = v82 + v205; /*0xffe275cf*/
v83 = v82 + (__ROR4__(v80, 2) ^ __ROL4__(v80, 10) ^ __ROR4__(v80, 13)) + (v80 & v258 | v189 & (v80 | v258)); /*0xffe275ee*/
v84 = v247 /*0xffe2765e*/
+ ((v78 >> 10) ^ __ROL4__(v78, 13) ^ __ROL4__(v78, 15))
+ (__ROR4__(v206, 6) ^ __ROL4__(v206, 7) ^ __ROR4__(v206, 11))
+ v256
+ ((v250 >> 3) ^ __ROR4__(v250, 7) ^ __ROL4__(v250, 14))
+ (v165 ^ v206 & (v165 ^ v202))
+ v97
- 1090935817;
v190 = v84 + v189; /*0xffe27667*/
v85 = v84 + (__ROR4__(v83, 2) ^ __ROL4__(v83, 10) ^ __ROR4__(v83, 13)) + (v83 & v80 | v258 & (v83 | v80)); /*0xffe27686*/
v86 = v250 /*0xffe276f2*/
+ ((v81 >> 10) ^ __ROL4__(v81, 13) ^ __ROL4__(v81, 15))
+ (__ROR4__(v190, 6) ^ __ROL4__(v190, 7) ^ __ROR4__(v190, 11))
+ v241
+ ((v260 >> 3) ^ __ROR4__(v260, 7) ^ __ROL4__(v260, 14))
+ (v202 ^ v190 & (v206 ^ v202))
+ v165
- 965641998;
v87 = v86 + buf[2] + (__ROR4__(v85, 2) ^ __ROL4__(v85, 10) ^ __ROR4__(v85, 13)) + (v85 & v83 | v80 & (v85 | v83)); /*0xffe2771c*/
v88 = buf[6]; /*0xffe2771e*/
buf[3] += v85; /*0xffe27721*/
buf[5] += v80; /*0xffe2772d*/
buf[4] += v83; /*0xffe27730*/
buf[6] = v258 + v86 + v88; /*0xffe27733*/
buf[7] += v190; /*0xffe2773a*/
buf[8] += v206; /*0xffe27741*/
buf[9] += v202; /*0xffe27748*/
buf[2] = v87; /*0xffe27750*/
return 0; /*0xffe2774d*/
}
// ============================================================================
// 0xffe27758 InitHashContextSm3
// ============================================================================
int __thiscall InitHashContextSm3(_BYTE *buf)
{
*((_DWORD *)buf + 10) = 0; /*0xffe2775a*/
*(_DWORD *)buf = 0; /*0xffe2775d*/
*((_DWORD *)buf + 1) = 0; /*0xffe2775f*/
*((_DWORD *)buf + 2) = 1779033703; /*0xffe27762*/
*((_DWORD *)buf + 3) = -1150833019; /*0xffe27769*/
*((_DWORD *)buf + 4) = 1013904242; /*0xffe27770*/
*((_DWORD *)buf + 5) = -1521486534; /*0xffe27777*/
*((_DWORD *)buf + 6) = 1359893119; /*0xffe2777e*/
*((_DWORD *)buf + 7) = -1694144372; /*0xffe27785*/
*((_DWORD *)buf + 8) = 528734635; /*0xffe2778c*/
*((_DWORD *)buf + 9) = 1541459225; /*0xffe27793*/
return 0; /*0xffe2779a*/
}
// ============================================================================
// 0xffe2779b HashUpdateSm3
// ============================================================================
int __fastcall HashUpdateSm3(int buf, unsigned __int8 *src, unsigned int n0x40)
{
unsigned int n0x40_1; // ebx
if ( *(_DWORD *)(buf + 40) > 0x40u ) /*0xffe277a5*/
return -1; /*0xffe277a7*/
while ( 1 ) /*0xffe2780d*/
{
do /*0xffe2780d*/
{
while ( 1 ) /*0xffe2782b*/
{
if ( !n0x40 ) /*0xffe2782d*/
return 0; /*0xffe2782f*/
if ( *(_DWORD *)(buf + 40) || n0x40 < 0x40 ) /*0xffe277c0*/
break; /*0xffe277c0*/
if ( sub_FFE24F44((_DWORD *)buf, src) < 0 ) /*0xffe277cd*/
return -1; /*0xffe277cd*/
*(_QWORD *)buf += 512LL; /*0xffe277cf*/
src += 64; /*0xffe277d9*/
n0x40 -= 64; /*0xffe277dc*/
}
n0x40_1 = 64 - *(_DWORD *)(buf + 40); /*0xffe277e4*/
if ( n0x40 < n0x40_1 ) /*0xffe277e9*/
n0x40_1 = n0x40; /*0xffe277eb*/
if ( n0x40_1 ) /*0xffe277ef*/
sub_FFE238C8((char *)(buf + *(_DWORD *)(buf + 40) + 44), (char *)src, n0x40_1); /*0xffe277fc*/
*(_DWORD *)(buf + 40) += n0x40_1; /*0xffe27802*/
src += n0x40_1; /*0xffe27805*/
n0x40 -= n0x40_1; /*0xffe27807*/
}
while ( *(_DWORD *)(buf + 40) != 64 ); /*0xffe2780d*/
if ( sub_FFE24F44((_DWORD *)buf, (unsigned __int8 *)(buf + 44)) < 0 ) /*0xffe2781b*/
break; /*0xffe2781b*/
*(_QWORD *)buf += 512LL; /*0xffe2781d*/
*(_DWORD *)(buf + 40) = 0; /*0xffe27827*/
}
return -1; /*0xffe27833*/
}
// ============================================================================
// 0xffe2783b HashUpdateSha512
// ============================================================================
int __fastcall HashUpdateSha512(_BYTE *buf, _BYTE *src)
{
unsigned int n0x40; // ecx
bool v6; // cf
unsigned int n0x40_1; // eax
n0x40 = *((_DWORD *)buf + 10); /*0xffe27841*/
if ( n0x40 >= 0x40 ) /*0xffe27847*/
return -1; /*0xffe27849*/
v6 = __CFADD__(8 * n0x40, *(_DWORD *)buf); /*0xffe27857*/
*(_DWORD *)buf += 8 * n0x40; /*0xffe27857*/
*((_DWORD *)buf + 1) += v6; /*0xffe2785c*/
buf[n0x40 + 44] = 0x80; /*0xffe2785f*/
n0x40_1 = ++*((_DWORD *)buf + 10); /*0xffe27867*/
if ( n0x40_1 > 0x38 ) /*0xffe2786d*/
{
while ( n0x40_1 < 0x40 ) /*0xffe2787e*/
{
buf[n0x40_1 + 44] = 0; /*0xffe27871*/
n0x40_1 = ++*((_DWORD *)buf + 10); /*0xffe27878*/
}
sub_FFE24F44(buf, buf + 44); /*0xffe27885*/
*((_DWORD *)buf + 10) = 0; /*0xffe2788a*/
}
while ( *((_DWORD *)buf + 10) < 0x38u ) /*0xffe2789d*/
buf[(*((_DWORD *)buf + 10))++ + 44] = 0; /*0xffe27892*/
buf[100] = buf[7]; /*0xffe278a4*/
buf[101] = buf[6]; /*0xffe278aa*/
buf[102] = sub_FFE2A6B8(0x28u, *(_QWORD *)buf); /*0xffe278b7*/
buf[103] = sub_FFE2A6B8(0x20u, *(_QWORD *)buf); /*0xffe278c6*/
buf[104] = HIBYTE(*(_DWORD *)buf); /*0xffe278d8*/
buf[105] = BYTE2(*(_DWORD *)buf); /*0xffe278e7*/
buf[106] = BYTE1(*(_QWORD *)buf); /*0xffe278f6*/
buf[107] = *buf; /*0xffe278fd*/
sub_FFE24F44(buf, buf + 44); /*0xffe27900*/
*src = buf[11]; /*0xffe27908*/
src[1] = buf[10]; /*0xffe2790d*/
src[2] = buf[9]; /*0xffe27913*/
src[3] = buf[8]; /*0xffe27919*/
src[4] = buf[15]; /*0xffe2791f*/
src[5] = buf[14]; /*0xffe27925*/
src[6] = buf[13]; /*0xffe2792b*/
src[7] = buf[12]; /*0xffe27931*/
src[8] = buf[19]; /*0xffe27937*/
src[9] = buf[18]; /*0xffe2793d*/
src[10] = buf[17]; /*0xffe27943*/
src[11] = buf[16]; /*0xffe27949*/
src[12] = buf[23]; /*0xffe2794f*/
src[13] = buf[22]; /*0xffe27955*/
src[14] = buf[21]; /*0xffe2795b*/
src[15] = buf[20]; /*0xffe27961*/
src[16] = buf[27]; /*0xffe27967*/
src[17] = buf[26]; /*0xffe2796d*/
src[18] = buf[25]; /*0xffe27973*/
src[19] = buf[24]; /*0xffe27979*/
src[20] = buf[31]; /*0xffe2797f*/
src[21] = buf[30]; /*0xffe27985*/
src[22] = buf[29]; /*0xffe2798b*/
src[23] = buf[28]; /*0xffe27991*/
src[24] = buf[35]; /*0xffe27997*/
src[25] = buf[34]; /*0xffe2799d*/
src[26] = buf[33]; /*0xffe279a3*/
src[27] = buf[32]; /*0xffe279a9*/
src[28] = buf[39]; /*0xffe279af*/
src[29] = buf[38]; /*0xffe279b5*/
src[30] = buf[37]; /*0xffe279bb*/
src[31] = buf[36]; /*0xffe279c1*/
return 0; /*0xffe279c7*/
}
// ============================================================================
// 0xffe279ca Tpm12HashAll
// ============================================================================
int __thiscall Tpm12HashAll(_DWORD *this)
{
if ( !this ) /*0xffe279cc*/
return -1; /*0xffe279ce*/
*(this + 18) = 0; /*0xffe279d4*/
*this = 0; /*0xffe279d7*/
*(this + 1) = 0; /*0xffe279d9*/
*(this + 2) = -1056596264; /*0xffe279dc*/
*(this + 3) = -876896931; /*0xffe279e3*/
*(this + 4) = 914150663; /*0xffe279ea*/
*(this + 5) = 1654270250; /*0xffe279f1*/
*(this + 6) = 812702999; /*0xffe279f8*/
*(this + 7) = -1856437926; /*0xffe279ff*/
*(this + 8) = -150054599; /*0xffe27a06*/
*(this + 9) = 355462360; /*0xffe27a0d*/
*(this + 10) = -4191439; /*0xffe27a14*/
*(this + 11) = 1731405415; /*0xffe27a1b*/
*(this + 12) = 1750603025; /*0xffe27a22*/
*(this + 13) = -1900787065; /*0xffe27a29*/
*(this + 14) = 1694076839; /*0xffe27a30*/
*(this + 15) = -619958771; /*0xffe27a37*/
*(this + 16) = -1090891868; /*0xffe27a3e*/
*(this + 17) = 1203062813; /*0xffe27a45*/
return 0; /*0xffe279d1*/
}
// ============================================================================
// 0xffe27a4d Tpm12HashExport
// ============================================================================
int __fastcall Tpm12HashExport(int a1, char *dst)
{
char src[64]; // [esp+8h] [ebp-40h] BYREF
if ( !a1 || !dst || *(_DWORD *)(a1 + 72) >= 0x80u ) /*0xffe27a6a*/
return -1; /*0xffe27a5a*/
sub_FFE2892A(a1, src); /*0xffe27a6f*/
sub_FFE238C8(dst, src, 0x30u); /*0xffe27a7b*/
return 0; /*0xffe27a83*/
}
// ============================================================================
// 0xffe27a88 Tpm20HashDigestExtend
// ============================================================================
int __fastcall Tpm20HashDigestExtend(int a1, int src)
{
char *dst; // esi
char *src_1; // edi
int n8; // ebx
unsigned __int8 *v6; // edi
__int64 v7; // rt0
__int64 v8; // rax
unsigned __int64 v9; // rt0
int v10; // ecx
_BYTE *v11; // edx
__int64 v12; // rcx
unsigned int v13; // edi
unsigned int v14; // ebp
unsigned __int64 v15; // rt0
int v16; // edi
bool v17; // zf
int n8_1; // ebp
unsigned int v19; // ecx
unsigned int v20; // edx
unsigned __int64 v21; // kr28_8
unsigned __int64 v22; // kr58_8
unsigned __int64 v23; // kr88_8
unsigned __int64 v24; // kr90_8
unsigned __int64 v25; // krB0_8
unsigned __int64 v26; // kr00_8
unsigned __int64 v27; // krD0_8
unsigned int v28; // eax
unsigned __int64 v29; // kr100_8
unsigned int v30; // eax
unsigned __int64 v31; // kr130_8
unsigned __int64 v32; // kr08_8
unsigned int v33; // eax
unsigned __int64 v34; // kr160_8
unsigned __int64 v35; // kr20_8
unsigned __int64 v36; // kr170_8
_DWORD *v37; // ecx
int v38; // eax
bool v39; // cf
unsigned int v41; // [esp+14h] [ebp-310h]
unsigned __int64 v42; // [esp+14h] [ebp-310h]
unsigned __int64 v43; // [esp+14h] [ebp-310h]
unsigned int v44; // [esp+18h] [ebp-30Ch]
int n64; // [esp+1Ch] [ebp-308h]
unsigned int v46; // [esp+1Ch] [ebp-308h]
unsigned int v47; // [esp+1Ch] [ebp-308h]
unsigned __int64 v48; // [esp+20h] [ebp-304h]
__int64 v49; // [esp+20h] [ebp-304h]
unsigned __int64 v50; // [esp+20h] [ebp-304h]
__int64 v51; // [esp+28h] [ebp-2FCh]
__int64 v52; // [esp+28h] [ebp-2FCh]
int v53; // [esp+2Ch] [ebp-2F8h]
unsigned __int64 v54; // [esp+30h] [ebp-2F4h]
__int64 v55; // [esp+30h] [ebp-2F4h]
unsigned __int64 v56; // [esp+30h] [ebp-2F4h]
unsigned __int64 v57; // [esp+38h] [ebp-2ECh]
unsigned __int64 v58; // [esp+38h] [ebp-2ECh]
unsigned __int64 v59; // [esp+40h] [ebp-2E4h]
unsigned __int64 v60; // [esp+40h] [ebp-2E4h]
unsigned __int64 v61; // [esp+48h] [ebp-2DCh]
unsigned __int64 v62; // [esp+48h] [ebp-2DCh]
unsigned int v63; // [esp+50h] [ebp-2D4h]
int v64; // [esp+50h] [ebp-2D4h]
_BYTE *v65; // [esp+54h] [ebp-2D0h]
int n160; // [esp+54h] [ebp-2D0h]
unsigned __int64 v67; // [esp+58h] [ebp-2CCh] BYREF
unsigned __int64 v68; // [esp+60h] [ebp-2C4h]
unsigned __int64 v69; // [esp+68h] [ebp-2BCh]
unsigned __int64 v70; // [esp+70h] [ebp-2B4h]
unsigned __int64 v71; // [esp+78h] [ebp-2ACh]
unsigned __int64 v72; // [esp+80h] [ebp-2A4h]
unsigned __int64 v73; // [esp+88h] [ebp-29Ch]
unsigned __int64 v74; // [esp+90h] [ebp-294h]
_DWORD *v75; // [esp+9Ch] [ebp-288h]
_DWORD v76[28]; // [esp+A0h] [ebp-284h]
_BYTE v77[532]; // [esp+110h] [ebp-214h] BYREF
dst = (char *)&v67; /*0xffe27a95*/
v75 = (_DWORD *)(a1 + 8); /*0xffe27a9d*/
src_1 = (char *)(a1 + 8); /*0xffe27aa4*/
n8 = 8; /*0xffe27aa6*/
do /*0xffe27abc*/
{
sub_FFE238C8(dst, src_1, 8u); /*0xffe27aad*/
src_1 += 8; /*0xffe27ab2*/
dst += 8; /*0xffe27ab5*/
--n8; /*0xffe27ab9*/
}
while ( n8 ); /*0xffe27abc*/
v6 = (unsigned __int8 *)(src + 2); /*0xffe27abe*/
do /*0xffe27b4e*/
{
HIDWORD(v7) = (unsigned __int64)*(v6 - 2) >> 24; /*0xffe27add*/
LODWORD(v7) = *(v6 - 1) | (*(v6 - 2) << 8); /*0xffe27add*/
v8 = *v6; /*0xffe27ae1*/
v6 += 8; /*0xffe27ae2*/
v9 = v8 | (v7 << 8); /*0xffe27af0*/
HIDWORD(v9) = v9 >> 24; /*0xffe27b00*/
LODWORD(v9) = *(v6 - 7) | ((_DWORD)v9 << 8); /*0xffe27b00*/
HIDWORD(v9) = v9 >> 24; /*0xffe27b10*/
LODWORD(v9) = *(v6 - 6) | ((_DWORD)v9 << 8); /*0xffe27b10*/
HIDWORD(v9) = v9 >> 24; /*0xffe27b20*/
LODWORD(v9) = *(v6 - 5) | ((_DWORD)v9 << 8); /*0xffe27b20*/
HIDWORD(v9) = v9 >> 24; /*0xffe27b30*/
LODWORD(v9) = *(v6 - 4) | ((_DWORD)v9 << 8); /*0xffe27b30*/
v10 = *(v6 - 3) | ((_DWORD)v9 << 8); /*0xffe27b3a*/
v76[2 * n8 + 1] = v9 >> 24; /*0xffe27b3c*/
v76[2 * n8++] = v10; /*0xffe27b43*/
}
while ( n8 < 16 ); /*0xffe27b4e*/
v11 = v77; /*0xffe27b54*/
n64 = 64; /*0xffe27b5b*/
v65 = v77; /*0xffe27b63*/
do /*0xffe27c35*/
{
HIDWORD(v12) = *((_DWORD *)v11 - 26); /*0xffe27b67*/
v13 = *((_DWORD *)v11 - 25); /*0xffe27b6c*/
v14 = *((_DWORD *)v11 + 1); /*0xffe27b71*/
LODWORD(v12) = v13; /*0xffe27b74*/
v44 = (__PAIR64__(v13, HIDWORD(v12)) >> 7) ^ (__PAIR64__(v13, HIDWORD(v12)) >> 1) ^ (*((_QWORD *)v11 - 13) >> 8); /*0xffe27bc2*/
v41 = (v13 >> 7) ^ (__SPAIR64__(HIDWORD(v12), v13) >> 1) ^ (v12 >> 8); /*0xffe27bc8*/
LODWORD(v15) = *(_DWORD *)v65; /*0xffe27bd5*/
HIDWORD(v15) = v14; /*0xffe27bd5*/
v16 = v15 >> 19; /*0xffe27bdf*/
HIDWORD(v15) = v14; /*0xffe27beb*/
LODWORD(v15) = *(_DWORD *)v65; /*0xffe27beb*/
HIDWORD(v12) = (v15 >> 29) ^ ((v14 >> 19) | (*(_DWORD *)v65 << 13)); /*0xffe27bf8*/
LODWORD(v15) = *(_DWORD *)v65; /*0xffe27c04*/
HIDWORD(v15) = v14; /*0xffe27c04*/
*((_QWORD *)v65 + 2) = *((_QWORD *)v65 - 5) /*0xffe27c20*/
+ *((_QWORD *)v65 - 14)
+ __PAIR64__(
(v14 >> 6) ^ HIDWORD(v12),
(unsigned int)(v15 >> 6) ^ ((8 * *(_DWORD *)v65) | (v14 >> 29)) ^ v16)
+ __PAIR64__(v41, v44);
v11 = v65 + 8; /*0xffe27c29*/
v17 = n64-- == 1; /*0xffe27c2c*/
v65 += 8; /*0xffe27c31*/
}
while ( !v17 ); /*0xffe27c35*/
n8_1 = 0; /*0xffe27c42*/
v54 = v74; /*0xffe27c4f*/
v19 = HIDWORD(v71); /*0xffe27c5a*/
v20 = v71; /*0xffe27c5e*/
v48 = v73; /*0xffe27c6d*/
v46 = HIDWORD(v72); /*0xffe27c78*/
v63 = v72; /*0xffe27c83*/
v57 = v70; /*0xffe27c93*/
v42 = v69; /*0xffe27ca3*/
v59 = v68; /*0xffe27cb3*/
n160 = 0; /*0xffe27cc3*/
v51 = __PAIR64__(v71, HIDWORD(v71)); /*0xffe27cc7*/
v61 = v67; /*0xffe27ccf*/
do /*0xffe287d7*/
{
v21 = v54 /*0xffe27d69*/
+ __PAIR64__(v76[n160 + 1], v76[n160])
+ __PAIR64__(dword_FFE2B2B8[n160], dword_FFE2B2B4[n160])
+ __PAIR64__(
(v51 >> 14) ^ (((unsigned int)v51 >> 18) | (v20 << 14)) ^ (__PAIR64__(v19, v20) >> 9),
v48 ^ HIDWORD(v51) & (v48 ^ v63))
+ __PAIR64__(
HIDWORD(v48) ^ (unsigned int)v51 & (HIDWORD(v48) ^ v46),
(__PAIR64__(v51, HIDWORD(v51)) >> 14) ^ (__PAIR64__(v51, HIDWORD(v51)) >> 18) ^ ((v20 << 23) | (v19 >> 9)));
v58 = v21 + v57; /*0xffe27d77*/
LODWORD(v55) = (((_DWORD)v61 << 25) | (HIDWORD(v61) >> 7)) /*0xffe27dd3*/
^ (((_DWORD)v61 << 30) | (HIDWORD(v61) >> 2))
^ (v61 >> 28);
HIDWORD(v55) = (v61 >> 7) ^ (v61 >> 2) ^ ((HIDWORD(v61) >> 28) | (16 * v61)); /*0xffe27dd7*/
v56 = v21 + (v61 & v59 | v42 & (v61 | v59)) + v55; /*0xffe27e1b*/
v22 = v48 /*0xffe27eb7*/
+ __PAIR64__(v76[n160 + 3], v76[n160 + 2])
+ __PAIR64__(dword_FFE2B2C0[n160], dword_FFE2B2BC[n160])
+ __PAIR64__(
((HIDWORD(v58) >> 14) | ((_DWORD)v58 << 18)) ^ ((HIDWORD(v58) >> 18) | ((_DWORD)v58 << 14)) ^ (v58 >> 9),
v63 ^ v58 & (HIDWORD(v51) ^ v63))
+ __PAIR64__(
v46 ^ HIDWORD(v58) & (v51 ^ v46),
(v58 >> 14) ^ (v58 >> 18) ^ (((_DWORD)v58 << 23) | (HIDWORD(v58) >> 9)));
v43 = v22 + v42; /*0xffe27ec5*/
HIDWORD(v49) = (v56 >> 7) ^ (v56 >> 2) ^ ((HIDWORD(v56) >> 28) | (16 * v56)); /*0xffe27f1f*/
LODWORD(v49) = (((_DWORD)v56 << 25) | (HIDWORD(v56) >> 7)) /*0xffe27f25*/
^ (((_DWORD)v56 << 30) | (HIDWORD(v56) >> 2))
^ (v56 >> 28);
v50 = v22 + (v56 & v61 | v59 & (v56 | v61)) + v49; /*0xffe27f69*/
v23 = __PAIR64__(v46, v63) /*0xffe28005*/
+ __PAIR64__(v76[n160 + 5], v76[n160 + 4])
+ __PAIR64__(dword_FFE2B2C8[n160], dword_FFE2B2C4[n160])
+ __PAIR64__(
((HIDWORD(v43) >> 14) | ((_DWORD)v43 << 18)) ^ ((HIDWORD(v43) >> 18) | ((_DWORD)v43 << 14)) ^ (v43 >> 9),
HIDWORD(v51) ^ v43 & (HIDWORD(v51) ^ v58))
+ __PAIR64__(
v51 ^ HIDWORD(v43) & (v51 ^ HIDWORD(v58)),
(v43 >> 14) ^ (v43 >> 18) ^ (((_DWORD)v43 << 23) | (HIDWORD(v43) >> 9)));
v60 = v23 + v59; /*0xffe28013*/
v24 = (v50 & v56 | v61 & (v50 | v56)) /*0xffe280a9*/
+ __PAIR64__(
(v50 >> 7) ^ (v50 >> 2) ^ ((HIDWORD(v50) >> 28) | (16 * v50)),
(((_DWORD)v50 << 25) | (HIDWORD(v50) >> 7)) ^ (((_DWORD)v50 << 30) | (HIDWORD(v50) >> 2)) ^ (v50 >> 28));
v64 = v23 + v24; /*0xffe280ad*/
v47 = (v23 + v24) >> 32; /*0xffe280b7*/
v25 = __PAIR64__(v51, HIDWORD(v51)) /*0xffe28153*/
+ __PAIR64__(v76[n160 + 7], v76[n160 + 6])
+ __PAIR64__(dword_FFE2B2D0[n160], dword_FFE2B2CC[n160])
+ (v58 ^ v60 & (v58 ^ v43))
+ __PAIR64__(
((HIDWORD(v60) >> 14) | ((_DWORD)v60 << 18)) ^ ((HIDWORD(v60) >> 18) | ((_DWORD)v60 << 14)) ^ (v60 >> 9),
(v60 >> 14) ^ (v60 >> 18) ^ (((_DWORD)v60 << 23) | (HIDWORD(v60) >> 9)));
v62 = v25 + v61; /*0xffe28161*/
v53 = ((v64 << 25) | (v47 >> 7)) ^ ((v64 << 30) | (v47 >> 2)) ^ ((v23 + v24) >> 28); /*0xffe281c1*/
v26 = v25 /*0xffe281fb*/
+ __PAIR64__(
(HIDWORD(v50) & v47 | HIDWORD(v56) & (HIDWORD(v50) | v47))
+ __CFADD__(v50 & v64 | v56 & (v50 | v64), v53)
+ (((v23 + v24) >> 7) ^ ((v23 + v24) >> 2) ^ ((v47 >> 28) | (16 * (v23 + v24)))),
(v50 & v64 | v56 & (v50 | v64)) + v53);
LODWORD(v52) = HIDWORD(v26); /*0xffe281fb*/
HIDWORD(v52) = v26; /*0xffe281fb*/
v27 = v58 /*0xffe282a1*/
+ __PAIR64__(v76[n160 + 9], v76[n160 + 8])
+ __PAIR64__(dword_FFE2B2D8[n160], dword_FFE2B2D4[n160])
+ (v43 ^ v62 & (v60 ^ v43))
+ __PAIR64__(
((HIDWORD(v62) >> 14) | ((_DWORD)v62 << 18)) ^ ((HIDWORD(v62) >> 18) | ((_DWORD)v62 << 14)) ^ (v62 >> 9),
(v62 >> 14) ^ (v62 >> 18) ^ (((_DWORD)v62 << 23) | (HIDWORD(v62) >> 9)));
v28 = (v27 + v56) >> 32; /*0xffe282af*/
LODWORD(v54) = v27 + v56; /*0xffe282af*/
v74 = __PAIR64__(v28, v54); /*0xffe282b3*/
HIDWORD(v54) = v28; /*0xffe282c2*/
HIDWORD(v58) = (__PAIR64__(v52, HIDWORD(v52)) >> 7) ^ (__PAIR64__(v52, HIDWORD(v52)) >> 2) ^ (v52 >> 28); /*0xffe28323*/
LODWORD(v58) = (v52 >> 7) ^ (v52 >> 2) ^ (__PAIR64__(v52, HIDWORD(v52)) >> 28); /*0xffe28329*/
v57 = v27 /*0xffe28363*/
+ __PAIR64__(
v52 & v47 | HIDWORD(v50) & (v52 | v47),
HIDWORD(v52) & v64 | (unsigned int)v50 & (HIDWORD(v52) | v64))
+ v58;
v70 = v57; /*0xffe28379*/
v29 = v43 /*0xffe2840d*/
+ __PAIR64__(v76[n160 + 11], v76[n160 + 10])
+ __PAIR64__(dword_FFE2B2E0[n160], dword_FFE2B2DC[n160])
+ (v60 ^ v54 & (v62 ^ v60))
+ __PAIR64__(
((HIDWORD(v54) >> 14) | ((_DWORD)v54 << 18)) ^ ((HIDWORD(v54) >> 18) | ((_DWORD)v54 << 14)) ^ (v54 >> 9),
(v54 >> 14) ^ (v54 >> 18) ^ (((_DWORD)v54 << 23) | (HIDWORD(v54) >> 9)));
v30 = (v29 + v50) >> 32; /*0xffe2841f*/
LODWORD(v48) = v29 + v50; /*0xffe2841f*/
v73 = __PAIR64__(v30, v48); /*0xffe28423*/
HIDWORD(v48) = v30; /*0xffe28432*/
HIDWORD(v43) = (v57 >> 7) ^ (v57 >> 2) ^ ((HIDWORD(v57) >> 28) | (16 * v57)); /*0xffe28493*/
LODWORD(v43) = (((_DWORD)v57 << 25) | (HIDWORD(v57) >> 7)) /*0xffe28499*/
^ (((_DWORD)v57 << 30) | (HIDWORD(v57) >> 2))
^ (v57 >> 28);
v42 = v29 /*0xffe284d3*/
+ __PAIR64__(
v52 & HIDWORD(v57) | v47 & (v52 | HIDWORD(v57)),
HIDWORD(v52) & v57 | (v23 + v24) & (HIDWORD(v52) | v57))
+ v43;
v69 = v42; /*0xffe284e9*/
v31 = v60 /*0xffe28581*/
+ __PAIR64__(v76[n160 + 13], v76[n160 + 12])
+ __PAIR64__(dword_FFE2B2E8[n160], dword_FFE2B2E4[n160])
+ (v62 ^ v48 & (v54 ^ v62))
+ __PAIR64__(
((HIDWORD(v48) >> 14) | ((_DWORD)v48 << 18)) ^ ((HIDWORD(v48) >> 18) | ((_DWORD)v48 << 14)) ^ (v48 >> 9),
(v48 >> 14) ^ (v48 >> 18) ^ (((_DWORD)v48 << 23) | (HIDWORD(v48) >> 9)));
v32 = v31 + v23 + v24; /*0xffe2858f*/
v46 = HIDWORD(v32); /*0xffe2858f*/
v63 = v32; /*0xffe2858f*/
v72 = __PAIR64__(v46, v63); /*0xffe28593*/
HIDWORD(v60) = (v42 >> 7) ^ (v42 >> 2) ^ ((HIDWORD(v42) >> 28) | (16 * v42)); /*0xffe28603*/
LODWORD(v60) = (((_DWORD)v42 << 25) | (HIDWORD(v42) >> 7)) /*0xffe28609*/
^ (((_DWORD)v42 << 30) | (HIDWORD(v42) >> 2))
^ (v42 >> 28);
v33 = (v31 /*0xffe28643*/
+ __PAIR64__(
HIDWORD(v57) & HIDWORD(v42) | (unsigned int)v52 & (HIDWORD(v57) | HIDWORD(v42)),
v57 & v42 | HIDWORD(v52) & (v57 | v42))
+ v60) >> 32;
LODWORD(v59) = v31 + (v57 & v42 | HIDWORD(v52) & (v57 | v42)) + v60; /*0xffe28643*/
v68 = __PAIR64__(v33, v59); /*0xffe28649*/
HIDWORD(v59) = v33; /*0xffe28653*/
v34 = v62 /*0xffe286f1*/
+ __PAIR64__(v76[n160 + 15], v76[n160 + 14])
+ __PAIR64__(dword_FFE2B2F0[n160], dword_FFE2B2EC[n160])
+ __PAIR64__(
((v46 >> 14) | (v63 << 18)) ^ ((v46 >> 18) | (v63 << 14)) ^ (__PAIR64__(v46, v63) >> 9),
v54 ^ v63 & (v48 ^ v54))
+ __PAIR64__(
HIDWORD(v54) ^ v46 & (HIDWORD(v48) ^ HIDWORD(v54)),
(__PAIR64__(v46, v63) >> 14) ^ (__PAIR64__(v46, v63) >> 18) ^ ((v63 << 23) | (v46 >> 9)));
v35 = v34 + __PAIR64__(v52, HIDWORD(v52)); /*0xffe286ff*/
LODWORD(v51) = HIDWORD(v35); /*0xffe286ff*/
HIDWORD(v51) = v35; /*0xffe286ff*/
v71 = __PAIR64__(v51, HIDWORD(v51)); /*0xffe28703*/
HIDWORD(v62) = (v59 >> 7) ^ (__PAIR64__(v33, v59) >> 2) ^ ((v33 >> 28) | (16 * v59)); /*0xffe2876d*/
LODWORD(v62) = (((_DWORD)v59 << 25) | (v33 >> 7)) /*0xffe28773*/
^ (((_DWORD)v59 << 30) | (v33 >> 2))
^ (__PAIR64__(v33, v59) >> 28);
v20 = HIDWORD(v51); /*0xffe287ab*/
v36 = v34 /*0xffe287b1*/
+ __PAIR64__(v33 & HIDWORD(v42) | HIDWORD(v57) & (v33 | HIDWORD(v42)), v59 & v42 | v57 & (v59 | v42))
+ v62;
v61 = v36; /*0xffe287b1*/
v67 = v36; /*0xffe287b7*/
v19 = v51; /*0xffe287bb*/
n160 += 16; /*0xffe287ce*/
}
while ( n160 < 160 ); /*0xffe287d7*/
v37 = v75; /*0xffe287dd*/
do /*0xffe287f8*/
{
v38 = *((_DWORD *)&v67 + 2 * n8_1); /*0xffe287e4*/
v39 = __CFADD__(v38, *v37); /*0xffe287e8*/
*v37 += v38; /*0xffe287e8*/
v37[1] += *((_DWORD *)&v67 + 2 * n8_1++ + 1) + v39; /*0xffe287ee*/
v37 += 2; /*0xffe287f2*/
}
while ( n8_1 < 8 ); /*0xffe287f8*/
return 0; /*0xffe287fa*/
}
// ============================================================================
// 0xffe28807 Tpm20MettleHashAll
// ============================================================================
int __thiscall Tpm20MettleHashAll(_DWORD *this)
{
if ( !this ) /*0xffe28809*/
return -1; /*0xffe2880b*/
*(this + 18) = 0; /*0xffe28811*/
*this = 0; /*0xffe28814*/
*(this + 1) = 0; /*0xffe28816*/
*(this + 2) = -205731576; /*0xffe28819*/
*(this + 3) = 1779033703; /*0xffe28820*/
*(this + 4) = -2067093701; /*0xffe28827*/
*(this + 5) = -1150833019; /*0xffe2882e*/
*(this + 6) = -23791573; /*0xffe28835*/
*(this + 7) = 1013904242; /*0xffe2883c*/
*(this + 8) = 1595750129; /*0xffe28843*/
*(this + 9) = -1521486534; /*0xffe2884a*/
*(this + 10) = -1377402159; /*0xffe28851*/
*(this + 11) = 1359893119; /*0xffe28858*/
*(this + 12) = 725511199; /*0xffe2885f*/
*(this + 13) = -1694144372; /*0xffe28866*/
*(this + 14) = -79577749; /*0xffe2886d*/
*(this + 15) = 528734635; /*0xffe28874*/
*(this + 16) = 327033209; /*0xffe2887b*/
*(this + 17) = 1541459225; /*0xffe28882*/
return 0; /*0xffe2880e*/
}
// ============================================================================
// 0xffe2888a Tpm20MettleHashUpdate
// ============================================================================
int __fastcall Tpm20MettleHashUpdate(int a1, char *src_1, unsigned int n0x80)
{
char *src; // ebp
int result; // eax
unsigned int count; // ebx
src = src_1; /*0xffe2888f*/
if ( !a1 || !src_1 || *(_DWORD *)(a1 + 72) > 0x80u ) /*0xffe288aa*/
return -1; /*0xffe28896*/
while ( n0x80 ) /*0xffe28921*/
{
if ( *(_DWORD *)(a1 + 72) || n0x80 < 0x80 ) /*0xffe288ba*/
{
count = 128 - *(_DWORD *)(a1 + 72); /*0xffe288d8*/
if ( n0x80 < count ) /*0xffe288dd*/
count = n0x80; /*0xffe288df*/
if ( count ) /*0xffe288e3*/
sub_FFE238C8((char *)(*(_DWORD *)(a1 + 72) + a1 + 76), src, count); /*0xffe288ee*/
*(_DWORD *)(a1 + 72) += count; /*0xffe288f4*/
src += count; /*0xffe288f7*/
n0x80 -= count; /*0xffe288f9*/
if ( *(_DWORD *)(a1 + 72) == 128 ) /*0xffe28903*/
{
result = sub_FFE27A88(a1, a1 + 76); /*0xffe2890a*/
if ( result ) /*0xffe28911*/
return result; /*0xffe28911*/
*(_QWORD *)a1 += 1024LL; /*0xffe28913*/
*(_DWORD *)(a1 + 72) = 0; /*0xffe2891c*/
}
}
else
{
result = sub_FFE27A88(a1, (int)src); /*0xffe288c0*/
if ( result ) /*0xffe288c7*/
return result; /*0xffe288c7*/
*(_QWORD *)a1 += 1024LL; /*0xffe288c9*/
src += 128; /*0xffe288d2*/
n0x80 -= 128; /*0xffe288d4*/
}
}
return 0; /*0xffe28925*/
}
// ============================================================================
// 0xffe2892a Tpm20MettleHashComplete
// ============================================================================
int __fastcall Tpm20MettleHashComplete(int a1, char *src)
{
unsigned int n0x80; // ecx
unsigned int n0x80_1; // eax
char *v7; // ecx
char *v8; // esi
int n8; // edx
char v10; // al
if ( !a1 ) /*0xffe28935*/
return -1; /*0xffe28935*/
if ( !src ) /*0xffe28941*/
return -1; /*0xffe28941*/
n0x80 = *(_DWORD *)(a1 + 72); /*0xffe28943*/
if ( n0x80 >= 0x80 ) /*0xffe2894d*/
return -1; /*0xffe28937*/
*(_QWORD *)a1 += 8LL * n0x80; /*0xffe28956*/
*(_BYTE *)(n0x80 + a1 + 76) = 0x80; /*0xffe2895b*/
n0x80_1 = ++*(_DWORD *)(a1 + 72); /*0xffe28962*/
if ( n0x80_1 > 0x70 ) /*0xffe28968*/
{
while ( n0x80_1 < 0x80 ) /*0xffe28979*/
{
*(_BYTE *)(a1 + n0x80_1 + 76) = 0; /*0xffe2896c*/
n0x80_1 = ++*(_DWORD *)(a1 + 72); /*0xffe28974*/
}
sub_FFE27A88(a1, a1 + 76); /*0xffe28980*/
*(_DWORD *)(a1 + 72) = 0; /*0xffe28985*/
}
while ( *(_DWORD *)(a1 + 72) < 0x78u ) /*0xffe2899a*/
{
*(_BYTE *)(*(_DWORD *)(a1 + 72) + a1 + 76) = 0; /*0xffe2898e*/
++*(_DWORD *)(a1 + 72); /*0xffe28993*/
}
*(_BYTE *)(a1 + 196) = *(_BYTE *)(a1 + 7); /*0xffe289a2*/
*(_BYTE *)(a1 + 197) = *(_BYTE *)(a1 + 6); /*0xffe289ad*/
*(_BYTE *)(a1 + 198) = *(_BYTE *)(a1 + 5); /*0xffe289b6*/
*(_BYTE *)(a1 + 199) = *(_BYTE *)(a1 + 4); /*0xffe289bf*/
*(_BYTE *)(a1 + 200) = *(_BYTE *)(a1 + 3); /*0xffe289c8*/
*(_BYTE *)(a1 + 201) = *(_BYTE *)(a1 + 2); /*0xffe289d1*/
*(_BYTE *)(a1 + 202) = *(_BYTE *)(a1 + 1); /*0xffe289da*/
*(_BYTE *)(a1 + 203) = *(_BYTE *)a1; /*0xffe289e2*/
sub_FFE27A88(a1, a1 + 76); /*0xffe289e8*/
v7 = src + 2; /*0xffe289ed*/
v8 = (char *)(a1 + 14); /*0xffe289f0*/
n8 = 8; /*0xffe289f3*/
do /*0xffe28a2a*/
{
*(v7 - 2) = v8[1]; /*0xffe289f8*/
*(v7 - 1) = *v8; /*0xffe289fd*/
*v7 = *(v8 - 1); /*0xffe28a03*/
v7[1] = *(v8 - 2); /*0xffe28a08*/
v7[2] = *(v8 - 3); /*0xffe28a0e*/
v7[3] = *(v8 - 4); /*0xffe28a14*/
v7[4] = *(v8 - 5); /*0xffe28a1a*/
v10 = *(v8 - 6); /*0xffe28a1d*/
v8 += 8; /*0xffe28a20*/
v7[5] = v10; /*0xffe28a22*/
v7 += 8; /*0xffe28a25*/
--n8; /*0xffe28a27*/
}
while ( n8 ); /*0xffe28a2a*/
return 0; /*0xffe28a2e*/
}
// ============================================================================
// 0xffe28a34 BootGuardIsTpmPresent
// ============================================================================
bool BootGuardIsTpmPresent()
{
return MEMORY[0xFED40030] != -1 && MEMORY[0xFED40030]; /*0xffe28a64*/
}
// ============================================================================
// 0xffe28a68 BootGuardGetTpmType
// ============================================================================
char BootGuardGetTpmType()
{
char v1; // [esp+6h] [ebp-2h]
v1 = MEMORY[0xFED40030] & 0xF; /*0xffe28a84*/
if ( sub_FFE28A34() ) /*0xffe28a8b*/
return v1 & 0xF; /*0xffe28ab6*/
else
return (unsigned __int8)sub_FFE2A498(-19660800) != 0; /*0xffe28aa1*/
}
// ============================================================================
// 0xffe28abd BootGuardFindFitEntry
// ============================================================================
_DWORD *BootGuardFindFitEntry()
{
int v0; // eax
int v1; // esi
int v2; // eax
_DWORD *v3; // esi
_DWORD *v4; // eax
unsigned int src_1; // ecx
unsigned int count; // ebx
char *v7; // edi
int v8; // ebp
char *src; // [esp+8h] [ebp-Ch]
int v11; // [esp+Ch] [ebp-8h] BYREF
int v12; // [esp+10h] [ebp-4h] BYREF
v11 = 0; /*0xffe28ac4*/
v12 = 0; /*0xffe28ac8*/
v0 = sub_FFE2A23F(); /*0xffe28acc*/
if ( (*(int (__cdecl **)(int, _DWORD, int *))(*(_DWORD *)v0 + 56))(v0, 0, &v11) < 0 ) /*0xffe28ae2*/
return 0; /*0xffe28ae2*/
v1 = v11; /*0xffe28ae8*/
v2 = sub_FFE2A23F(); /*0xffe28aec*/
if ( (*(int (__cdecl **)(void *, int, int *))(*(_DWORD *)v2 + 104))(&unk_FFE2C524, v1, &v12) < 0 ) /*0xffe28b06*/
return 0; /*0xffe28b06*/
v3 = (_DWORD *)(v12 + 44); /*0xffe28b10*/
if ( *(_DWORD *)(v12 + 44) != 1280134994 ) /*0xffe28b19*/
return 0; /*0xffe28baf*/
v4 = (_DWORD *)sub_FFE2A3F4(); /*0xffe28b29*/
if ( v4 ) /*0xffe28b32*/
{
*v4 = v3[1]; /*0xffe28b37*/
v4[1] = v3[2]; /*0xffe28b3c*/
src_1 = (unsigned int)(v3 + 4); /*0xffe28b3f*/
v4[2] = 48; /*0xffe28b42*/
v4[3] = 0; /*0xffe28b49*/
count = v3[2]; /*0xffe28b4f*/
src = (char *)(v3 + 4); /*0xffe28b56*/
v7 = (char *)(v4 + 4); /*0xffe28b5a*/
if ( v3 + 4 < (_DWORD *)((char *)v3 + count * v3[3] + 16) ) /*0xffe28b63*/
{
v8 = 16 - (_DWORD)v4; /*0xffe28b65*/
do /*0xffe28ba7*/
{
if ( count ) /*0xffe28b69*/
{
sub_FFE238C8(v7 + 8, src, count); /*0xffe28b73*/
src_1 = (unsigned int)src; /*0xffe28b79*/
}
*((_DWORD *)v7 + 1) = 0; /*0xffe28b7d*/
*(_DWORD *)v7 = &v7[v8 + 8]; /*0xffe28b86*/
v7 += 48; /*0xffe28b88*/
count = v3[2]; /*0xffe28b8b*/
src = (char *)(count + src_1); /*0xffe28b90*/
src_1 += count; /*0xffe28ba3*/
}
while ( src_1 < (unsigned int)v3 + count * v3[3] + 16 ); /*0xffe28ba7*/
}
}
return v3; /*0xffe28bb1*/
}
// ============================================================================
// 0xffe28bb7 BootGuardIsAcmPostSuccess
// ============================================================================
int __thiscall BootGuardIsAcmPostSuccess(void *this)
{
int v1; // ecx
int v3; // [esp-4h] [ebp-4h]
v1 = sub_FFE2A390(this); /*0xffe28bbd*/
if ( !v1 ) /*0xffe28bc1*/
{
sub_FFE28ABD(); /*0xffe28bc3*/
v1 = sub_FFE2A390(v3); /*0xffe28bcd*/
}
return v1 != 0 ? v1 + 48 : 0;
}
// ============================================================================
// 0xffe28bda BootGuardGetFitEntryCount
// ============================================================================
unsigned int __thiscall BootGuardGetFitEntryCount(char *this)
{
char *v1; // esi
char *v2; // edi
unsigned int v3; // esi
if ( this /*0xffe28c0e*/
&& (v1 = this - 8, v2 = &v1[-*(_DWORD *)v1], sub_FFE239A6((int)(v2 + 8), (int)&unk_FFE2C534))
&& (v3 = (unsigned int)&v1[*((_DWORD *)v2 + 8)], (unsigned int)(v2 + 40) <= v3)
&& (unsigned int)&v2[*((unsigned __int16 *)v2 + 1)] > v3 )
{
return v3 + 8; /*0xffe28c10*/
}
else
{
return 0; /*0xffe28c15*/
}
}
// ============================================================================
// 0xffe28c1b BootGuardInitialize
// ============================================================================
int __fastcall BootGuardInitialize(int a1, int n50563586)
{
if ( byte_FFE2C634 ) /*0xffe28c22*/
return sub_FFE2A49B(a1, n50563586); /*0xffe28c27*/
else
return -2147483645; /*0xffe28c30*/
}
// ============================================================================
// 0xffe28c36 BootGuardCheckCapability
// ============================================================================
char BootGuardCheckCapability()
{
unsigned __int64 v0; // rax
v0 = __readmsr(0x13Au); /*0xffe28c3c*/
if ( (v0 & 0x100000000LL) != 0 ) /*0xffe28c45*/
{
sub_FFE23AA9(64, "[BootGuardTCG2.c] Bit 32 BootGuardCapability = 1 in MSR 0x13A\n"); /*0xffe28c4e*/
sub_FFE23AA9(64, "[BootGuardTCG2.c] Processor supports Boot Guard.\n"); /*0xffe28c5a*/
return 1; /*0xffe28c62*/
}
else
{
sub_FFE23AA9(0x80000000, "[BootGuardTCG2.c] Bit 32 BootGuardCapability = 0 in MSR 0x13A\n"); /*0xffe28c71*/
sub_FFE23AA9(0x80000000, "[BootGuardTCG2.c] Processor does not support Boot Guard.\n"); /*0xffe28c7c*/
return 0; /*0xffe28c84*/
}
}
// ============================================================================
// 0xffe28c88 BootGuardPrintHexBuffer
// ============================================================================
int __fastcall BootGuardPrintHexBuffer(unsigned int i_1, int a2)
{
unsigned int i; // ebx
for ( i = 0; i < i_1; ++i ) /*0xffe28c99*/
{
if ( (i & 0xF) == 0 ) /*0xffe28c9e*/
sub_FFE23AA9(64, "\n"); /*0xffe28ca3*/
sub_FFE23AA9(64, " %02x", *(unsigned __int8 *)(i + a2)); /*0xffe28cb6*/
}
return sub_FFE23AA9(64, "\n"); /*0xffe28ccd*/
}
// ============================================================================
// 0xffe28cd2 BootGuardPrintStructId
// ============================================================================
int __thiscall BootGuardPrintStructId(unsigned __int8 *this)
{
unsigned int i; // esi
sub_FFE23AA9(64, "StructureID:"); /*0xffe28cdd*/
for ( i = 0; i < 8; ++i ) /*0xffe28ce4*/
sub_FFE23AA9(64, "%c", *(this + i)); /*0xffe28cf2*/
return sub_FFE23AA9(64, "\nStructVersion[%02x]\n", *(this + 8)); /*0xffe28d14*/
}
// ============================================================================
// 0xffe28d17 BootGuardCheckMsrBootState
// ============================================================================
int BootGuardCheckMsrBootState()
{
unsigned __int64 v0; // rax
char v1; // bl
const char *[BootGuardTCG2.c]_NEM_enabled_in_MSR_0x13A_n; // [esp-4h] [ebp-14h]
v0 = __readmsr(0x13Au); /*0xffe28d20*/
v1 = v0; /*0xffe28d22*/
if ( (v0 & 1) != 0 ) /*0xffe28d27*/
[BootGuardTCG2.c]_NEM_enabled_in_MSR_0x13A_n = "[BootGuardTCG2.c] NEM enabled in MSR 0x13A\n"; /*0xffe28d29*/
else
[BootGuardTCG2.c]_NEM_enabled_in_MSR_0x13A_n = "[BootGuardTCG2.c] NEM disable in MSR 0x13A\n"; /*0xffe28d30*/
sub_FFE23AA9(64, [BootGuardTCG2.c]_NEM_enabled_in_MSR_0x13A_n); /*0xffe28d39*/
if ( (v1 & 0x20) != 0 ) /*0xffe28d43*/
sub_FFE23AA9(64, "[BootGuardTCG2.c] Measure Boot enabled in MSR 0x13A\n"); /*0xffe28d4a*/
else
sub_FFE23AA9(64, "[BootGuardTCG2.c] Measure Boot disable in MSR 0x13A\n"); /*0xffe28d52*/
if ( (v1 & 8) != 0 ) /*0xffe28d5c*/
sub_FFE23AA9(64, "[BootGuardTCG2.c] Tpm Success in MSR 0x13A\n"); /*0xffe28d63*/
else
sub_FFE23AA9(64, "[BootGuardTCG2.c] Tpm Fail in MSR 0x13A\n"); /*0xffe28d6b*/
if ( (v1 & 0x29) == 0x29 )
{
sub_FFE23AA9(64, "[BootGuardTCG2.c] : ACM_PostSuccess : EFI_SUCCESS\n");
return 0; /*0xffe28d85*/
}
else
{
sub_FFE23AA9(64, "[BootGuardTCG2.c] : ACM_PostSuccess : EFI_UNSUPPORTED\n");
return -2147483645; /*0xffe28d94*/
}
}
// ============================================================================
// 0xffe28da0 BootGuardReadFitPointer
// ============================================================================
unsigned __int64 BootGuardReadFitPointer()
{
unsigned __int64 result; // rax
result = __readmsr(0x13Au) >> 4; /*0xffe28ded*/
LOBYTE(result) = (2 /*0xffe28df2*/
* (((MEMORY[0xFED3032C] & 0x20) != 0)
| (2
* (((MEMORY[0xFED3032C] & 0x40) != 0)
| (2 * (((MEMORY[0xFED3032C] & 0x80) != 0) | (2 * (MEMORY[0xFED3032D] & 1))))))))
| result & 1;
return result; /*0xffe28df4*/
}
// ============================================================================
// 0xffe28df9 BootGuardReadBpmMsr
// ============================================================================
char BootGuardReadBpmMsr()
{
unsigned __int64 v0; // rax
char v2; // [esp+4h] [ebp-4h]
v2 = MEMORY[0xFED3032C]; /*0xffe28e05*/
v0 = __readmsr(0x13Au); /*0xffe28e0d*/
return ((v0 & 0x20) != 0) | (2 * (((v0 & 0x40) != 0) | (2 * ((v2 & 0x10) != 0)))); /*0xffe28e3f*/
}
// ============================================================================
// 0xffe28e44 BootGuardGetTcgHob
// ============================================================================
int __cdecl BootGuardGetTcgHob(int a1, int a2, int Boot_Guard_Measured_S_CRTM, int n27)
{
int v4; // ecx
int v5; // ebp
_WORD *v7; // eax
_WORD *v8; // ebx
char *v9; // edi
_WORD *v10; // [esp+10h] [ebp-4h] BYREF
v5 = v4; /*0xffe28e47*/
if ( (*(int (__cdecl **)(int, _WORD **))(*(_DWORD *)v4 + 48))(v4, &v10) < 0 )
{
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not locate PEI HOB Logs\n", 285);
return -2147483634; /*0xffe28e79*/
}
v7 = sub_FFE2A364((int)&unk_FFE2C608, v10); /*0xffe28e84*/
if ( !v7 )
{
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not Find TCG HOB Logs\n", 292);
return -2147483634; /*0xffe28e99*/
}
v8 = v7 + 12; /*0xffe28e9e*/
v9 = (char *)v7 + *((_DWORD *)v7 + 7) + 24; /*0xffe28ea1*/
*((_DWORD *)v9 + 10) = 0; /*0xffe28ea9*/
*((_DWORD *)v9 + 11) = 7; /*0xffe28ead*/
v9 += 48; /*0xffe28eb4*/
(*(void (__cdecl **)(char *, int, int))(*(_DWORD *)v5 + 80))(v9, a2, 20); /*0xffe28ebb*/
*((_DWORD *)v9 + 5) = n27; /*0xffe28ec5*/
v9 += 24; /*0xffe28ec8*/
(*(void (__cdecl **)(char *, int, int))(*(_DWORD *)v5 + 80))(v9, Boot_Guard_Measured_S_CRTM, n27); /*0xffe28ed4*/
++*((_DWORD *)v8 + 2); /*0xffe28ee1*/
*((_DWORD *)v8 + 1) = v9 - (char *)v8 + n27 - 40; /*0xffe28ee4*/
return 0; /*0xffe28ee9*/
}
// ============================================================================
// 0xffe28eef CreateBootGuardTpm12Event
// ============================================================================
int __cdecl CreateBootGuardTpm12Event(int a1, int a2)
{
int v2; // ecx
int v3; // esi
int v5; // [esp-4h] [ebp-60h]
_BYTE v6[68]; // [esp+8h] [ebp-54h] BYREF
int v7; // [esp+4Ch] [ebp-10h] BYREF
int n804; // [esp+50h] [ebp-Ch] BYREF
int v9; // [esp+54h] [ebp-8h] BYREF
v3 = v2; /*0xffe28f02*/
sub_FFE23AA9(64, "BootGuardTCG2.c[%d] : Enter CreateBootGuardTPM12Event(...)\n", 341);
(*(void (__cdecl **)(_BYTE *, int, _DWORD))(*(_DWORD *)v3 + 84))(v6, 64, 0); /*0xffe28f16*/
if ( (*(int (__cdecl **)(int, int *))(*(_DWORD *)v3 + 48))(v3, &v9) < 0 )
{
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not locate PEI HOB Logs\n", 349);
return -2147483634; /*0xffe28f48*/
}
if ( !sub_FFE2A364(&unk_FFE2C608, v9) )
{
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not Find TCG HOB Logs\n", 356);
return -2147483634; /*0xffe28f65*/
}
v7 = a2; /*0xffe28f6d*/
n804 = 804; /*0xffe28f75*/
sub_FFE23AF1(1, (int)&v7, (int)&n804, (int)v6); /*0xffe28f82*/
return sub_FFE28E44(v5, (int)v6, (int)"Boot Guard Measured S-CRTM", 27); /*0xffe28f9f*/
}
// ============================================================================
// 0xffe28fa4 LogBootGuardTpm20Event
// ============================================================================
int __fastcall LogBootGuardTpm20Event(int this, int a2, int n7, int a4, int a5, int FIT_Type_0x02_Measured_S_CRTM, int n30)
{
_WORD *v10; // eax
_WORD *v11; // ebx
_DWORD *v12; // edi
_DWORD *v13; // edi
_DWORD *v14; // esi
char *v15; // edi
char *v16; // edi
_DWORD *v17; // edi
char *v18; // edi
char *v19; // ecx
int v20; // eax
_WORD *v21; // [esp+14h] [ebp-4h] BYREF
sub_FFE23AA9(64, "BootGuardTCG2.c[%d] : Enter LogBootGuardTPM20Event(...)\n", 394);
if ( (*(int (__cdecl **)(int, _WORD **))(*(_DWORD *)this + 48))(this, &v21) < 0 )
{
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not locate PEI HOB Logs\n", 400);
return -2147483634; /*0xffe28ff0*/
}
v10 = sub_FFE2A364((int)&unk_FFE2C5D8, v21); /*0xffe28ffe*/
if ( !v10 )
{
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not Find TCG HOB Logs\n", 408);
return -2147483634; /*0xffe29013*/
}
v11 = v10 + 12; /*0xffe29015*/
sub_FFE23AA9(64, "BootGuardTCG2.c[%d] : TcgLog Addr 0x%x\n", 413, v10 + 12);
if ( (*((_DWORD *)v11 + 8) & 3) != 0 )
{
if ( !*((_DWORD *)v11 + 3) )
{
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : For Invalid parameter\n", 424);
return -2147483634; /*0xffe29067*/
}
v12 = (_DWORD *)*((_DWORD *)v11 + 4); /*0xffe2906c*/
*v12++ = a2; /*0xffe29076*/
*v12 = n7; /*0xffe2907a*/
v13 = v12 + 1; /*0xffe2907c*/
if ( *((_DWORD *)v11 + 3) == 1 ) /*0xffe29082*/
{
(*(void (__cdecl **)(_DWORD *, int, int))(*(_DWORD *)this + 80))(v13, a4, 20); /*0xffe2908e*/
v13 += 5; /*0xffe29094*/
}
else if ( *((_DWORD *)v11 + 3) == 2 ) /*0xffe2909d*/
{
*v13 = 0; /*0xffe2909f*/
v14 = v13++; /*0xffe290a2*/
if ( (v11[16] & 1) != 0 ) /*0xffe290aa*/
{
*(_WORD *)v13 = 4; /*0xffe290ac*/
v15 = (char *)v13 + 2; /*0xffe290af*/
++*v14; /*0xffe290b2*/
(*(void (__cdecl **)(char *, int, int))(*(_DWORD *)this + 80))(v15, a4, 20); /*0xffe290be*/
v13 = v15 + 20; /*0xffe290c4*/
}
if ( (v11[16] & 2) != 0 ) /*0xffe290cb*/
{
*(_WORD *)v13 = 11; /*0xffe290d0*/
v16 = (char *)v13 + 2; /*0xffe290d3*/
++*v14; /*0xffe290d6*/
(*(void (__cdecl **)(char *, int, int))(*(_DWORD *)this + 80))(v16, a5, 32); /*0xffe290e2*/
v13 = v16 + 32; /*0xffe290e8*/
}
}
*v13 = n30; /*0xffe290ef*/
v17 = v13 + 1; /*0xffe290f1*/
(*(void (__cdecl **)(_DWORD *, int, int))(*(_DWORD *)this + 80))(v17, FIT_Type_0x02_Measured_S_CRTM, n30); /*0xffe290fd*/
v18 = (char *)v17 + n30; /*0xffe29103*/
*((_DWORD *)v11 + 6) = *((_DWORD *)v11 + 4); /*0xffe29107*/
v19 = &v18[-*((_DWORD *)v11 + 4)]; /*0xffe2910a*/
v20 = *((_DWORD *)v11 + 5); /*0xffe29110*/
*((_DWORD *)v11 + 5) = 0; /*0xffe29113*/
*((_DWORD *)v11 + 1) += v19; /*0xffe29117*/
++*((_DWORD *)v11 + 2); /*0xffe2911a*/
*((_DWORD *)v11 + 7) = v20; /*0xffe2911d*/
*((_DWORD *)v11 + 4) = v18; /*0xffe29122*/
return 0; /*0xffe29120*/
}
else
{
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Err ActPcrBanks, No SHA1/SHA256 banks\n", 417);
return -2147483646; /*0xffe2904d*/
}
}
// ============================================================================
// 0xffe2912c CreateBootGuardTpm20Event
// ============================================================================
int __fastcall CreateBootGuardTpm20Event(
int a1,
int n7,
int n3,
unsigned __int8 *src_2,
int n100,
int Boot_Guard_Measured_S_CRTM,
int n17)
{
_WORD *v10; // eax
_WORD *v11; // esi
unsigned int n2; // eax
int n100_1; // [esp+10h] [ebp-40h] BYREF
unsigned __int8 *src; // [esp+14h] [ebp-3Ch] BYREF
_WORD *v15; // [esp+18h] [ebp-38h] BYREF
_BYTE v16[20]; // [esp+1Ch] [ebp-34h] BYREF
_BYTE src_1[32]; // [esp+30h] [ebp-20h] BYREF
sub_FFE23AA9(64, "BootGuardTCG2.c[%d] : Enter CreateBootGuardTPM20Event(...)\n", 503);
(*(void (__cdecl **)(_BYTE *, int, _DWORD))(*(_DWORD *)a1 + 84))(v16, 20, 0); /*0xffe29156*/
(*(void (__cdecl **)(_BYTE *, int, _DWORD))(*(_DWORD *)a1 + 84))(src_1, 32, 0); /*0xffe29167*/
if ( (*(int (__cdecl **)(int, _WORD **))(*(_DWORD *)a1 + 48))(a1, &v15) < 0 )
{
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not locate PEI HOB Logs\n", 513);
return -2147483634; /*0xffe2919a*/
}
v10 = sub_FFE2A364((int)&unk_FFE2C5D8, v15); /*0xffe291a8*/
if ( !v10 )
{
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not Find TCG HOB Logs\n", 521);
return -2147483634; /*0xffe291bd*/
}
v11 = v10 + 12; /*0xffe291bf*/
sub_FFE23AA9(64, "BootGuardTCG2.c[%d] : TcgLog Addr 0x%x\n", 526, v10 + 12);
src = src_2; /*0xffe291df*/
n2 = *((_DWORD *)v11 + 3); /*0xffe291e3*/
n100_1 = n100; /*0xffe291e6*/
if ( n2 < 2 ) /*0xffe291ed*/
{
sub_FFE23AF1(1, (int)&src, (int)&n100_1, (int)v16); /*0xffe2924d*/
}
else if ( n2 == 2 ) /*0xffe291f6*/
{
if ( (v11[16] & 1) != 0 && n100 ) /*0xffe29200*/
sub_FFE23AF1(1, (int)&src, (int)&n100_1, (int)v16); /*0xffe29213*/
if ( (v11[16] & 2) != 0 ) /*0xffe2921e*/
{
if ( n100 ) /*0xffe29222*/
sub_FFE24EF3(1, &src, (int)&n100_1, src_1); /*0xffe29235*/
}
}
return sub_FFE28FA4(a1, n7, n3, (int)v16, (int)src_1, Boot_Guard_Measured_S_CRTM, n17); /*0xffe29276*/
}
// ============================================================================
// 0xffe2927e BootGuardFindBpmStruct
// ============================================================================
int __fastcall BootGuardFindBpmStruct(int *a1, int a2)
{
int v4; // eax
_DWORD v5[2]; // [esp+8h] [ebp-110h] BYREF
__int16 v6; // [esp+10h] [ebp-108h]
int v7; // [esp+12h] [ebp-106h]
int n8; // [esp+16h] [ebp-102h]
_BYTE v9[238]; // [esp+1Ah] [ebp-FEh] BYREF
_DWORD v10[4]; // [esp+108h] [ebp-10h] BYREF
v10[0] = 1416362782; /*0xffe2928a*/
v10[1] = 1079319820; /*0xffe29291*/
v10[2] = -196170332; /*0xffe29298*/
v10[3] = 985143231; /*0xffe2929f*/
if ( !a2 ) /*0xffe292a9*/
return -2147483634; /*0xffe292ab*/
v5[0] = 34; /*0xffe292b4*/
n8 = 8; /*0xffe292bf*/
v6 = 1; /*0xffe292c9*/
v4 = *a1; /*0xffe292d2*/
v5[1] = 14; /*0xffe292e0*/
v7 = 0; /*0xffe292eb*/
(*(void (__cdecl **)(_BYTE *, _DWORD *, int))(v4 + 80))(v9, v10, 16); /*0xffe292f1*/
return (*(int (__cdecl **)(int, _DWORD, _DWORD, _BYTE *, _DWORD, int, _DWORD, _DWORD *))(a2 + 8))( /*0xffe2930f*/
a2,
0,
0,
v9,
0,
16,
0,
v5);
}
// ============================================================================
// 0xffe29315 BootGuardCheckAmiTreePpi
// ============================================================================
int __thiscall BootGuardCheckAmiTreePpi(int *this)
{
int v2; // eax
int v3; // eax
int v4; // esi
_DWORD v6[8]; // [esp+10h] [ebp-128h] BYREF
_BYTE v7[224]; // [esp+30h] [ebp-108h] BYREF
_BYTE v8[4]; // [esp+110h] [ebp-28h] BYREF
_DWORD v9[4]; // [esp+114h] [ebp-24h] BYREF
int (__cdecl **v10)(_DWORD, void *, _DWORD *, int, _DWORD *, _BYTE *); // [esp+124h] [ebp-14h] BYREF
_DWORD v11[4]; // [esp+128h] [ebp-10h] BYREF
v11[0] = 1416362782; /*0xffe29325*/
v11[1] = 1079319820; /*0xffe29331*/
v2 = *this; /*0xffe29338*/
v11[2] = -196170332; /*0xffe29343*/
v11[3] = 985143231; /*0xffe2934b*/
v10 = 0; /*0xffe29352*/
v9[0] = 394082770; /*0xffe29355*/
v9[1] = 1086866360; /*0xffe2935c*/
v9[2] = 1362944410; /*0xffe29363*/
v9[3] = 513070744; /*0xffe2936a*/
v6[0] = 0; /*0xffe29371*/
v6[1] = 8; /*0xffe29377*/
v6[7] = 16; /*0xffe29381*/
(*(void (__cdecl **)(_BYTE *, _DWORD *, int))(v2 + 80))(v7, v11, 16); /*0xffe29387*/
v3 = (*(int (__cdecl **)(int *, _DWORD *, _DWORD, _DWORD, int (__cdecl ***)(_DWORD, void *, _DWORD *, int, _DWORD *, _BYTE *)))(*this + 32))( /*0xffe29397*/
this,
v9,
0,
0,
&v10);
v4 = v3; /*0xffe2939a*/
if ( v3 >= 0 ) /*0xffe293a1*/
return (*v10)(v10, this, v11, 16, v6, v8); /*0xffe293d4*/
sub_FFE23AA9(0x80000000, "[%d]: gTcgPpiguid NOT found %r \n", 645, v3);
return v4; /*0xffe293d9*/
}
// ============================================================================
// 0xffe293e0 BootGuardDetectTpmDevice
// ============================================================================
int __thiscall BootGuardDetectTpmDevice(int *this)
{
int v2; // eax
int v3; // eax
int v5; // eax
_DWORD v7[4]; // [esp+Ch] [ebp-1Ch] BYREF
int v8; // [esp+1Ch] [ebp-Ch] BYREF
int v9; // [esp+20h] [ebp-8h] BYREF
int v10; // [esp+24h] [ebp-4h] BYREF
v7[0] = 394082770; /*0xffe293ea*/
v7[1] = 1086866360; /*0xffe293f3*/
v10 = 0; /*0xffe293fd*/
v2 = *this; /*0xffe29401*/
v8 = 0; /*0xffe2940b*/
v7[2] = 1362944410; /*0xffe2940e*/
v7[3] = 513070744; /*0xffe29415*/
if ( (*(int (__cdecl **)(int *, void *, _DWORD, _DWORD, int *))(v2 + 32))(this, &unk_FFE2C5F8, 0, 0, &v10) < 0 )
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d] : Can not locate Ami Tree Ppi, It may TPM 1.2 Device\n", 702);
goto LABEL_11; /*0xffe29430*/
}
if ( (*(int (__cdecl **)(int *, int *))(*this + 48))(this, &v9) < 0 )
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d] : Can not locate PEI HOB Logs, It may TPM 1.2 Device\n", 710);
goto LABEL_11; /*0xffe2944c*/
}
v3 = sub_FFE2A364(&unk_FFE2C5E8, v9); /*0xffe29456*/
if ( *(_BYTE *)(v3 + 24) != 1 )
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d] : TrEEDeviceHob->Tpm20DeviceState = 0, It may TPM 1.2 Device\n", 725);
LABEL_11:
v5 = (*(int (__cdecl **)(int *, _DWORD *, _DWORD, _DWORD, int *))(*this + 32))(this, v7, 0, 0, &v8); /*0xffe294ac*/
if ( v5 >= 0 )
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: TPM 1.2 found\n", 743);
return 1; /*0xffe29506*/
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: gTcgPpiguid NOT found %r\n", 738, v5);
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: No TPM\n", 739);
return 0; /*0xffe294ec*/
}
}
if ( *(_BYTE *)(v3 + 25) == 1 )
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: TPM 2.0 found\n", 718);
return 2; /*0xffe2947b*/
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: PTT found\n", 721);
return 3; /*0xffe29497*/
}
}
// ============================================================================
// 0xffe2950d BootGuardFindFitEntryInTable
// ============================================================================
int __fastcall BootGuardFindFitEntryInTable(unsigned __int8 a1, _DWORD *a2)
{
int v2; // esi
unsigned int v5; // edx
unsigned int v6; // ecx
int v7; // eax
int n64; // [esp-Ch] [ebp-18h]
const char *[BootGuardTCG2.c]_:_FindEntryInFit(%lx)_is_Invalid_n; // [esp-8h] [ebp-14h]
int v11; // [esp-4h] [ebp-10h]
v2 = 0; /*0xffe29513*/
if ( MEMORY[0xFFFFFFC0] == -1 || !MEMORY[0xFFFFFFC0] )
{
v11 = MEMORY[0xFFFFFFC0]; /*0xffe29551*/
[BootGuardTCG2.c]_:_FindEntryInFit(%lx)_is_Invalid_n = "[BootGuardTCG2.c] : FindEntryInFit(%lx) is Invalid\n";
n64 = 0x80000000; /*0xffe29557*/
goto LABEL_10; /*0xffe29557*/
}
v5 = *(_DWORD *)(MEMORY[0xFFFFFFC0] + 8); /*0xffe29524*/
v6 = 1; /*0xffe29529*/
if ( v5 <= 1 )
{
LABEL_7:
v11 = a1; /*0xffe2953e*/
[BootGuardTCG2.c]_:_FindEntryInFit(%lx)_is_Invalid_n = "[BootGuardTCG2.c] : Error, Did not find Tbl type = %x\n";
n64 = 64; /*0xffe29547*/
LABEL_10:
v2 = -2147483634; /*0xffe2955c*/
sub_FFE23AA9(n64, [BootGuardTCG2.c]_:_FindEntryInFit(%lx)_is_Invalid_n, v11); /*0xffe29561*/
return v2; /*0xffe29561*/
}
v7 = MEMORY[0xFFFFFFC0] + 16; /*0xffe2952e*/
while ( *(_BYTE *)(v7 + 14) != a1 ) /*0xffe29534*/
{
++v6; /*0xffe29536*/
v7 += 16; /*0xffe29537*/
if ( v6 >= v5 ) /*0xffe2953c*/
goto LABEL_7; /*0xffe2953c*/
}
*a2 = *(_DWORD *)v7; /*0xffe2954d*/
return v2; /*0xffe29569*/
}
// ============================================================================
// 0xffe2956f LogTpm20LocalityStartup
// ============================================================================
int __fastcall LogTpm20LocalityStartup(int a1, char n2)
{
_BYTE Boot_Guard_Measured_S_CRTM[20]; // [esp+Ch] [ebp-14h] BYREF
sub_FFE23AA9(64, "BootGuardTCG2.c[%d] : Enter LogTpm20LocalityStartupEvent(...)\n", 842);
if ( n2 ) /*0xffe29591*/
{
(*(void (__cdecl **)(_BYTE *, int, _DWORD))(*(_DWORD *)a1 + 84))(Boot_Guard_Measured_S_CRTM, 16, 0); /*0xffe2959d*/
(*(void (__cdecl **)(_BYTE *, const char *, int))(*(_DWORD *)a1 + 80))( /*0xffe295b0*/
Boot_Guard_Measured_S_CRTM,
"StartupLocality",
16);
Boot_Guard_Measured_S_CRTM[16] = 3; /*0xffe295b6*/
sub_FFE2912C(a1, 0, 3, 0, 0, (int)Boot_Guard_Measured_S_CRTM, 17); /*0xffe295ca*/
}
return 0; /*0xffe295d2*/
}
// ============================================================================
// 0xffe295da BootGuardSkipLogAuthority
// ============================================================================
int __fastcall BootGuardSkipLogAuthority(int a1, char n2)
{
int v4; // eax
int v6; // [esp+Ch] [ebp-4h] BYREF
v6 = 0; /*0xffe295df*/
v4 = sub_FFE2950D(0xCu, &v6); /*0xffe295ee*/
if ( v4 >= 0 )
{
if ( (*(_DWORD *)(v6 + 28) & 2) != 0 )
{
if ( n2 != 1 && (n2 == 2 || n2 == 3) ) /*0xffe2963d*/
sub_FFE2956F(a1, n2); /*0xffe29643*/
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Skip Log Authority Event\n", 893);
}
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: TRACE ERROR - %r\n", 884, v4);
}
return 0; /*0xffe29648*/
}
// ============================================================================
// 0xffe29650 LogAuthorityPcrEvent
// ============================================================================
int __fastcall LogAuthorityPcrEvent(int a1, char n2)
{
int v4; // eax
int v5; // edi
int v6; // eax
int v7; // eax
int n256_1; // esi
int v10; // [esp+10h] [ebp-74h] BYREF
int v11; // [esp+14h] [ebp-70h] BYREF
int n256; // [esp+18h] [ebp-6Ch] BYREF
unsigned __int8 v13; // [esp+1Ch] [ebp-68h] BYREF
unsigned __int8 v14; // [esp+1Dh] [ebp-67h]
unsigned __int16 v15; // [esp+1Eh] [ebp-66h]
char v16[32]; // [esp+20h] [ebp-64h] BYREF
char v17[32]; // [esp+40h] [ebp-44h] BYREF
char v18[36]; // [esp+60h] [ebp-24h] BYREF
n256 = 0; /*0xffe29666*/
v10 = 0; /*0xffe2966a*/
v11 = 0; /*0xffe2966e*/
sub_FFE23AA9(64, "[BootGuardTCG2.c] : Enter LogAuthorityPCREvent(...)\n");
v4 = sub_FFE2950D(0xCu, &v10); /*0xffe2967f*/
v5 = v4; /*0xffe29684*/
if ( v4 >= 0 )
{
if ( (*(_DWORD *)(v10 + 28) & 4) != 0 )
{
v13 = sub_FFE28DA0(); /*0xffe296cf*/
sub_FFE23AA9(64, "BP->RSTR:[%x]\n", v13); /*0xffe296dd*/
v14 = sub_FFE28DF9(); /*0xffe296ea*/
sub_FFE23AA9(64, "BP->TYPE:[%x]\n", v14); /*0xffe296f8*/
v6 = sub_FFE2950D(2u, &v11); /*0xffe29706*/
v5 = v6; /*0xffe2970b*/
if ( v6 >= 0 )
{
v15 = sub_FFE2A43A(v11 + 28); /*0xffe29728*/
sub_FFE23AA9(64, "BP->ACM_SVN = [%x]\n", v15); /*0xffe29737*/
(*(void (__cdecl **)(char *, int, int))(*(_DWORD *)a1 + 80))(v16, -19725312, 32); /*0xffe2974e*/
v7 = sub_FFE2950D(0xBu, &n256); /*0xffe2975a*/
v5 = v7; /*0xffe2975f*/
if ( v7 >= 0 )
{
n256_1 = n256; /*0xffe29770*/
n256 = 256; /*0xffe2977a*/
v11 = n256_1 + 58; /*0xffe29786*/
sub_FFE24EF3(1, (int)&v11, (int)&n256, (int)v17); /*0xffe29794*/
(*(void (__cdecl **)(char *, int, int))(*(_DWORD *)a1 + 80))(v18, n256_1 + 16, 32); /*0xffe297a7*/
sub_FFE23AA9(64, "BP Hash Structure, Size[%x]", 100); /*0xffe297b6*/
sub_FFE28C88(0x64u, (int)&v13); /*0xffe297c5*/
if ( n2 != 1 && (n2 == 2 || n2 == 3) ) /*0xffe297d7*/
return sub_FFE2912C(a1, 7, -2147483647, (int)&v13, 100, (int)L"Boot Guard Measured S-CRTM", 54); /*0xffe297f9*/
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: TRACE ERROR - %r\n", 989, v7);
}
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: TRACE ERROR - %r\n", 976, v6);
}
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Skip Log Authority Event\n", 959);
return 0; /*0xffe296c3*/
}
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: TRACE ERROR - %r\n", 951, v4);
}
return v5; /*0xffe297fd*/
}
// ============================================================================
// 0xffe29805 LogDetailPcrEvent
// ============================================================================
int __fastcall LogDetailPcrEvent(int a1, char n2)
{
int v4; // eax
int v5; // esi
__int16 v6; // ax
int v7; // eax
unsigned __int8 *v8; // esi
int v9; // eax
int v10; // edi
int v11; // esi
int v12; // ecx
unsigned __int8 *v14; // [esp+14h] [ebp-10h] BYREF
int v15; // [esp+18h] [ebp-Ch] BYREF
unsigned __int8 *v16; // [esp+1Ch] [ebp-8h] BYREF
int v17; // [esp+20h] [ebp-4h] BYREF
v14 = 0; /*0xffe2981d*/
v16 = 0; /*0xffe29821*/
v17 = 0; /*0xffe29825*/
v15 = 0; /*0xffe29829*/
sub_FFE23AA9(64, "[BootGuardTCG2.c] : Enter LogDetailPCREvent(...)\n");
if ( (*(int (__cdecl **)(int, int, unsigned __int8 **))(*(_DWORD *)a1 + 76))(a1, 804, &v14) < 0 ) /*0xffe29847*/
return -2147483639; /*0xffe29849*/
sub_FFE23AA9(64, "MSR[0x%x]:[%08x]\n", 314, (unsigned int)__readmsr(0x13Au)); /*0xffe29867*/
sub_FFE23AA9(64, "ACM_STATUS:[%08x]\n", MEMORY[0xFED30328]); /*0xffe2987b*/
*v14 = sub_FFE28DA0(); /*0xffe2988c*/
sub_FFE23AA9(64, "BP->RSTR:[%x]\n", *v14); /*0xffe2989c*/
v14[1] = sub_FFE28DF9(); /*0xffe298ad*/
sub_FFE23AA9(64, "BP->TYPE:[%x]\n", v14[1]); /*0xffe298bf*/
v4 = sub_FFE2950D(2u, &v15); /*0xffe298cd*/
if ( v4 >= 0 )
{
v5 = v15; /*0xffe298ef*/
v6 = sub_FFE2A43A(v15 + 28); /*0xffe298f6*/
*((_WORD *)v14 + 1) = v6; /*0xffe298ff*/
sub_FFE23AA9(64, "BP->ACM_SVN = [%x]\n", *((unsigned __int16 *)v14 + 1)); /*0xffe29912*/
(*(void (__cdecl **)(unsigned __int8 *, int, int))(*(_DWORD *)a1 + 80))(v14 + 4, v5 + 388, 256); /*0xffe29931*/
sub_FFE28C88(0x100u, (int)(v14 + 4)); /*0xffe29940*/
v7 = sub_FFE2950D(0xBu, &v16); /*0xffe2994b*/
if ( v7 >= 0 )
{
v8 = v16; /*0xffe2995c*/
sub_FFE23AA9(64, "\nKmStructure: Addr[%lx]\n", v16);
sub_FFE28CD2(v8); /*0xffe29971*/
(*(void (__cdecl **)(unsigned __int8 *, unsigned __int8 *, int))(*(_DWORD *)a1 + 80))(v14 + 260, v8 + 321, 256); /*0xffe2998a*/
sub_FFE28C88(0x100u, (int)(v14 + 260)); /*0xffe2999c*/
v9 = sub_FFE2950D(0xCu, &v17); /*0xffe299a7*/
if ( v9 >= 0 )
{
v10 = v17; /*0xffe299bb*/
sub_FFE23AA9(64, "\nBpmStructure: Addr[%lx]\n", v17);
sub_FFE28CD2((unsigned __int8 *)v10); /*0xffe299d0*/
sub_FFE23AA9(64, "BpmStructure->Ibb_Element.EntryPoint[%x]\n", *(_DWORD *)(v10 + 108)); /*0xffe299de*/
sub_FFE23AA9(64, "BpmStructure->Ibb_Element.SegmentCount[%x]\n", *(unsigned __int8 *)(v10 + 148)); /*0xffe299f4*/
v11 = 12 * *(unsigned __int8 *)(v10 + 148); /*0xffe29a03*/
sub_FFE23AA9(64, "\nBpmStructure->Bpm_Signature_Element.KeySignaturee"); /*0xffe29a0c*/
(*(void (__cdecl **)(unsigned __int8 *, int, int))(*(_DWORD *)a1 + 80))(v14 + 516, v11 + v10 + 431, 256); /*0xffe29a2b*/
sub_FFE28C88(0x100u, (int)(v14 + 516)); /*0xffe29a40*/
sub_FFE23AA9(64, "\n\nBpmStructure->Digest_of_Hashed_IBB_Segment:"); /*0xffe29a4b*/
(*(void (__cdecl **)(unsigned __int8 *, int, int))(*(_DWORD *)a1 + 80))(v14 + 772, v10 + 116, 32); /*0xffe29a62*/
sub_FFE28C88(0x20u, (int)(v14 + 772)); /*0xffe29a75*/
sub_FFE23AA9(64, "BP Hash Structure, Size[%x]", 804); /*0xffe29a86*/
sub_FFE28C88(0x324u, (int)v14); /*0xffe29a94*/
if ( n2 == 1 ) /*0xffe29a9f*/
{
sub_FFE28EEF(v12, (int)v14); /*0xffe29aab*/
}
else if ( n2 == 2 || n2 == 3 ) /*0xffe29ab8*/
{
sub_FFE2912C(a1, 0, 7, (int)v14, 804, (int)"Boot Guard Measured S-CRTM", 27); /*0xffe29acc*/
}
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: TRACE ERROR - %r\n", 1099, v9);
}
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: TRACE ERROR - %r\n", 1087, v7);
}
}
else
{
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: TRACE ERROR - %r\n", 1075, v4);
}
return 0; /*0xffe29ad6*/
}
// ============================================================================
// 0xffe29ade LogTxtTpm12CrtmEvent
// ============================================================================
int __thiscall LogTxtTpm12CrtmEvent(void *this)
{
int v1; // esi
int v2; // edi
unsigned int v3; // ebx
unsigned int v4; // eax
_BYTE *v5; // ebp
int v6; // ecx
int v7; // ebp
int v8; // ecx
unsigned int v9; // edx
int v10; // ecx
int *i; // eax
int v13; // [esp-4h] [ebp-90h]
int v14; // [esp-4h] [ebp-90h]
int v16; // [esp+18h] [ebp-74h] BYREF
unsigned int v17; // [esp+1Ch] [ebp-70h]
int v18; // [esp+20h] [ebp-6Ch]
_DWORD v19[5]; // [esp+24h] [ebp-68h] BYREF
_DWORD v20[10]; // [esp+38h] [ebp-54h] BYREF
_DWORD v21[11]; // [esp+60h] [ebp-2Ch] BYREF
v1 = 0; /*0xffe29af5*/
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Enter LogTxtTpm12CRTMEvent\n", 1175);
v2 = MEMORY[0xFFFFFFC0]; /*0xffe29b02*/
v18 = MEMORY[0xFFFFFFC0]; /*0xffe29b04*/
if ( MEMORY[0xFFFFFFC0] == -1 )
{
v1 = -2147483642; /*0xffe29b1a*/
sub_FFE23AA9(64, "[%d] : FitEntryPointer(%lx) is empty\n", 1183, -1);
}
else if ( *MEMORY[0xFFFFFFC0] == 1414088287 && *(_DWORD *)(MEMORY[0xFFFFFFC0] + 4) == 538976351 )
{
v3 = *(_DWORD *)(MEMORY[0xFFFFFFC0] + 8); /*0xffe29b45*/
if ( v3 > 1 )
{
v4 = v3 - 1; /*0xffe29b51*/
v5 = (_BYTE *)(MEMORY[0xFFFFFFC0] + 16); /*0xffe29b54*/
v17 = v3 - 1; /*0xffe29b57*/
do
{
if ( v5[14] == 2 )
{
v16 = *(_DWORD *)(*(_DWORD *)v5 + 20); /*0xffe29b74*/
(*(void (__cdecl **)(_DWORD *, int, _DWORD))(*(_DWORD *)this + 84))(v19, 20, 0); /*0xffe29b7a*/
v19[0] = v16; /*0xffe29b84*/
v1 = sub_FFE28E44(v6, (int)v19, (int)"FIT Type 0x02 Measured S-CRTM", 30); /*0xffe29b9c*/
if ( v1 < 0 )
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Error LogBootGuardTPM12Event(...)\n", 1219);
v4 = v17; /*0xffe29bb9*/
}
v5 += 16; /*0xffe29bbd*/
v17 = --v4; /*0xffe29bc3*/
}
while ( v4 );
v2 = v18; /*0xffe29bc9*/
if ( v1 < 0 )
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Error TRACE CODE\n", 1227);
}
v7 = 0; /*0xffe29be5*/
if ( v3 > 1 )
{
v8 = v2 + 24; /*0xffe29bec*/
v9 = v3 - 1; /*0xffe29bef*/
do /*0xffe29c0f*/
{
if ( *(_BYTE *)(v8 + 6) == 7 ) /*0xffe29bf6*/
{
v21[v7] = *(_DWORD *)(v8 - 8); /*0xffe29bfb*/
v20[v7++] = 16 * *(_DWORD *)v8; /*0xffe29c04*/
}
v8 += 16; /*0xffe29c09*/
--v9; /*0xffe29c0c*/
}
while ( v9 ); /*0xffe29c0f*/
if ( v7 )
{
sub_FFE23AF1(v7, (int)v21, (int)v20, (int)v19); /*0xffe29c25*/
v1 = sub_FFE28E44(v13, (int)v19, (int)"FIT Type 0x07 Measured S-CRTM", 30); /*0xffe29c44*/
if ( v1 < 0 )
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Error LogBootGuardTPM12Event(...)\n", 1259);
}
}
v16 = 0; /*0xffe29c67*/
v10 = 1; /*0xffe29c6e*/
if ( v3 > 1 )
{
for ( i = (int *)(v2 + 16); *((_BYTE *)i + 14) != 45; i += 4 ) /*0xffe29c77*/
{
if ( ++v10 >= v3 ) /*0xffe29c86*/
return v1; /*0xffe29c86*/
}
v16 = *i; /*0xffe29c90*/
v20[0] = 4; /*0xffe29c9a*/
v21[0] = &v16; /*0xffe29ca2*/
sub_FFE23AF1(1, (int)v21, (int)v20, (int)v19); /*0xffe29cb1*/
v1 = sub_FFE28E44(v14, (int)v19, (int)"FIT Type 0x2D Measured S-CRTM", 30); /*0xffe29ccc*/
if ( v1 < 0 )
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Error LogBootGuardTPM12Event(...)\n", 1291);
}
}
else
{
v1 = -2147483642; /*0xffe29cee*/
sub_FFE23AA9(64, "[%d] : [Type 0] FitEntry->TblAddress(%lx) is error\n", 1191, *MEMORY[0xFFFFFFC0]);
}
return v1; /*0xffe29d09*/
}
// ============================================================================
// 0xffe29d13 LogTxtTpm20CrtmEvent
// ============================================================================
int __thiscall LogTxtTpm20CrtmEvent(void *this)
{
int this_1; // ebp
int v2; // esi
int v3; // esi
unsigned int v4; // ebx
int v5; // edi
int v6; // esi
unsigned int v7; // ebp
int v8; // ebx
int v9; // eax
bool v10; // sf
int v11; // edi
int v12; // ecx
unsigned int v13; // edx
unsigned int v14; // ecx
int *v15; // eax
int v17; // [esp+14h] [ebp-A0h] BYREF
int this_2; // [esp+18h] [ebp-9Ch]
int v19; // [esp+1Ch] [ebp-98h]
int v20; // [esp+20h] [ebp-94h]
int v21; // [esp+24h] [ebp-90h]
unsigned int v22; // [esp+28h] [ebp-8Ch]
_BYTE v23[20]; // [esp+2Ch] [ebp-88h] BYREF
_DWORD p_n256[10]; // [esp+40h] [ebp-74h] BYREF
_DWORD v25[10]; // [esp+68h] [ebp-4Ch] BYREF
_BYTE v26[36]; // [esp+90h] [ebp-24h] BYREF
v19 = 0; /*0xffe29d19*/
this_1 = (int)this; /*0xffe29d27*/
this_2 = (int)this; /*0xffe29d30*/
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Enter LogTxtTpm20CRTMEvent\n", 1317);
v2 = MEMORY[0xFFFFFFC0]; /*0xffe29d3f*/
v21 = MEMORY[0xFFFFFFC0]; /*0xffe29d41*/
if ( MEMORY[0xFFFFFFC0] == -1 )
{
v3 = -2147483642; /*0xffe29d58*/
sub_FFE23AA9(64, "[%d] : FitEntryPointer(%lx) is empty\n", 1325, -1);
}
else if ( *MEMORY[0xFFFFFFC0] == 1414088287 && *(_DWORD *)(MEMORY[0xFFFFFFC0] + 4) == 538976351 )
{
v4 = *(_DWORD *)(MEMORY[0xFFFFFFC0] + 8); /*0xffe29d86*/
v20 = 0; /*0xffe29d89*/
v22 = v4; /*0xffe29d8e*/
if ( v4 > 1 )
{
v5 = MEMORY[0xFFFFFFC0] + 16; /*0xffe29d9b*/
v6 = v19; /*0xffe29d9e*/
v7 = v4 - 1; /*0xffe29da2*/
v8 = v20; /*0xffe29da5*/
do
{
if ( *(_BYTE *)(v5 + 14) == 2 )
{
v9 = *(_DWORD *)v5; /*0xffe29db3*/
p_n256[v8] = 4; /*0xffe29db9*/
v17 = *(_DWORD *)(v9 + 20); /*0xffe29dc4*/
v25[v8++] = &v17; /*0xffe29dcc*/
sub_FFE24EF3(v8, (int)v25, (int)p_n256, (int)v26); /*0xffe29de0*/
sub_FFE23AF1(v8, (int)v25, (int)p_n256, (int)v23); /*0xffe29df5*/
v6 = sub_FFE28FA4(this_2, 0, 7, (int)v23, (int)v26, (int)"FIT Type 0x02 Measured S-CRTM", 30); /*0xffe29e1b*/
if ( v6 < 0 )
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Error LogBootGuardTPM20Event(...)\n", 1366);
}
v5 += 16; /*0xffe29e38*/
--v7; /*0xffe29e3b*/
}
while ( v7 );
v4 = v22; /*0xffe29e44*/
v10 = v6 < 0; /*0xffe29e48*/
v2 = v21; /*0xffe29e4a*/
if ( v10 )
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Error TRACE CODE\n", 1374);
this_1 = this_2; /*0xffe29e64*/
}
v11 = 0; /*0xffe29e68*/
if ( v4 > 1 )
{
v12 = v2 + 24; /*0xffe29e73*/
v13 = v4 - 1; /*0xffe29e76*/
do /*0xffe29e96*/
{
if ( *(_BYTE *)(v12 + 6) == 7 ) /*0xffe29e7d*/
{
v25[v11] = *(_DWORD *)(v12 - 8); /*0xffe29e82*/
p_n256[v11++] = 16 * *(_DWORD *)v12; /*0xffe29e8b*/
}
v12 += 16; /*0xffe29e90*/
--v13; /*0xffe29e93*/
}
while ( v13 ); /*0xffe29e96*/
if ( v11 )
{
sub_FFE24EF3(v11, (int)v25, (int)p_n256, (int)v26); /*0xffe29eaf*/
sub_FFE23AF1(v11, (int)v25, (int)p_n256, (int)v23); /*0xffe29ec4*/
if ( sub_FFE28FA4(this_1, 0, 7, (int)v23, (int)v26, (int)"FIT Type 0x07 Measured S-CRTM", 30) < 0 )
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Error LogBootGuardTPM20Event(...)\n", 1408);
}
}
v17 = 0; /*0xffe29f03*/
v14 = 1; /*0xffe29f0b*/
if ( v4 > 1 ) /*0xffe29f0f*/
{
v15 = (int *)(v2 + 16); /*0xffe29f11*/
while ( *((_BYTE *)v15 + 14) != 45 ) /*0xffe29f18*/
{
++v14; /*0xffe29f1a*/
v15 += 4; /*0xffe29f1b*/
if ( v14 >= v4 ) /*0xffe29f20*/
goto LABEL_28; /*0xffe29f20*/
}
v17 = *v15; /*0xffe29f26*/
}
LABEL_28:
p_n256[0] = 4; /*0xffe29f2a*/
v25[0] = &v17; /*0xffe29f36*/
sub_FFE24EF3(1, (int)v25, (int)p_n256, (int)v26); /*0xffe29f4d*/
sub_FFE23AF1(1, (int)v25, (int)p_n256, (int)v23); /*0xffe29f62*/
v3 = sub_FFE28FA4(this_1, 0, 7, (int)v23, (int)v26, (int)"FIT Type 0x2D Measured S-CRTM", 30); /*0xffe29f86*/
if ( v3 < 0 )
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Error LogBootGuardTPM20Event(...)\n", 1445);
}
else
{
v3 = -2147483642; /*0xffe29fb3*/
sub_FFE23AA9(64, "[%d] : [Type 0] FitEntry->TblAddress(%lx) is error\n", 1333, *MEMORY[0xFFFFFFC0]);
}
return v3; /*0xffe29fc0*/
}
// ============================================================================
// 0xffe29fcd BootGuardTcg2MeasureCrtm
// ============================================================================
int __cdecl BootGuardTcg2MeasureCrtm(int *a1)
{
char n2; // bl
unsigned __int64 v2; // rax
int v3; // eax
int v4; // eax
int v5; // eax
int v6; // eax
int v7; // eax
int v8; // eax
int v10[3]; // [esp+Ch] [ebp-Ch] BYREF
v10[0] = 0; /*0xffe29fe7*/
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: Enter BootGuardTcg2MeasureCRTMVersion\n", 1465);
n2 = sub_FFE293E0(a1); /*0xffe29fff*/
if ( (*(int (__cdecl **)(int *, void *, _DWORD, _DWORD, int *))(*a1 + 32))(a1, &unk_FFE2C5F8, 0, 0, v10) < 0 ) /*0xffe2a016*/
v10[0] = 0; /*0xffe2a018*/
if ( MEMORY[0xFED300A4] < 0 )
{
sub_FFE23AA9(64, "[BootGuardTCG2.c] Bit 63 success in 0xFED300A0\n"); /*0xffe2a057*/
LABEL_7:
if ( sub_FFE28C36() == 1 && sub_FFE28D17() >= 0 ) /*0xffe2a072*/
{
sub_FFE23AA9(64, "[BootGuardTCG2.c] Start the LogDetailPCREvent\n"); /*0xffe2a07f*/
v3 = sub_FFE295DA((int)a1, n2); /*0xffe2a08a*/
if ( v3 < 0 ) /*0xffe2a096*/
{
sub_FFE23AA9(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v3); /*0xffe2a09f*/
v4 = sub_FFE23A81(); /*0xffe2a0a7*/
if ( v4 ) /*0xffe2a0ae*/
(*(void (__cdecl **)(const char *, int, const char *))(v4 + 4))( /*0xffe2a0bf*/
"e:\\hs\\PurleyPlatPkg\\BootGuard\\BootGuardTCG2\\BootGuardTCG2.c",
1495,
"!EFI_ERROR (Status)");
}
v5 = sub_FFE29805((int)a1, n2); /*0xffe2a0c9*/
if ( v5 < 0 ) /*0xffe2a0d0*/
{
sub_FFE23AA9(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v5); /*0xffe2a0d9*/
v6 = sub_FFE23A81(); /*0xffe2a0e1*/
if ( v6 ) /*0xffe2a0e8*/
(*(void (__cdecl **)(const char *, int, const char *))(v6 + 4))( /*0xffe2a0f9*/
"e:\\hs\\PurleyPlatPkg\\BootGuard\\BootGuardTCG2\\BootGuardTCG2.c",
1497,
"!EFI_ERROR (Status)");
}
v7 = sub_FFE29650((int)a1, n2); /*0xffe2a103*/
if ( v7 < 0 ) /*0xffe2a10a*/
{
sub_FFE23AA9(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v7); /*0xffe2a117*/
v8 = sub_FFE23A81(); /*0xffe2a11f*/
if ( v8 ) /*0xffe2a126*/
(*(void (__cdecl **)(const char *, int, const char *))(v8 + 4))( /*0xffe2a13b*/
"e:\\hs\\PurleyPlatPkg\\BootGuard\\BootGuardTCG2\\BootGuardTCG2.c",
1499,
"!EFI_ERROR (Status)");
}
goto LABEL_27; /*0xffe2a13e*/
}
if ( sub_FFE2956F((int)a1, n2) < 0 )
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not Find TCG HOB Logs\n", 1507);
if ( n2 == 1 )
{
if ( sub_FFE29ADE(a1) >= 0 )
{
LABEL_27:
sub_FFE23AA9(64, "BootGuardTCG2.c[%d]: End of BootGuardTcg2MeasureCRTMVersion\n", 1524);
goto LABEL_28; /*0xffe2a1bc*/
}
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not Find TCG HOB Logs\n", 1513);
}
if ( (n2 == 2 || n2 == 3) && sub_FFE29D13(a1) < 0 )
sub_FFE23AA9(0x80000000, "BootGuardTCG2.c[%d] : Can not Find TCG HOB Logs\n", 1520);
goto LABEL_27; /*0xffe2a1a8*/
}
sub_FFE23AA9(64, "[BootGuardTCG2.c] Bit 63 fail in 0xFED300A0\n"); /*0xffe2a035*/
v2 = __readmsr(0x13Au); /*0xffe2a041*/
if ( (v2 & 0x20) != 0 ) /*0xffe2a048*/
goto LABEL_7; /*0xffe2a048*/
LABEL_28:
if ( n2 != 1 && (n2 == 2 || n2 == 3) ) /*0xffe2a1da*/
sub_FFE2927E(a1, v10[0]); /*0xffe2a1e2*/
else
sub_FFE29315(a1); /*0xffe2a1cb*/
return 0; /*0xffe2a1e7*/
}
// ============================================================================
// 0xffe2a1f0 BootGuardFitGetEntryType
// ============================================================================
int BootGuardFitGetEntryType()
{
unsigned __int8 v0; // al
char n3; // al
char n3_1; // cl
v0 = __inbyte(0x70u); /*0xffe2a1f6*/
__outbyte(0x70u, v0 & 0x80 | 0x4A); /*0xffe2a1fb*/
n3 = __inbyte(0x71u); /*0xffe2a202*/
n3_1 = n3; /*0xffe2a203*/
if ( (unsigned __int8)n3 <= 3u ) /*0xffe2a208*/
{
LABEL_4:
if ( !n3_1 ) /*0xffe2a223*/
return 0; /*0xffe2a223*/
goto LABEL_5; /*0xffe2a223*/
}
n3_1 = n3; /*0xffe2a20a*/
if ( !n3 ) /*0xffe2a212*/
{
n3_1 = MEMORY[0xFDAF0490] & 2 | 1; /*0xffe2a21e*/
goto LABEL_4; /*0xffe2a21e*/
}
LABEL_5:
if ( n3_1 != -1 )
return n3_1 != 1 ? -2147483578 : -2147483644;
return 0; /*0xffe2a23b*/
}
// ============================================================================
// 0xffe2a23f PeiServicesGetPointer
// ============================================================================
int PeiServicesGetPointer()
{
int v0; // esi
_BYTE v2[2]; // [esp+4h] [ebp-8h] BYREF
int v3; // [esp+6h] [ebp-6h]
sub_FFE2A271(v2); /*0xffe2a248*/
v0 = *(_DWORD *)(v3 - 4); /*0xffe2a250*/
if ( !v0 ) /*0xffe2a255*/
sub_FFE23AD3( /*0xffe2a264*/
(int)"e:\\hs\\MdePkg\\Library\\PeiServicesTablePointerLibIdt\\PeiServicesTablePointer.c",
48,
(int)"PeiServices != ((void *) 0)");
return v0; /*0xffe2a26c*/
}
// ============================================================================
// 0xffe2a271 BaseReadIdtr
// ============================================================================
void *__thiscall BaseReadIdtr(void *this)
{
void *this_1; // eax
if ( !this ) /*0xffe2a277*/
sub_FFE23AD3((int)"e:\\hs\\MdePkg\\Library\\BaseLib\\X86ReadIdtr.c", 37, (int)"Idtr != ((void *) 0)"); /*0xffe2a286*/
this_1 = this; /*0xffe2a28c*/
__sidt(this); /*0xffe2a28f*/
return this_1; /*0xffe2a293*/
}
// ============================================================================
// 0xffe2a2b1 InternalGetHobList
// ============================================================================
int InternalGetHobList()
{
int v0; // eax
int v1; // eax
int v2; // eax
int v3; // eax
int v5; // [esp+4h] [ebp-4h] BYREF
v0 = sub_FFE2A23F(); /*0xffe2a2b6*/
v1 = (*(int (__cdecl **)(int, int *))(*(_DWORD *)v0 + 48))(v0, &v5); /*0xffe2a2c2*/
if ( v1 < 0 ) /*0xffe2a2ce*/
{
sub_FFE23AA9(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v1); /*0xffe2a2db*/
v2 = sub_FFE23A81(); /*0xffe2a2e3*/
if ( v2 ) /*0xffe2a2ea*/
(*(void (__cdecl **)(const char *, int, const char *))(v2 + 4))( /*0xffe2a2f4*/
"e:\\hs\\MdePkg\\Library\\PeiHobLib\\HobLib.c",
50,
"!EFI_ERROR (Status)");
}
if ( !v5 ) /*0xffe2a2fe*/
{
v3 = sub_FFE23A81(); /*0xffe2a300*/
if ( v3 ) /*0xffe2a307*/
(*(void (__cdecl **)(const char *, int, const char *))(v3 + 4))( /*0xffe2a311*/
"e:\\hs\\MdePkg\\Library\\PeiHobLib\\HobLib.c",
51,
"HobList != ((void *) 0)");
}
return v5; /*0xffe2a31a*/
}
// ============================================================================
// 0xffe2a31f GetFirstHob
// ============================================================================
_WORD *__fastcall GetFirstHob(int a1, _WORD *a2)
{
_WORD *v2; // esi
int v3; // eax
v2 = a2; /*0xffe2a320*/
if ( !a2 ) /*0xffe2a324*/
{
v3 = sub_FFE23A81(); /*0xffe2a326*/
if ( v3 ) /*0xffe2a32d*/
(*(void (__cdecl **)(const char *, int, const char *))(v3 + 4))( /*0xffe2a33b*/
"e:\\hs\\MdePkg\\Library\\PeiHobLib\\HobLib.c",
82,
"HobStart != ((void *) 0)");
}
while ( 1 ) /*0xffe2a354*/
{
if ( *v2 == 0xFFFF ) /*0xffe2a35a*/
return 0; /*0xffe2a35f*/
if ( *v2 == 4 ) /*0xffe2a34c*/
break; /*0xffe2a34c*/
v2 = (_WORD *)((char *)v2 + (unsigned __int16)v2[1]); /*0xffe2a352*/
}
return v2; /*0xffe2a35e*/
}
// ============================================================================
// 0xffe2a364 GetNextHob
// ============================================================================
_WORD *__fastcall GetNextHob(int a1, _WORD *a2)
{
_WORD *v3; // eax
_WORD *v4; // esi
while ( 1 ) /*0xffe2a37f*/
{
v3 = sub_FFE2A31F(a1, a2); /*0xffe2a37f*/
v4 = v3; /*0xffe2a384*/
if ( !v3 || sub_FFE239A6(a1, (int)(v3 + 4)) ) /*0xffe2a370*/
break; /*0xffe2a370*/
a2 = (_WORD *)((char *)v4 + (unsigned __int16)v4[1]); /*0xffe2a37d*/
}
return v4; /*0xffe2a38a*/
}
// ============================================================================
// 0xffe2a390 GetFirstGuidHob
// ============================================================================
_WORD *__cdecl GetFirstGuidHob()
{
_WORD *v0; // eax
v0 = (_WORD *)sub_FFE2A2B1(); /*0xffe2a391*/
return sub_FFE2A364((int)&unk_FFE2C534, v0); /*0xffe2a3a3*/
}
// ============================================================================
// 0xffe2a3a4 GetNextGuidHob
// ============================================================================
int __fastcall GetNextGuidHob(int a1, int a2)
{
int v3; // eax
int v4; // eax
int v6; // [esp+4h] [ebp-4h] BYREF
v3 = sub_FFE2A23F(); /*0xffe2a3ab*/
if ( (*(int (__cdecl **)(int, int, int, int *))(*(_DWORD *)v3 + 52))(v3, 4, a2, &v6) < 0 ) /*0xffe2a3c3*/
v6 = 0; /*0xffe2a3c5*/
if ( !v6 ) /*0xffe2a3cd*/
{
v4 = sub_FFE23A81(); /*0xffe2a3cf*/
if ( v4 ) /*0xffe2a3d6*/
(*(void (__cdecl **)(const char *, int, const char *))(v4 + 4))( /*0xffe2a3e7*/
"e:\\hs\\MdePkg\\Library\\PeiHobLib\\HobLib.c",
250,
"Hob != ((void *) 0)");
}
return v6; /*0xffe2a3c0*/
}
// ============================================================================
// 0xffe2a3f4 BuildGuidHob
// ============================================================================
int __fastcall BuildGuidHob(int a1, unsigned int n0xFFE0)
{
int v3; // eax
int result; // eax
int v5; // esi
if ( n0xFFE0 > 0xFFE0 ) /*0xffe2a3fd*/
{
v3 = sub_FFE23A81(); /*0xffe2a3ff*/
if ( v3 ) /*0xffe2a406*/
(*(void (__cdecl **)(const char *, int, const char *))(v3 + 4))( /*0xffe2a417*/
"e:\\hs\\MdePkg\\Library\\PeiHobLib\\HobLib.c",
421,
"DataLength <= (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE))");
}
result = sub_FFE2A3A4(a1, n0xFFE0 + 24); /*0xffe2a420*/
v5 = result; /*0xffe2a425*/
if ( result ) /*0xffe2a429*/
{
sub_FFE23975((void *)(result + 8)); /*0xffe2a430*/
return v5 + 24; /*0xffe2a435*/
}
return result; /*0xffe2a42b*/
}
// ============================================================================
// 0xffe2a43a IoWrite8
// ============================================================================
int __fastcall IoWrite8(unsigned __int16 *a1)
{
int v2; // eax
if ( ((unsigned __int8)a1 & 1) != 0 ) /*0xffe2a440*/
{
v2 = sub_FFE23A81(); /*0xffe2a442*/
if ( v2 ) /*0xffe2a449*/
(*(void (__cdecl **)(const char *, int, const char *))(v2 + 4))( /*0xffe2a45a*/
"e:\\hs\\MdePkg\\Library\\BaseIoLibIntrinsic\\IoLib.c",
151,
"(Address & 1) == 0");
}
return *a1; /*0xffe2a466*/
}
// ============================================================================
// 0xffe2a498 BootGuardGetPcdPttSkip
// ============================================================================
char BootGuardGetPcdPttSkip()
{
return 0; /*0xffe2a49a*/
}
// ============================================================================
// 0xffe2a49b BootGuardPcdGetFunc
// ============================================================================
int __fastcall BootGuardPcdGetFunc(int n2, int n50563586)
{
int v5; // eax
int v6; // eax
if ( (unsigned __int8)n2 != 2 && (unsigned __int8)n2 != 3 ) /*0xffe2a4ac*/
return -2147483645; /*0xffe2a4ae*/
v5 = sub_FFE2A23F(); /*0xffe2a4b5*/
v6 = (*(int (__cdecl **)(int, int, int, _DWORD, void *, _DWORD))(*(_DWORD *)v5 + 88))( /*0xffe2a4c8*/
v5,
n2,
n50563586,
0,
&unk_FFE2C5A4,
0);
return v6 != -1610612734 ? v6 : 0;
}
// ============================================================================
// 0xffe2a4df LibPcdGet32
// ============================================================================
int LibPcdGet32()
{
int v0; // eax
v0 = sub_FFE2A4FC(); /*0xffe2a4df*/
return (*(int (__cdecl **)(int))(v0 + 16))(5); /*0xffe2a4ea*/
}
// ============================================================================
// 0xffe2a4eb LibPcdSet32
// ============================================================================
int LibPcdSet32()
{
int v0; // ebx
int v1; // eax
v0 = sub_FFE2A4DF() + 1024064; /*0xffe2a469*/
if ( (v0 & 1) != 0 ) /*0xffe2a46e*/
{
v1 = sub_FFE23A81(); /*0xffe2a470*/
if ( v1 ) /*0xffe2a477*/
(*(void (__cdecl **)(const char *, int, const char *))(v1 + 4))( /*0xffe2a488*/
"e:\\hs\\MdePkg\\Library\\BaseIoLibIntrinsic\\IoLib.c",
183,
"(Address & 1) == 0");
}
*(_WORD *)v0 = 1280; /*0xffe2a493*/
return 1280; /*0xffe2a497*/
}
// ============================================================================
// 0xffe2a4fc LibPcdGetPtr
// ============================================================================
void *__thiscall LibPcdGetPtr(void *this)
{
int v1; // eax
int v2; // eax
void *this_1; // [esp+0h] [ebp-4h] BYREF
this_1 = this; /*0xffe2a4ff*/
v1 = sub_FFE23A05(0, (int)&this_1); /*0xffe2a50b*/
if ( v1 < 0 ) /*0xffe2a514*/
{
sub_FFE23AA9(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v1); /*0xffe2a521*/
v2 = sub_FFE23A81(); /*0xffe2a529*/
if ( v2 ) /*0xffe2a530*/
(*(void (__cdecl **)(const char *, int, const char *))(v2 + 4))( /*0xffe2a53e*/
"e:\\hs\\MdePkg\\Library\\PeiPcdLib\\PeiPcdLib.c",
49,
"!EFI_ERROR (Status)");
}
return this_1; /*0xffe2a549*/
}
// ============================================================================
// 0xffe2a6b8 LShiftU64
// ============================================================================
unsigned __int64 __usercall LShiftU64@<edx:eax>(unsigned __int8 n0x40@<cl>, unsigned __int64 a2@<edx:eax>)
{
if ( n0x40 >= 0x40u ) /*0xffe2a6bb*/
return 0; /*0xffe2a6d2*/
else
return a2 >> n0x40; /*0xffe2a6c5*/
}