instruction
stringlengths 25
119k
| response
stringclasses 1
value |
|---|---|
void *FUNC()
{
return &unk_140222EF0;
}
| openssl |
void *FUNC()
{
return &unk_1401EE400;
}
| openssl |
__int64 __fastcall FUNC(_QWORD *a1, _BYTE *a2)
{
unsigned __int64 v2; // rbx
__int64 v5; // rbp
__int64 v6; // rcx
__int64 v7; // r12
unsigned __int16 v8; // r8
unsigned __int16 v9; // dx
unsigned __int64 v11; // rcx
_QWORD *v12; // rax
__int64 v13; // rax
__int64 v14; // [rsp+40h] [rbp-148h] BYREF
__int64 v15; // [rsp+48h] [rbp-140h] BYREF
v2 = *((_QWORD *)a2 + 4);
v5 = 0i64;
if ( v2 + *((_QWORD *)a2 + 3) > *((_QWORD *)a2 + 1) )
{
LABEL_21:
FUNC(v5);
return 0i64;
}
v6 = a1[22];
v15 = 0i64;
BYTE6(v15) = a2[17];
HIBYTE(v15) = a2[16];
v7 = FUNC(*(_QWORD *)(v6 + 280), &v15);
if ( v7 && v2 != *((_QWORD *)a2 + 1) )
v7 = 0i64;
v8 = *((_WORD *)a2 + 8);
v9 = *(_WORD *)(a1[22] + 272i64);
if ( v8 <= v9 || v8 > v9 + 10 || v7 || !v9 && *a2 == 20 )
{
if ( v2 )
{
while ( (*(int (__fastcall **)(_QWORD *, __int64))(a1[1] + 104i64))(a1, 22i64) > 0 )
{
v2 -= v14;
if ( !v2 )
return 4294967293i64;
}
if ( v7 )
return 0i64;
goto LABEL_21;
}
}
else
{
if ( v2 != *((_QWORD *)a2 + 1) )
return FUNC(a1, (__int64)a2);
v11 = 17740i64;
if ( a1[188] > 0x454Cui64 )
v11 = a1[188];
if ( v2 > v11 )
goto LABEL_21;
v12 = FUNC(v2, 0);
v5 = (__int64)v12;
if ( !v12 )
goto LABEL_21;
memmove(v12, a2, 0x58ui64);
if ( v2 )
{
if ( (*(int (__fastcall **)(_QWORD *, __int64, _QWORD, _QWORD, unsigned __int64, _DWORD, __int64 *))(a1[1] + 104i64))(
a1,
22i64,
0i64,
*(_QWORD *)(v5 + 88),
v2,
0,
&v14) <= 0
|| v14 != v2 )
{
goto LABEL_21;
}
}
v13 = FUNC(&v15, v5);
if ( !v13 || !FUNC(*(_QWORD *)(a1[22] + 280i64), v13) )
goto LABEL_21;
}
return 4294967293i64;
}
| openssl |
evp_Encode_Ctx_st *__fastcall EVP_ENCODE_CTX_new_0()
{
int v0; // eax
return (evp_Encode_Ctx_st *)CRYPTO_zalloc((unsigned int)(v0 + 56), "crypto\\evp\\encode.c", (unsigned int)(v0 + 89));
}
| openssl |
evp_md_ctx_st *__fastcall FUNC(
char *a1,
unsigned __int64 a2,
__int64 a3,
unsigned __int64 a4,
__int64 a5,
unsigned __int64 a6,
unsigned int *a7)
{
unsigned int v8; // r13d
size_t v9; // rdi
evp_md_ctx_st *result; // rax
evp_md_ctx_st *v11; // rbx
int v12; // r12d
unsigned __int64 i; // rsi
char v14[8]; // [rsp+20h] [rbp-B8h] BYREF
__int64 v15; // [rsp+28h] [rbp-B0h]
__int64 v16; // [rsp+30h] [rbp-A8h]
__int64 v17; // [rsp+38h] [rbp-A0h]
unsigned __int8 Src[64]; // [rsp+40h] [rbp-98h] BYREF
v8 = 0;
v15 = a3;
v9 = a2;
v16 = a5;
v17 = a4;
if ( a6 > 0x40000000 || a2 > 0x40000000 || a4 > 0x40000000 )
return 0i64;
result = EVP_MD_CTX_new_0();
v11 = result;
if ( result )
{
v12 = 1;
for ( i = (int)FUNC((__int64)a7); (unsigned int)FUNC((__int64)v11, a7, 0i64); ++v12 )
{
v14[2] = BYTE1(v12);
v14[3] = v12;
v14[1] = BYTE2(v12);
v14[0] = HIBYTE(v12);
if ( !(unsigned int)FUNC((__int64)v11, v15, v17)
|| !(unsigned int)FUNC((__int64)v11, (__int64)v14, 4i64)
|| !(unsigned int)FUNC((__int64)v11, v16, a6) )
{
break;
}
if ( v9 < i )
{
if ( !(unsigned int)EVP_DigestFinal_1(v11, Src, 0i64) )
break;
memmove(a1, Src, v9);
OPENSSL_cleanse_0((__int64)Src, i);
LABEL_16:
v8 = 1;
break;
}
if ( !(unsigned int)EVP_DigestFinal_1(v11, (unsigned __int8 *)a1, 0i64) )
break;
v9 -= i;
if ( !v9 )
goto LABEL_16;
a1 += i;
}
FUNC(v11);
return (evp_md_ctx_st *)v8;
}
return result;
}
| openssl |
__int64 FUNC()
{
unsigned __int8 algorithm2; // al
algorithm2 = ssl_get_algorithm2();
if ( algorithm2 > 0xBu )
return 0i64;
else
return qword_1402822F0[algorithm2];
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, _DWORD *a2, __int64 a3)
{
__int64 v6; // rdi
FUNC(*(struct _RTL_CRITICAL_SECTION **)(a1 + 168));
if ( !*(_QWORD *)(a1 + 152) )
*(_QWORD *)(a1 + 152) = FUNC(a1, a3);
v6 = *(_QWORD *)(a1 + 152);
if ( v6 )
{
if ( BN_BLINDING_is_current_thread_0(*(_QWORD *)(a1 + 152)) )
{
*a2 = 1;
}
else
{
*a2 = 0;
if ( !*(_QWORD *)(a1 + 160) )
*(_QWORD *)(a1 + 160) = FUNC(a1, a3);
v6 = *(_QWORD *)(a1 + 160);
}
}
FUNC(*(struct _RTL_CRITICAL_SECTION **)(a1 + 168));
return v6;
}
| openssl |
__int64 ERR_load_EVP_strings_0()
{
if ( !ERR_func_error_string_0(0x60A5000u) )
{
ERR_load_strings_const_0((const ERR_string_data_st *)&unk_14024F7B0);
ERR_load_strings_const_0((const ERR_string_data_st *)&unk_14024FE20);
}
return 1i64;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2, __int64 a3, int a4, __int64 a5)
{
void *v9; // rax
volatile signed __int32 *v10; // rax
volatile signed __int32 *v11; // rsi
_QWORD *v13; // rdi
unsigned int v14; // ebx
v9 = FUNC();
v10 = (volatile signed __int32 *)FUNC((__int64)v9);
v11 = v10;
if ( v10 )
{
v13 = FUNC(v10, a1);
v14 = FUNC((__int64)v13, a2, a3, a4, a5);
FUNC(v13, 0xBu, 0, 0i64);
FUNC(v13);
FUNC(v11);
return v14;
}
else
{
FUNC(13, 210, 65, (__int64)"crypto\\asn1\\asn_mime.c", 105);
return 0i64;
}
}
| openssl |
engine_st *__fastcall ENGINE_get_default_DH_0_3()
{
int v0; // eax
return (engine_st *)FUNC((__int64 *)&qword_140285490, v0 - 39);
}
| openssl |
char *__fastcall FUNC(__int64 a1, __int64 a2)
{
int v2; // eax
int v3; // ebp
int v6; // eax
int v7; // eax
int v8; // eax
char *v9; // rax
char *v10; // r12
__int64 v11; // rax
const char *v12; // rdx
__int64 v13; // rbp
const char *v14; // rcx
__int64 v15; // rdx
const char *v16; // rsi
const char *v17; // r8
unsigned __int64 v18; // rax
const char *v19; // rbx
unsigned __int64 v20; // rdx
int v21; // r11d
int v22; // ebp
__int64 v23; // rax
const char *v24; // rcx
__int64 v25; // rdx
const char *v26; // rsi
const char *v27; // r8
unsigned __int64 v28; // rax
const char *v29; // rbx
unsigned __int64 v30; // rdx
int v31; // r11d
int v32; // ebp
__int64 v33; // rax
v2 = 0;
v3 = 0;
if ( a2 )
{
if ( *(_QWORD *)a2 )
{
v2 = *(_DWORD *)(a2 + 8) + 2;
if ( *(_QWORD *)(a2 + 32) || *(_QWORD *)(a2 + 48) || *(_QWORD *)(a2 + 64) )
v2 = *(_DWORD *)(a2 + 8) + 3;
}
else if ( *(_QWORD *)(a2 + 16) )
{
v2 = *(_DWORD *)(a2 + 24) + 1;
}
v6 = *(_DWORD *)(a2 + 40) + v2;
if ( *(_QWORD *)(a2 + 32) && (*(_QWORD *)(a2 + 48) || *(_QWORD *)(a2 + 64)) )
++v6;
v7 = *(_DWORD *)(a2 + 56) + v6;
if ( *(_QWORD *)(a2 + 48) && *(_QWORD *)(a2 + 64) )
++v7;
v8 = *(_DWORD *)(a2 + 72) + v7;
if ( v8 )
{
v9 = (char *)CRYPTO_malloc(v8 + 1, "crypto\\dso\\dso_win32.c", 336i64);
v10 = v9;
if ( v9 )
{
if ( *(_QWORD *)a2 )
{
strcpy(v9, "\\\\");
strncpy(v9 + 2, *(const char **)a2, *(int *)(a2 + 8));
v3 = *(_DWORD *)(a2 + 8) + 2;
if ( *(_QWORD *)(a2 + 32) || *(_QWORD *)(a2 + 48) || *(_QWORD *)(a2 + 64) )
{
v11 = v3;
v3 = *(_DWORD *)(a2 + 8) + 3;
v10[v11] = 92;
}
}
else
{
v12 = *(const char **)(a2 + 16);
if ( v12 )
{
strncpy(v9, v12, *(int *)(a2 + 24));
v13 = *(int *)(a2 + 24);
v10[v13] = 58;
v3 = v13 + 1;
}
}
v14 = *(const char **)(a2 + 32);
v15 = *(int *)(a2 + 40);
v16 = v14;
if ( v15 > 0 )
{
do
{
v17 = &v14[v15];
v18 = 0i64;
v19 = v16;
v20 = &v14[v15] - v16;
if ( v20 )
{
do
{
if ( !*v19 )
break;
if ( *v19 == 47 )
goto LABEL_34;
++v18;
++v19;
}
while ( v18 < v20 );
}
v19 = v17;
LABEL_34:
strncpy(&v10[v3], v16, v19 - v16);
v21 = (_DWORD)v19 - (_DWORD)v16;
v16 = v19 + 1;
v22 = v21 + v3;
v23 = v22;
v3 = v22 + 1;
v10[v23] = 92;
v14 = *(const char **)(a2 + 32);
v15 = *(int *)(a2 + 40);
}
while ( v15 > v19 + 1 - v14 );
}
v24 = *(const char **)(a2 + 48);
v25 = *(int *)(a2 + 56);
v26 = v24;
if ( v25 > 0 )
{
do
{
v27 = &v24[v25];
v28 = 0i64;
v29 = v26;
v30 = &v24[v25] - v26;
if ( v30 )
{
do
{
if ( !*v29 )
break;
if ( *v29 == 47 )
goto LABEL_41;
++v28;
++v29;
}
while ( v28 < v30 );
}
v29 = v27;
LABEL_41:
strncpy(&v10[v3], v26, v29 - v26);
v31 = (_DWORD)v29 - (_DWORD)v26;
v26 = v29 + 1;
v32 = v31 + v3;
v33 = v32;
v3 = v32 + 1;
v10[v33] = 92;
v24 = *(const char **)(a2 + 48);
v25 = *(int *)(a2 + 56);
}
while ( v25 > v29 + 1 - v24 );
}
strncpy(&v10[v3], *(const char **)(a2 + 64), *(int *)(a2 + 72));
v10[v3 + (__int64)*(int *)(a2 + 72)] = 0;
return v10;
}
else
{
FUNC(37, 135, 65, (__int64)"crypto\\dso\\dso_win32.c", 338);
return 0i64;
}
}
else
{
FUNC(37, 135, 113, (__int64)"crypto\\dso\\dso_win32.c", 332);
return 0i64;
}
}
else
{
FUNC(37, 135, 67, (__int64)"crypto\\dso\\dso_win32.c", 311);
return 0i64;
}
}
| openssl |
void __fastcall ec_GFp_simple_group_finish_0_0(ec_group_st *group)
{
FUNC(*((_BYTE **)group + 8));
FUNC(*((_BYTE **)group + 12));
FUNC(*((_BYTE **)group + 13));
}
| openssl |
__int64 __fastcall FUNC(unsigned int a1, __int64 a2)
{
unsigned int v2; // r14d
X509_crl_st *v5; // r12
__int64 v6; // rbp
__int64 v7; // r15
int v8; // esi
unsigned int v9; // r13d
unsigned __int64 v10; // rdx
__int64 v11; // rcx
const char *v12; // rbx
__int64 v13; // r8
int v14; // eax
__int64 v15; // rdx
__int64 v16; // rax
int v17; // eax
__int64 v18; // rax
__int64 v19; // rax
__int64 v20; // rax
__int64 v21; // rax
__int64 v22; // rdx
__int64 v23; // rdi
__int64 v24; // rax
__int64 v25; // rax
__int64 v26; // rbx
__int64 v27; // rax
__int64 v28; // rax
__int64 v29; // rdi
x509_st *v30; // rax
evp_pkey_st *pubkey_1_0; // rbx
int v32; // edi
int v33; // edi
__int64 v34; // rbx
__int64 v35; // rax
__int64 v36; // rdi
__int64 v37; // rsi
int v38; // ebp
int v39; // edi
int v40; // r13d
int v41; // r14d
int v42; // r15d
unsigned int v43; // ebx
__int64 v44; // rax
__int64 v45; // rbx
__int64 v46; // rax
unsigned int v47; // eax
__int64 v48; // rax
unsigned int v49; // eax
__int64 v50; // rax
__int64 v51; // rax
unsigned int v52; // eax
const char *v53; // rax
int v54; // eax
int v55; // esi
unsigned __int8 *v56; // rbx
__int64 v57; // r9
__int64 v58; // rbx
unsigned int v59; // eax
int v62; // [rsp+30h] [rbp-108h]
int v63; // [rsp+34h] [rbp-104h] BYREF
unsigned int v64; // [rsp+38h] [rbp-100h]
unsigned int v65; // [rsp+3Ch] [rbp-FCh] BYREF
unsigned int v66; // [rsp+40h] [rbp-F8h] BYREF
int v67; // [rsp+44h] [rbp-F4h]
int v68; // [rsp+48h] [rbp-F0h]
int v69; // [rsp+4Ch] [rbp-ECh]
int v70; // [rsp+50h] [rbp-E8h]
int v71; // [rsp+54h] [rbp-E4h] BYREF
int v72; // [rsp+58h] [rbp-E0h]
int v73; // [rsp+5Ch] [rbp-DCh]
int v74; // [rsp+60h] [rbp-D8h]
int v75; // [rsp+64h] [rbp-D4h]
int v76; // [rsp+68h] [rbp-D0h]
__int64 v77; // [rsp+70h] [rbp-C8h] BYREF
__int64 v78; // [rsp+78h] [rbp-C0h] BYREF
__int64 v79; // [rsp+80h] [rbp-B8h]
__int64 v80; // [rsp+88h] [rbp-B0h]
__int64 v81; // [rsp+90h] [rbp-A8h]
__int64 v82; // [rsp+98h] [rbp-A0h]
__int64 v83; // [rsp+A0h] [rbp-98h]
__int64 v84; // [rsp+A8h] [rbp-90h]
char v85[64]; // [rsp+B0h] [rbp-88h] BYREF
v2 = 0;
v5 = 0i64;
v80 = 0i64;
v83 = 0i64;
v81 = 0i64;
v6 = 0i64;
v77 = FUNC();
v79 = 0i64;
v84 = 0i64;
v78 = 0i64;
v7 = 0i64;
v82 = 0i64;
v76 = 0;
v73 = 0;
v63 = 0;
v67 = 0;
v68 = 0;
v65 = 32773;
v66 = 32773;
v71 = 32773;
v64 = 1;
v62 = 0;
v70 = 0;
v72 = 0;
v75 = 0;
v74 = 0;
v8 = 0;
v9 = 0;
v69 = 0;
v12 = (const char *)FUNC(a1, a2, &unk_1401C0A10);
while ( 2 )
{
v14 = FUNC(v11, v10, v13);
if ( v14 )
{
v10 = 0x140000000ui64;
switch ( v14 )
{
case -1:
case 0:
goto LABEL_32;
case 1:
FUNC(&unk_1401C0A10);
v64 = 0;
goto LABEL_101;
case 2:
v16 = FUNC(v11, 0x140000000ui64, v13);
v17 = FUNC(v16, 2i64, &v65);
goto LABEL_28;
case 3:
v6 = FUNC(v11, 0x140000000ui64, v13);
continue;
case 4:
v18 = FUNC(v11, 0x140000000ui64, v13);
v17 = FUNC(v18, 2i64, &v66);
goto LABEL_28;
case 5:
v79 = FUNC(v11, 0x140000000ui64, v13);
continue;
case 6:
v19 = FUNC(v11, 0x140000000ui64, v13);
v17 = FUNC(v19, 2i64, &v71);
goto LABEL_28;
case 7:
v78 = FUNC(v11, 0x140000000ui64, v13);
continue;
case 8:
v73 = ++v62;
continue;
case 9:
v63 = ++v62;
continue;
case 10:
v67 = ++v62;
continue;
case 11:
v72 = ++v62;
continue;
case 12:
v75 = ++v62;
continue;
case 13:
v70 = 1;
continue;
case 14:
v84 = FUNC(v11, 0x140000000ui64, v13);
continue;
case 15:
v82 = FUNC(v11, 0x140000000ui64, v13);
goto LABEL_12;
case 16:
v8 = 1;
v7 = FUNC(v11, 0x140000000ui64, v13);
continue;
case 17:
v2 = 1;
continue;
case 18:
v9 = 1;
continue;
case 19:
LABEL_12:
v8 = 1;
continue;
case 20:
v74 = 1;
continue;
case 21:
v76 = ++v62;
continue;
case 22:
v69 = ++v62;
continue;
case 23:
v68 = ++v62;
continue;
case 24:
v20 = FUNC(v11, 0x140000000ui64, v13);
v17 = FUNC(v20);
goto LABEL_28;
case 25:
v21 = FUNC(v11, 0x140000000ui64);
v17 = FUNC(v21, &v77);
LABEL_28:
if ( v17 )
continue;
goto LABEL_32;
default:
continue;
}
}
break;
}
if ( (unsigned int)FUNC(v11, v15, v13) )
{
LABEL_32:
BIO_printf(qword_1402808E8, "%s: Use -help for summary.\n", v12);
goto LABEL_100;
}
v5 = (X509_crl_st *)FUNC(v6, v65);
if ( !v5 )
goto LABEL_100;
if ( v8 )
{
v23 = FUNC(v7, v82, v9, v2);
v83 = v23;
if ( !v23 )
goto LABEL_100;
v24 = FUNC();
if ( !FUNC(v23, v24) )
goto LABEL_100;
v25 = FUNC();
v26 = v25;
v81 = v25;
if ( !v25 || !(unsigned int)FUNC(v25, v23, 0i64, 0i64) )
{
BIO_printf(qword_1402808E8, "Error initialising X509 store\n");
goto LABEL_100;
}
v27 = FUNC(v5);
v28 = FUNC(v26, 1i64, v27);
v29 = v28;
if ( !v28 )
{
BIO_printf(qword_1402808E8, "Error getting CRL issuer certificate\n");
goto LABEL_100;
}
v30 = (x509_st *)FUNC(v28);
pubkey_1_0 = X509_get_pubkey_1_0(v30);
FUNC(v29);
if ( !pubkey_1_0 )
{
BIO_printf(qword_1402808E8, "Error getting CRL issuer public key\n");
goto LABEL_100;
}
v32 = X509_CRL_verify_0(v5, pubkey_1_0);
FUNC(pubkey_1_0);
if ( v32 < 0 )
goto LABEL_100;
if ( v32 )
BIO_printf(qword_1402808E8, "verify OK\n");
else
BIO_printf(qword_1402808E8, "verify failure\n");
}
if ( v84 )
{
v33 = v78;
if ( !v78 )
{
FUNC(qword_1402808E8, "Missing CRL signing key\n");
goto LABEL_100;
}
v34 = FUNC(v84, v65);
if ( !v34 )
goto LABEL_100;
v35 = FUNC(v33, v71, 0, 0, 0i64, (__int64)"CRL signing key");
v36 = v35;
if ( !v35 )
{
FUNC(v34);
goto LABEL_100;
}
v37 = FUNC(v5, v34, v35, v77, 0);
FUNC(v34);
FUNC(v36);
if ( !v37 )
{
FUNC(qword_1402808E8, "Error creating delta CRL\n");
goto LABEL_100;
}
FUNC(v5);
v5 = (X509_crl_st *)v37;
}
if ( v70 )
{
FUNC(v5, &v78, 0i64);
FUNC(v78);
}
v38 = v62;
if ( v62 )
{
v39 = 1;
if ( v62 >= 1 )
{
v40 = v76;
v41 = v73;
v42 = v63;
do
{
if ( v41 == v39 )
{
v43 = FUNC();
v44 = FUNC(v5);
FUNC(qword_1402808E0, "issuer=", v44, v43);
}
if ( v75 == v39 )
{
v45 = FUNC(v5, 88i64, 0i64);
BIO_printf((bio_st *)qword_1402808E0, "crlNumber=");
if ( v45 )
{
FUNC(qword_1402808E0, v45);
FUNC(v45);
}
else
{
FUNC(qword_1402808E0, "<NONE>");
}
BIO_printf((bio_st *)qword_1402808E0, "\n");
}
if ( v40 == v39 )
{
v46 = FUNC(v5);
v47 = X509_NAME_hash(v46);
BIO_printf((bio_st *)qword_1402808E0, "%08lx\n", v47);
}
if ( v69 == v39 )
{
v48 = FUNC(v5);
v49 = FUNC(v48);
BIO_printf((bio_st *)qword_1402808E0, "%08lx\n", v49);
}
if ( v42 == v39 )
{
BIO_printf((bio_st *)qword_1402808E0, "lastUpdate=");
v50 = FUNC(v5);
FUNC(qword_1402808E0, v50);
BIO_printf((bio_st *)qword_1402808E0, "\n");
}
if ( v67 == v39 )
{
BIO_printf((bio_st *)qword_1402808E0, "nextUpdate=");
if ( FUNC(v5) )
{
v51 = FUNC(v5);
FUNC(qword_1402808E0, v51);
}
else
{
BIO_printf((bio_st *)qword_1402808E0, "NONE");
}
BIO_printf((bio_st *)qword_1402808E0, "\n");
}
if ( v72 == v39 )
{
if ( !(unsigned int)FUNC(v5, v77, v85, &v63) )
{
BIO_printf(qword_1402808E8, "out of memory\n");
goto LABEL_100;
}
v52 = FUNC(v77);
v53 = (const char *)FUNC(v52);
BIO_printf((bio_st *)qword_1402808E0, "%s Fingerprint=", v53);
v54 = v63;
v55 = 0;
if ( v63 > 0 )
{
v56 = (unsigned __int8 *)v85;
do
{
v57 = 58i64;
if ( ++v55 == v54 )
v57 = 10i64;
BIO_printf((bio_st *)qword_1402808E0, "%02X%c", *v56, v57);
v54 = v63;
++v56;
}
while ( v55 < v63 );
v38 = v62;
}
}
++v39;
}
while ( v39 <= v38 );
}
}
LOBYTE(v22) = 119;
v58 = FUNC(v79, v22, v66);
v80 = v58;
if ( !v58 )
goto LABEL_100;
if ( v74 )
{
v59 = FUNC();
FUNC(v58, v5, v59);
}
if ( !v68 && !(v66 == 4 ? d2i_PKCS7_bio_2(v58, v5) : (unsigned int)PEM_write_SSL_SESSION_3(v58, v5)) )
{
BIO_printf(qword_1402808E8, "unable to write CRL\n");
LABEL_100:
X509_ALGOR_dup_0(qword_1402808E8);
goto LABEL_101;
}
v64 = 0;
LABEL_101:
FUNC(v80);
FUNC(v5);
FUNC(v81);
FUNC(v83);
return v64;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, volatile signed __int32 *a2, unsigned int *a3)
{
unsigned int *v3; // r12
unsigned int v6; // esi
void **v7; // r14
CHAR *v8; // rbp
CONF_VALUE *section; // r12
int v10; // ebx
_QWORD *v11; // rdi
__int64 v12; // rbx
unsigned __int64 v13; // kr08_8
int v14; // ecx
int v15; // edi
volatile signed __int32 *v16; // rdi
void **v17; // r14
unsigned __int64 v18; // kr10_8
__int64 v19; // rax
char v20; // dl
int v21; // eax
_QWORD *v22; // rcx
int v23; // edi
_BYTE *v24; // rdx
__int64 v25; // r8
unsigned __int8 v26; // al
unsigned __int8 *v27; // rdi
unsigned __int8 v28; // dl
__int64 v29; // r8
unsigned __int8 v30; // r8
unsigned __int8 *v31; // rsi
unsigned __int8 *j; // rbx
unsigned __int8 *v33; // r11
unsigned __int8 *k; // rdi
unsigned __int8 v35; // dl
__int64 v36; // r8
int v37; // eax
unsigned __int8 *v38; // rax
unsigned __int8 *v39; // rsi
char *v40; // rbp
unsigned __int8 *v41; // rbx
bool v42; // zf
char *v43; // rdi
volatile signed __int32 *v44; // rax
volatile signed __int32 *v45; // rbx
void **v46; // rdi
unsigned __int8 *v47; // rbx
_BYTE *v48; // rax
CONF_VALUE *v49; // rax
unsigned int *m; // rbx
__int64 v51; // rdi
__int64 v52; // rcx
unsigned int v54; // [rsp+30h] [rbp-A8h]
int v55; // [rsp+34h] [rbp-A4h]
int i; // [rsp+40h] [rbp-98h]
char *v58; // [rsp+48h] [rbp-90h] BYREF
_BYTE *v59; // [rsp+50h] [rbp-88h]
_QWORD *v60; // [rsp+58h] [rbp-80h]
char *v61; // [rsp+60h] [rbp-78h] BYREF
void *v62; // [rsp+68h] [rbp-70h] BYREF
void **v63; // [rsp+70h] [rbp-68h]
_BYTE *v64; // [rsp+78h] [rbp-60h] BYREF
__int64 v65; // [rsp+80h] [rbp-58h]
char v66[16]; // [rsp+88h] [rbp-50h] BYREF
v3 = a3;
v65 = *(_QWORD *)(a1 + 16);
v6 = 0;
v54 = 0;
v7 = 0i64;
v59 = 0i64;
v63 = 0i64;
v8 = 0i64;
v61 = 0i64;
v62 = 0i64;
v60 = FUNC();
if ( v60 )
{
v59 = FUNC("default", "crypto\\conf\\conf_def.c", 206i64);
v64 = v59;
if ( !v59 )
{
FUNC(14, 121, 65, (__int64)"crypto\\conf\\conf_def.c", 208);
goto LABEL_93;
}
if ( !(unsigned int)CONF_new_data(a1) )
{
FUNC(14, 121, 65, (__int64)"crypto\\conf\\conf_def.c", 213);
goto LABEL_93;
}
section = (CONF_VALUE *)FUNC(a1, v59);
if ( !section )
{
FUNC(14, 121, 103, (__int64)"crypto\\conf\\conf_def.c", 219);
LABEL_92:
v3 = a3;
goto LABEL_93;
}
v10 = 0;
v11 = v60;
v55 = 0;
if ( !FUNC((__int64)v60, 0x200ui64) )
{
LABEL_90:
FUNC(14, 121, 7, (__int64)"crypto\\conf\\conf_def.c", 227);
goto LABEL_91;
}
while ( 1 )
{
v12 = v11[1] + v10;
*(_BYTE *)v12 = 0;
FUNC((__int64)a2, v12, 511);
*(_BYTE *)(v12 + 511) = 0;
v13 = strlen((const char *)v12) + 1;
v14 = v13 - 1;
v15 = v13 - 1;
if ( (_DWORD)v13 == 1 )
{
do
{
if ( v6 )
break;
if ( v62 )
{
v16 = (volatile signed __int32 *)FUNC(v8, (LPWIN32_FIND_DATAW *)&v62);
if ( v16 )
goto LABEL_16;
CRYPTO_free(v8, "crypto\\conf\\conf_def.c", 250i64);
v8 = 0i64;
v61 = 0i64;
}
v17 = v63;
v16 = (volatile signed __int32 *)OPENSSL_sk_pop_0(v63);
if ( !v16 )
{
FUNC((__int64)v60);
CRYPTO_free(v59, "crypto\\conf\\conf_def.c", 431i64);
FUNC(v17);
return 1i64;
}
LABEL_16:
FUNC(a2);
a2 = v16;
FUNC((__int64)v16, v12, 511);
*(_BYTE *)(v12 + 511) = 0;
v18 = strlen((const char *)v12) + 1;
v14 = v18 - 1;
v15 = v18 - 1;
}
while ( (_DWORD)v18 == 1 );
}
v6 = 0;
v19 = v14;
for ( i = 0; v19 > 0; --v14 )
{
v20 = *(_BYTE *)(v12 + v19 - 1);
if ( v20 != 13 && v20 != 10 )
break;
--v19;
}
if ( v15 && v14 == v15 )
{
v6 = 1;
i = 1;
}
else
{
++v54;
*(_BYTE *)(v14 + v12) = 0;
}
v7 = 0i64;
v21 = v14 + v55;
v22 = v60;
v55 = v21;
if ( v21 < 1 )
{
v10 = v21;
}
else
{
v10 = v21;
v23 = v21 - 1;
v24 = (_BYTE *)(v60[1] + v21 - 1);
if ( *v24 <= 0x7Fu )
{
v25 = *(_QWORD *)(a1 + 8);
if ( ((*(unsigned __int16 *)(v25 + 2i64 * (unsigned __int8)*v24) >> 5) & 1) != 0 )
{
if ( v21 <= 1
|| (v26 = *(v24 - 1), v26 > 0x7Fu)
|| ((*(unsigned __int16 *)(v25 + 2i64 * v26) >> 5) & 1) == 0 )
{
v10 = v23;
v6 = 1;
v55 = v23;
goto LABEL_89;
}
}
v22 = v60;
}
}
if ( !v6 )
{
v27 = (unsigned __int8 *)v22[1];
v55 = 0;
FUNC(a1, (char *)v27);
while ( 1 )
{
v28 = *v27;
if ( *v27 > 0x7Fu )
break;
v29 = *(_QWORD *)(a1 + 8);
if ( ((*(unsigned __int16 *)(v29 + 2i64 * v28) >> 4) & 1) == 0
|| v28 <= 0x7Fu && ((*(unsigned __int16 *)(v29 + 2i64 * v28) >> 3) & 1) != 0 )
{
break;
}
++v27;
}
v30 = *v27;
if ( *v27 > 0x7Fu || ((*(unsigned __int16 *)(*(_QWORD *)(a1 + 8) + 2i64 * v30) >> 3) & 1) == 0 )
{
if ( v30 == 91 )
{
v31 = FUNC(a1, v27 + 1);
for ( j = v31; ; j = k )
{
v33 = FUNC(a1, j);
for ( k = v33; ; ++k )
{
v35 = *k;
if ( *k > 0x7Fu )
break;
v36 = *(_QWORD *)(a1 + 8);
if ( ((*(unsigned __int16 *)(v36 + 2i64 * v35) >> 4) & 1) == 0
|| v35 <= 0x7Fu && ((*(unsigned __int16 *)(v36 + 2i64 * v35) >> 3) & 1) != 0 )
{
break;
}
}
if ( *k == 93 )
break;
if ( !*k || j == k )
{
FUNC(14, 121, 100, (__int64)"crypto\\conf\\conf_def.c", 324);
goto LABEL_91;
}
}
*v33 = 0;
v37 = FUNC(a1, 0i64, (void **)&v64, v31);
v59 = v64;
if ( !v37 )
goto LABEL_91;
section = CONF_get_section((const conf_st *)a1, v64);
if ( !section )
{
section = (CONF_VALUE *)FUNC(a1, v59);
if ( !section )
{
FUNC(14, 121, 103, (__int64)"crypto\\conf\\conf_def.c", 334);
goto LABEL_91;
}
}
}
else
{
v38 = FUNC(a1, v27);
v39 = v38;
if ( *v38 == 58 && v38[1] == 58 )
{
v40 = (char *)v27;
*v38 = 0;
v27 = v38 + 2;
v39 = FUNC(a1, v38 + 2);
}
else
{
v40 = v59;
}
v41 = FUNC(a1, v39);
if ( !strncmp((const char *)v27, ".include", 8ui64) )
{
if ( v41 == v27 + 8 && *v41 != 61 )
{
LABEL_111:
FUNC(14, 121, 101, (__int64)"crypto\\conf\\conf_def.c", 391);
goto LABEL_91;
}
v42 = *v41 == 61;
v58 = 0i64;
if ( v42 )
v41 = FUNC(a1, v41 + 1);
FUNC(a1, v41);
if ( !(unsigned int)FUNC(a1, v40, (void **)&v58, v41) )
goto LABEL_91;
v43 = v58;
v44 = (volatile signed __int32 *)FUNC(v58, (LPWIN32_FIND_DATAW *)&v62, &v61);
v8 = v61;
v45 = v44;
if ( v43 != v61 )
CRYPTO_free(v43, "crypto\\conf\\conf_def.c", 368i64);
if ( v45 )
{
v46 = v63;
if ( !v63 )
{
v46 = (void **)FUNC();
v63 = v46;
if ( !v46 )
{
FUNC(14, 121, 65, (__int64)"crypto\\conf\\conf_def.c", 378);
goto LABEL_91;
}
}
if ( !(unsigned int)OPENSSL_sk_push_0((unsigned int *)v46, (__int64)a2) )
{
FUNC(14, 121, 65, (__int64)"crypto\\conf\\conf_def.c", 383);
goto LABEL_91;
}
a2 = v45;
}
}
else
{
if ( *v41 != 61 )
goto LABEL_111;
*v39 = 0;
v47 = FUNC(a1, v41 + 1);
FUNC(a1, v47);
v7 = (void **)CRYPTO_malloc(0x18ui64, "crypto\\conf\\conf_def.c", 399i64);
if ( !v7 )
{
FUNC(14, 121, 65, (__int64)"crypto\\conf\\conf_def.c", 400);
goto LABEL_91;
}
v48 = FUNC((char *)v27, "crypto\\conf\\conf_def.c", 403i64);
v7[2] = 0i64;
v7[1] = v48;
if ( !v48 )
{
FUNC(14, 121, 65, (__int64)"crypto\\conf\\conf_def.c", 406);
goto LABEL_91;
}
if ( !(unsigned int)FUNC(a1, v40, v7 + 2, v47) )
goto LABEL_91;
if ( !strcmp(v40, v59) )
{
v49 = section;
}
else
{
v49 = CONF_get_section((const conf_st *)a1, v40);
if ( !v49 )
{
v49 = (CONF_VALUE *)FUNC(a1, v40);
if ( !v49 )
{
FUNC(14, 121, 103, (__int64)"crypto\\conf\\conf_def.c", 418);
LABEL_91:
v6 = v54;
goto LABEL_92;
}
}
}
if ( !(unsigned int)FUNC(a1, v49, v7) )
{
FUNC(14, 121, 65, (__int64)"crypto\\conf\\conf_def.c", 424);
goto LABEL_91;
}
v8 = v61;
v7 = 0i64;
}
}
v6 = i;
}
v10 = 0;
}
LABEL_89:
v11 = v60;
if ( !FUNC((__int64)v60, v10 + 512) )
goto LABEL_90;
}
}
FUNC(14, 121, 7, (__int64)"crypto\\conf\\conf_def.c", 202);
LABEL_93:
FUNC((__int64)v60);
CRYPTO_free(v59, "crypto\\conf\\conf_def.c", 440i64);
for ( m = (unsigned int *)v63; (int)FUNC(m) > 0; a2 = (volatile signed __int32 *)v51 )
{
v51 = OPENSSL_sk_pop_0(m);
FUNC(a2);
}
FUNC((void **)m);
CRYPTO_free(v61, "crypto\\conf\\conf_def.c", 453i64);
if ( v62 )
FUNC(&v62);
if ( v3 )
*v3 = v6;
FUNC(v66, 0xDui64, "%ld", v6);
ERR_add_error_data(2, "line ", v66);
v52 = *(_QWORD *)(a1 + 16);
if ( v65 != v52 )
{
CONF_free_0(v52);
*(_QWORD *)(a1 + 16) = 0i64;
}
if ( v7 )
{
CRYPTO_free(v7[1], "crypto\\conf\\conf_def.c", 466i64);
CRYPTO_free(v7[2], "crypto\\conf\\conf_def.c", 467i64);
CRYPTO_free(v7, "crypto\\conf\\conf_def.c", 468i64);
}
return 0i64;
}
| openssl |
errno_t __cdecl mbsnbcpy_s(unsigned __int8 *Dst, size_t SizeInBytes, const unsigned __int8 *Src, size_t MaxCount)
{
return mbsnbcpy_s_l(Dst, SizeInBytes, Src, MaxCount, 0i64);
}
| openssl |
int __cdecl vsnprintf(char *const Buffer, const size_t BufferCount, const char *const Format, va_list ArgList)
{
return vsnprintf_l(Buffer, BufferCount, Format, 0i64, ArgList);
}
| openssl |
__int64 __fastcall FUNC(_QWORD *a1)
{
return FUNC(a1, 6);
}
| openssl |
__int64 __fastcall FUNC(__int64 *a1, unsigned int a2)
{
__int64 v5; // rax
if ( !a1 )
return 0i64;
if ( a2 )
{
if ( !*a1 )
{
v5 = FUNC();
*a1 = v5;
if ( !v5 )
return 0i64;
}
return FUNC(*a1, a2);
}
else
{
FUNC();
*a1 = 0i64;
return 1i64;
}
}
| openssl |
void __fastcall FUNC(void *a1)
{
ASN1_item_free(a1, (__int64)&unk_140220FB0);
}
| openssl |
__int64 __fastcall FUNC(const char *a1, _QWORD *a2, _QWORD *a3, int a4)
{
int v4; // eax
char *k; // r14
__int64 v6; // r12
__int64 v7; // rbp
const char *v10; // rdi
char *v11; // rax
char *v12; // rsi
char *v13; // r12
char v14; // al
char *m; // rsi
_BYTE *v16; // rax
unsigned int v17; // eax
char *i; // rcx
char *v19; // rbx
char *v20; // rax
char *v22; // r12
char *j; // rcx
_BYTE *v24; // rax
k = 0i64;
v6 = 0i64;
v7 = 0i64;
v10 = a1;
if ( *a1 == 91 )
{
v11 = strchr(a1, v4 + 45);
v12 = v11;
if ( !v11 )
goto LABEL_34;
v13 = v11;
v14 = v11[1];
k = (char *)(v10 + 1);
v6 = v13 - (v10 + 1);
if ( !v14 )
{
m = 0i64;
goto LABEL_5;
}
if ( v14 != 58 )
{
LABEL_34:
FUNC(32, 136, 130, (__int64)"crypto\\bio\\b_addr.c", 547);
return 0i64;
}
m = v12 + 2;
v17 = 0;
for ( i = m; *i; ++v17 )
{
if ( v17 >= 0x80000000 )
break;
++i;
}
}
else
{
v19 = strrchr(a1, 58);
v20 = strchr(v10, 58);
m = v20;
if ( v20 != v19 )
{
FUNC(32, 136, 129, (__int64)"crypto\\bio\\b_addr.c", 544);
return 0i64;
}
if ( v20 )
{
v22 = v20;
m = v20 + 1;
v17 = 0;
v6 = v22 - v10;
k = (char *)v10;
for ( j = m; *j; ++v17 )
{
if ( v17 >= 0x80000000 )
break;
++j;
}
}
else
{
v17 = 0;
if ( !a4 )
{
for ( k = (char *)v10; *v10; ++v17 )
{
if ( v17 >= 0x80000000 )
break;
++v10;
}
v6 = v17 & 0x7FFFFFFF;
goto LABEL_5;
}
for ( m = (char *)v10; *v10; ++v17 )
{
if ( v17 >= 0x80000000 )
break;
++v10;
}
}
}
v7 = v17 & 0x7FFFFFFF;
if ( m && strchr(m, 58) )
goto LABEL_34;
LABEL_5:
if ( k && a2 )
{
if ( !v6 || v6 == 1 && *k == 42 )
{
*a2 = 0i64;
}
else
{
v16 = FUNC(k, v6, "crypto\\bio\\b_addr.c", 0x20Eu);
*a2 = v16;
if ( !v16 )
goto LABEL_42;
}
}
if ( m && a3 )
{
if ( !v7 || v7 == 1 && *m == 42 )
{
*a3 = 0i64;
}
else
{
v24 = FUNC(m, v7, "crypto\\bio\\b_addr.c", 0x218u);
*a3 = v24;
if ( !v24 )
{
LABEL_42:
FUNC(32, 136, 65, (__int64)"crypto\\bio\\b_addr.c", 550);
return 0i64;
}
}
}
return 1i64;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2)
{
unsigned __int8 *i; // rax
_BYTE *j; // rcx
__int64 v4; // rcx
unsigned __int8 v5; // dl
for ( i = *(unsigned __int8 **)(a1 + 24); *i == 48; ++i )
;
for ( j = *(_BYTE **)(a2 + 24); *j == 48; ++j )
;
v4 = j - i;
while ( 1 )
{
v5 = *i;
if ( *i != i[v4] )
break;
++i;
if ( !v5 )
return 0i64;
}
return -(v5 < i[v4]) - ((unsigned int)(*i < i[v4]) - 1);
}
| openssl |
void FUNC()
{
engine_st *v0; // rax
__int64 v1; // rbx
v0 = engine_dynamic();
v1 = (__int64)v0;
if ( v0 )
{
FUNC(v0);
FUNC(v1);
FUNC();
}
}
| openssl |
__int64 __fastcall FUNC(__m128i *a1, __m128i *a2, __int64 *a3)
{
__int64 v6; // rsi
__int64 v7; // rbp
size_t v9; // r12
_BYTE *v10; // rax
_BYTE *v11; // rbx
unsigned int *v12; // rax
char v13[24]; // [rsp+30h] [rbp-48h] BYREF
v6 = 0i64;
v7 = (int)(FUNC((__int64)a3) + 7) / 8;
if ( a1 != (__m128i *)a3 && (int)FUNC(a1->m128i_i64, a3) >= 0
|| a2 != (__m128i *)a3 && (int)FUNC(a2->m128i_i64, a3) >= 0 )
{
return 0i64;
}
v9 = 2 * (int)v7;
v10 = CRYPTO_malloc(v9, "crypto\\srp\\srp_lib.c", 34i64);
v11 = v10;
if ( v10 && (int)BN_bn2binpad_0(a1, v10, v7) >= 0 && (int)BN_bn2binpad_0(a2, &v11[v7], v7) >= 0 )
{
v12 = (unsigned int *)FUNC();
if ( (unsigned int)FUNC((__int64)v11, v9, (__int64)v13, 0i64, v12, 0i64) )
v6 = FUNC(v13, 20, 0i64);
}
CRYPTO_free(v11, "crypto\\srp\\srp_lib.c", 42i64);
return v6;
}
| openssl |
void *__fastcall FUNC(
unsigned __int64 *a1,
unsigned __int64 *a2,
unsigned __int64 *a3,
int a4,
int a5,
int a6,
unsigned __int64 *a7)
{
__int64 v7; // rsi
__int64 v9; // rdi
void *result; // rax
int v11; // ebx
int v12; // r8d
unsigned __int64 *v13; // rbx
int v14; // eax
int v15; // edi
int v16; // edi
__int64 v17; // rcx
unsigned __int64 *v18; // r8
unsigned __int64 v19; // rcx
unsigned __int64 v20; // rax
bool v21; // zf
unsigned __int64 *v22; // [rsp+40h] [rbp-58h]
__int64 v23; // [rsp+40h] [rbp-58h]
__int64 v24; // [rsp+40h] [rbp-58h]
int v25; // [rsp+4Ch] [rbp-4Ch]
int v26; // [rsp+50h] [rbp-48h]
unsigned __int64 *v27; // [rsp+58h] [rbp-40h]
int v28; // [rsp+60h] [rbp-38h]
int v29; // [rsp+68h] [rbp-30h]
__int64 v30; // [rsp+68h] [rbp-30h]
unsigned __int64 *v31; // [rsp+70h] [rbp-28h]
__int64 v32; // [rsp+78h] [rbp-20h]
int v35; // [rsp+B8h] [rbp+20h]
v7 = a4;
v9 = a4 / 2;
v35 = a4 / 2;
v25 = v9 + a6;
v26 = v9 + a5;
if ( a4 == 8 )
{
if ( !a5 && !a6 )
return (void *)FUNC(a1, a2, a3);
goto LABEL_6;
}
if ( a4 < 16 )
{
LABEL_6:
result = (void *)FUNC(a1, a2, a4 + a5, a3, a4 + a6);
if ( a5 + a6 < 0 )
return memset(&a1[2 * (int)v7 + a6 + a5], 0, 8i64 * -(a5 + a6));
return result;
}
v32 = a4 / 2;
v29 = -a5;
v22 = &a2[v9];
v11 = FUNC((__int64)a2, (__int64)v22, (int)v9 + a5, -a5);
v28 = 0;
v31 = &a3[v9];
switch ( (unsigned int)FUNC((__int64)v31, (__int64)a3, (int)v9 + a6, a6) + 3 * v11 )
{
case 0xFFFFFFFC:
FUNC(a7, v22, a2, v26, v26 - v35);
FUNC(&a7[v35], a3, v31, v25, v35 - v25);
goto LABEL_14;
case 0xFFFFFFFD:
case 0xFFFFFFFF:
case 0u:
case 1u:
case 3u:
v12 = 1;
goto LABEL_15;
case 0xFFFFFFFE:
FUNC(a7, v22, a2, v26, v26 - v35);
FUNC(&a7[v9], v31, a3, v25, a6);
v28 = 1;
goto LABEL_14;
case 2u:
FUNC(a7, a2, v22, v26, v29);
FUNC(&a7[v9], a3, v31, v25, v35 - v25);
v28 = 1;
goto LABEL_14;
case 4u:
FUNC(a7, a2, v22, v26, v29);
FUNC(&a7[v9], v31, a3, v25, a6);
goto LABEL_14;
default:
LABEL_14:
v12 = 0;
LABEL_15:
if ( v35 == 4 )
{
if ( !a5 && !a6 )
{
v23 = v7;
v13 = &a7[v7];
if ( v12 )
{
*v13 = 0i64;
v13[1] = 0i64;
v13[2] = 0i64;
v13[3] = 0i64;
v13[4] = 0i64;
v13[5] = 0i64;
v13[6] = 0i64;
v13[7] = 0i64;
}
else
{
FUNC(&a7[v7], a7, a7 + 4);
}
FUNC(a1, a2, a3);
v27 = &a1[v23];
FUNC(&a1[v23], a2 + 4, a3 + 4);
goto LABEL_33;
}
goto LABEL_29;
}
if ( v35 != 8 || a5 || a6 )
{
LABEL_29:
v30 = (__int64)&a7[2 * (int)v7];
v13 = &a7[v7];
if ( v12 )
memset(&a7[v7], 0, 8 * v7);
else
FUNC(8 * v7 + (_DWORD)a7, (_DWORD)a7, (_DWORD)a7 + 8 * v35, v35, 0, 0, (__int64)&a7[2 * (int)v7]);
FUNC((_DWORD)a1, (_DWORD)a2, (_DWORD)a3, v35, 0, 0, v30);
v27 = &a1[v7];
FUNC((_DWORD)v27, (_DWORD)v22, (_DWORD)v31, v35, a5, a6, v30);
goto LABEL_33;
}
v24 = v7;
v13 = &a7[v7];
if ( v12 )
memset(v13, 0, 0x80ui64);
else
FUNC(v13, a7, a7 + 8);
FUNC(a1, a2, a3);
v27 = &a1[v24];
FUNC(&a1[v24], a2 + 8, a3 + 8);
LABEL_33:
v14 = FUNC(a7, a1, v27, v7);
if ( v28 )
v15 = v14 - FUNC(v13, a7, v13, v7);
else
v15 = FUNC(v13, v13, a7, v7) + v14;
result = (void *)FUNC(&a1[v32], &a1[v32], v13, v7);
v16 = (_DWORD)result + v15;
if ( v16 )
{
v17 = (int)v7 + v35;
result = (void *)a1[v17];
v18 = &a1[v17];
v19 = (unsigned __int64)result + v16;
*v18 = v19;
if ( v19 < v16 )
{
do
{
v20 = v18[1];
++v18;
v21 = v20 == -1i64;
result = (void *)(v20 + 1);
*v18 = (unsigned __int64)result;
}
while ( v21 );
}
}
return result;
}
}
| openssl |
__int64 __fastcall ossl_init_load_crypto_strings_0()
{
__int64 result; // rax
result = FUNC();
dword_1402853D0 = 1;
return result;
}
| openssl |
__int64 __fastcall FUNC(__int64 *a1, unsigned __int8 **a2, __int64 a3)
{
return FUNC(a1, a2, a3, (__int64)&unk_140214410);
}
| openssl |
int __cdecl ismbblead_l(unsigned int Ch, _locale_t Locale)
{
return x_ismbbtype_l((const __m128i *)Locale, Ch, 0, 4u);
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2)
{
return FUNC(a1, a2, &unk_140220540);
}
| openssl |
__int64 __fastcall FUNC(__int64 *a1)
{
__int64 v2; // rax
__int64 (*v3)(void); // rdx
__int64 result; // rax
if ( a1 && (v2 = *a1) != 0 && *(_QWORD *)(v2 + 40) )
{
*((_DWORD *)a1 + 8) = 2;
v3 = *(__int64 (**)(void))(v2 + 32);
if ( v3 )
{
result = v3();
if ( (int)result <= 0 )
*((_DWORD *)a1 + 8) = 0;
}
else
{
return 1i64;
}
}
else
{
FUNC(6, 149, 150, (__int64)"crypto\\evp\\pmeth_gn.c", 24);
return 4294967294i64;
}
return result;
}
| openssl |
__int64 __fastcall FUNC(_QWORD *a1)
{
unsigned int *v2; // rax
int v3; // eax
int v4; // edx
int v5; // edx
unsigned int v7; // edx
if ( dword_1402854E4 )
{
v7 = dword_1402854E0;
*a1 = dword_1402854D8;
return v7;
}
else
{
v2 = (unsigned int *)FUNC();
if ( v2 )
{
v3 = FUNC(v2);
v4 = dword_1402854E0;
dword_1402854D8[dword_1402854E0] = v3;
v5 = v4 + 1;
dword_1402854E0 = v5;
}
else
{
v5 = dword_1402854E0;
}
dword_1402854E4 = 1;
dword_1402854D8[v5] = 0;
*a1 = dword_1402854D8;
return (unsigned int)v5;
}
}
| openssl |
__int64 __fastcall FUNC(const char *a1)
{
FILE *v3; // rdi
unsigned int v4; // ebx
struct _stat64i32 Stat; // [rsp+30h] [rbp-448h] BYREF
char Buffer[1024]; // [rsp+60h] [rbp-418h] BYREF
if ( stat64i32_0(a1, &Stat) >= 0 && (Stat.st_mode & 0x8000u) == 0 )
{
FUNC(36, 112, 122, (__int64)"crypto\\rand\\randfile.c", 183);
ERR_add_error_data(2, "Filename=", a1);
return 0xFFFFFFFFi64;
}
if ( (unsigned int)FUNC((__int64)Buffer, 1024) != 1 )
return 0xFFFFFFFFi64;
v3 = (FILE *)FUNC(a1, "wb");
if ( v3 )
{
chmod(a1, 384);
v4 = fwrite(Buffer, 1ui64, 0x400ui64, v3);
fclose(v3);
OPENSSL_cleanse_0((__int64)Buffer, 1024i64);
return v4;
}
else
{
FUNC(36, 112, 121, (__int64)"crypto\\rand\\randfile.c", 233);
ERR_add_error_data(2, "Filename=", a1);
return 0xFFFFFFFFi64;
}
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, char a2)
{
unsigned int v2; // esi
int v3; // ebx
evp_cipher_ctx_st *v6; // rcx
evp_cipher_ctx_st *v7; // rax
evp_cipher_ctx_st *v8; // rcx
char *v9; // rbp
__int64 v10; // r13
__int64 v11; // r14
int v12; // eax
__int64 v13; // r15
evp_cipher_ctx_st *v14; // rax
int v15; // edx
__int64 v16; // rcx
evp_md_ctx_st *v17; // rbx
unsigned int v18; // eax
__int64 v19; // rax
__int64 v20; // rax
int v21; // ecx
__int64 v22; // rax
__int64 v23; // r13
__int64 v24; // r13
char *v25; // r15
__int64 v26; // rax
__int64 v27; // rax
size_t v28; // rbx
__int64 v29; // rax
__int64 v30; // r13
__int64 v31; // rax
__int64 v32; // rbx
__int64 v33; // rax
unsigned __int64 v35; // [rsp+38h] [rbp-140h]
size_t Size; // [rsp+60h] [rbp-118h] BYREF
__int64 v37; // [rsp+68h] [rbp-110h]
__int64 v38; // [rsp+70h] [rbp-108h]
__int64 v39; // [rsp+78h] [rbp-100h]
unsigned int v40; // [rsp+80h] [rbp-F8h] BYREF
__int64 v41; // [rsp+88h] [rbp-F0h]
char *v42; // [rsp+90h] [rbp-E8h]
evp_cipher_ctx_st *v43; // [rsp+98h] [rbp-E0h]
__int64 v44; // [rsp+A0h] [rbp-D8h]
__int64 v45; // [rsp+A8h] [rbp-D0h]
char Src[64]; // [rsp+B0h] [rbp-C8h] BYREF
char v47[64]; // [rsp+F0h] [rbp-88h] BYREF
v2 = 0;
v3 = a2 & 1;
v42 = Src;
v37 = 0i64;
v38 = 0i64;
Size = 0i64;
v39 = 0i64;
v41 = 0i64;
if ( (a2 & 1) != 0 )
{
v6 = *(evp_cipher_ctx_st **)(a1 + 1080);
if ( v6 )
{
EVP_CIPHER_CTX_reset(v6);
}
else
{
v7 = EVP_CIPHER_CTX_new();
*(_QWORD *)(a1 + 1080) = v7;
if ( !v7 )
{
FUNC((_DWORD *)a1, 0x50u, 440, 65, (__int64)"ssl\\tls13_enc.c", 473);
goto LABEL_71;
}
}
v43 = *(evp_cipher_ctx_st **)(a1 + 1080);
v44 = a1 + 1088;
FUNC(a1 + 2096);
}
else
{
*(_DWORD *)(a1 + 124) = 1;
v8 = *(evp_cipher_ctx_st **)(a1 + 1128);
if ( v8 )
{
EVP_CIPHER_CTX_reset(v8);
}
else
{
v14 = EVP_CIPHER_CTX_new();
*(_QWORD *)(a1 + 1128) = v14;
if ( !v14 )
{
FUNC((_DWORD *)a1, 0x50u, 440, 65, (__int64)"ssl\\tls13_enc.c", 489);
goto LABEL_71;
}
}
v43 = *(evp_cipher_ctx_st **)(a1 + 1128);
v44 = a1 + 1136;
FUNC(a1 + 2096);
}
v9 = "s hs traffic";
if ( (a2 & 0x10) != 0 && (a2 & 2) != 0 || (a2 & 0x20) != 0 && v3 )
{
if ( (a2 & 0x40) != 0 )
{
v10 = FUNC(*(_QWORD *)(a1 + 1288));
v11 = a1 + 308;
v9 = "c e traffic";
v12 = FUNC(*(_QWORD *)(*(_QWORD *)(a1 + 168) + 224i64), 3i64, 0i64);
v13 = v12;
if ( v12 <= 0 )
{
FUNC((_DWORD *)a1, 0x50u, 440, 332, (__int64)"ssl\\tls13_enc.c", 517);
goto LABEL_71;
}
if ( *(_DWORD *)(a1 + 132) == 2 )
{
v15 = *(_DWORD *)(a1 + 5904);
if ( v15 )
{
if ( !*(_DWORD *)(*(_QWORD *)(a1 + 1288) + 560i64) )
{
v16 = *(_QWORD *)(a1 + 1296);
if ( !v16 || v15 != *(_DWORD *)(v16 + 560) )
{
FUNC((_DWORD *)a1, 0x50u, 440, 68, (__int64)"ssl\\tls13_enc.c", 534);
goto LABEL_71;
}
v10 = FUNC(v16);
}
}
}
if ( !v10 )
{
FUNC((_DWORD *)a1, 0x50u, 440, 219, (__int64)"ssl\\tls13_enc.c", 541);
goto LABEL_71;
}
v17 = EVP_MD_CTX_new_0();
if ( !v17 )
{
FUNC((_DWORD *)a1, 0x50u, 440, 65, (__int64)"ssl\\tls13_enc.c", 553);
goto LABEL_71;
}
v18 = FUNC(v10);
v19 = FUNC(v18);
v20 = FUNC(v19);
v21 = *(_DWORD *)(v10 + 64);
v41 = v20;
v22 = FUNC(v21);
v23 = v22;
v39 = v22;
if ( !v22
|| !(unsigned int)FUNC(v17, v22, 0i64)
|| !(unsigned int)FUNC(v17, v45, v13)
|| !(unsigned int)FUNC(v17, Src, &v40) )
{
FUNC((_DWORD *)a1, 0x50u, 440, 68, (__int64)"ssl\\tls13_enc.c", 562);
FUNC(v17);
goto LABEL_71;
}
Size = v40;
FUNC(v17);
if ( !(unsigned int)FUNC(
(_DWORD *)a1,
v23,
a1 + 308,
(__int64)"e exp master",
0xCui64,
(__int64)Src,
Size,
a1 + 1012,
Size,
1) )
{
FUNC((_DWORD *)a1, 0x50u, 440, 68, (__int64)"ssl\\tls13_enc.c", 576);
goto LABEL_71;
}
if ( !(unsigned int)FUNC(a1, "EARLY_EXPORTER_SECRET", a1 + 1012, Size) )
goto LABEL_71;
v24 = 11i64;
v25 = "CLIENT_EARLY_TRAFFIC_SECRET";
}
else if ( a2 >= 0 )
{
v9 = "c ap traffic";
v11 = a1 + 436;
v24 = 12i64;
v25 = "CLIENT_TRAFFIC_SECRET_0";
v42 = (char *)(a1 + 692);
}
else
{
v11 = a1 + 372;
v37 = a1 + 564;
v26 = FUNC();
v9 = "c hs traffic";
v24 = 12i64;
v25 = "CLIENT_HANDSHAKE_TRAFFIC_SECRET";
v42 = (char *)(a1 + 756);
v38 = (int)FUNC(v26);
}
}
else if ( a2 >= 0 )
{
v11 = a1 + 436;
v9 = "s ap traffic";
v24 = 12i64;
v25 = "SERVER_TRAFFIC_SECRET_0";
}
else
{
v11 = a1 + 372;
v37 = a1 + 628;
v27 = FUNC();
v24 = 12i64;
v25 = "SERVER_HANDSHAKE_TRAFFIC_SECRET";
v38 = (int)FUNC(v27);
}
if ( (a2 & 0x40) != 0
|| (v39 = FUNC(), v41 = *(_QWORD *)(*(_QWORD *)(a1 + 168) + 632i64), (unsigned int)FUNC(a1, 1i64))
&& (unsigned int)FUNC(a1, (__int64)Src, 0x40ui64, &Size) )
{
v28 = Size;
if ( v9 == "s ap traffic" )
memmove((void *)(a1 + 692), Src, Size);
if ( v9 == "s hs traffic" )
memmove((void *)(a1 + 756), Src, v28);
if ( v9 != "c ap traffic"
|| (v29 = FUNC(),
(unsigned int)FUNC(
(_DWORD *)a1,
v29,
v11,
(__int64)"res master",
0xAui64,
(__int64)Src,
Size,
a1 + 500,
Size,
1)) )
{
v35 = v24;
v30 = (__int64)v42;
if ( (unsigned int)FUNC(
a1,
a2 & 2,
v39,
v41,
v11,
(__int64)v42,
(__int64)v9,
v35,
(__int64)v47,
v44,
v43) )
{
if ( v9 == "s ap traffic" )
{
memmove((void *)(a1 + 884), v47, Size);
v31 = FUNC();
if ( !(unsigned int)FUNC(
(_DWORD *)a1,
v31,
v11,
(__int64)"exp master",
0xAui64,
v30,
Size,
a1 + 948,
Size,
1)
|| !(unsigned int)FUNC(a1, "EXPORTER_SECRET", a1 + 948, Size) )
{
goto LABEL_71;
}
}
else if ( v9 == "c ap traffic" )
{
memmove((void *)(a1 + 820), v47, Size);
}
if ( (unsigned int)FUNC(a1, v25, (__int64)v47, Size) )
{
v32 = v37;
if ( !v37
|| (v33 = FUNC(),
(unsigned int)FUNC(
(_DWORD *)a1,
v33,
(__int64)v47,
(__int64)"finished",
8ui64,
0i64,
0i64,
v32,
v38,
1)) )
{
if ( *(_DWORD *)(a1 + 56) || v9 != "c e traffic" )
*(_DWORD *)(a1 + 124) = 0;
else
*(_DWORD *)(a1 + 124) = 2;
v2 = 1;
}
}
}
}
}
LABEL_71:
OPENSSL_cleanse_0((__int64)v47, 64i64);
return v2;
}
| openssl |
__int64 __fastcall FUNC(
ssl_st *a1,
__int64 a2,
unsigned int a3,
__int64 a4,
unsigned __int64 a5,
__int64 a6,
__int64 a7,
int a8)
{
__int64 v11; // rbp
unsigned int v12; // edi
evp_md_ctx_st *v13; // rbx
unsigned int v16; // [rsp+50h] [rbp-118h] BYREF
unsigned int v17; // [rsp+54h] [rbp-114h] BYREF
__int64 v18; // [rsp+58h] [rbp-110h]
char v19[64]; // [rsp+60h] [rbp-108h] BYREF
char v20[64]; // [rsp+A0h] [rbp-C8h] BYREF
char v21[64]; // [rsp+E0h] [rbp-88h] BYREF
v18 = a2;
v11 = FUNC();
v12 = 0;
v13 = EVP_MD_CTX_new_0();
if ( v13 && ossl_statem_export_allowed(a1) )
{
if ( !a8 )
a7 = 0i64;
if ( (int)FUNC(v13, v11, 0i64) > 0
&& (int)FUNC(v13, a6, a7) > 0
&& (int)FUNC(v13, v19, &v16) > 0
&& (int)FUNC(v13, v11, 0i64) > 0
&& (int)FUNC(v13, v20, &v17) > 0
&& (unsigned int)FUNC(a1, v11, (__int64)a1 + 948, a4, a5, (__int64)v20, v17, (__int64)v21, v16, 0)
&& (unsigned int)FUNC(a1, v11, (__int64)v21, (__int64)"exporter", 8ui64, (__int64)v19, v16, v18, a3, 0) )
{
v12 = 1;
}
}
FUNC(v13);
return v12;
}
| openssl |
__int64 __fastcall EVP_PKEY_base_id_0(const evp_pkey_st *pkey)
{
unsigned int *v1; // rax
unsigned int v2; // ebx
__int64 v4; // [rsp+30h] [rbp+8h] BYREF
v1 = (unsigned int *)FUNC(&v4, *(unsigned int *)pkey);
if ( v1 )
{
v2 = *v1;
FUNC(v4);
return v2;
}
else
{
FUNC(v4);
return 0i64;
}
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, const void *a2, size_t a3)
{
__int64 v3; // r12
__int64 v4; // rbx
__int64 v9; // rax
__int64 v10; // rax
__int64 v11; // rcx
int v12[4]; // [rsp+20h] [rbp-2C8h] BYREF
int v13[84]; // [rsp+30h] [rbp-2B8h] BYREF
size_t v14; // [rsp+180h] [rbp-168h]
char v15[296]; // [rsp+188h] [rbp-160h] BYREF
v3 = *(_QWORD *)(a1 + 1896);
v4 = 0i64;
if ( _bittest((const signed __int32 *)(v3 + 72), 8u) )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 1896);
if ( *(_QWORD *)(v10 + 96) )
{
v12[0] = 1;
v4 = (*(__int64 (__fastcall **)(__int64, const void *, _QWORD, int *))(v10 + 96))(a1, a2, (unsigned int)a3, v12);
if ( v4 )
{
_InterlockedExchangeAdd((volatile signed __int32 *)(*(_QWORD *)(a1 + 1896) + 144i64), 1u);
if ( v12[0] )
_InterlockedExchangeAdd((volatile signed __int32 *)(v4 + 468), 1u);
v11 = *(_QWORD *)(a1 + 1896);
if ( !_bittest((const signed __int32 *)(v11 + 72), 9u) )
FUNC(v11, v4);
}
}
return v4;
}
v13[0] = *(_DWORD *)a1;
if ( a3 > 0x20 )
return 0i64;
memmove(v15, a2, a3);
v14 = a3;
FUNC(*(_QWORD *)(v3 + 896));
v9 = FUNC(*(_QWORD *)(*(_QWORD *)(a1 + 1896) + 40i64), v13);
v4 = v9;
if ( v9 )
_InterlockedExchangeAdd((volatile signed __int32 *)(v9 + 468), 1u);
FUNC(*(_QWORD *)(*(_QWORD *)(a1 + 1896) + 896i64));
if ( !v4 )
{
_InterlockedExchangeAdd((volatile signed __int32 *)(*(_QWORD *)(a1 + 1896) + 128i64), 1u);
goto LABEL_8;
}
return v4;
}
| openssl |
__int64 __fastcall FUNC(__ExceptionPtr *a1, unsigned int a2, unsigned int a3, __int64 a4)
{
unsigned int v4; // ebx
__int64 v9; // rax
void **ThrowImageBase; // rax
_QWORD *v12; // rdi
__int64 v13; // rax
v4 = 0;
if ( a2 == 0x8000 )
{
ThrowImageBase = (void **)__ExceptionPtr::_GetThrowImageBase(a1);
v12 = ThrowImageBase;
if ( ThrowImageBase )
{
CRYPTO_free(*ThrowImageBase, "apps\\bf_prefix.c", 151);
v13 = FUNC(a4, "apps\\bf_prefix.c", 152i64);
*v12 = v13;
LOBYTE(v4) = v13 != 0;
}
}
else if ( FUNC(a1) )
{
v9 = FUNC(a1);
return FUNC(v9, a2, a3);
}
return v4;
}
| openssl |
__int64 __fastcall FUNC(Concurrency::details::VirtualProcessor *a1, __int64 a2, const void *a3)
{
struct Concurrency::details::SchedulingRing *OwningRing; // rsi
int v7; // eax
int v8; // eax
size_t v9; // rbx
void *v10; // rax
OwningRing = Concurrency::details::VirtualProcessor::GetOwningRing(a1);
if ( a3 )
{
if ( !a2 )
{
LABEL_10:
v9 = (int)FUNC(a1);
v10 = (void *)FUNC((__int64)a1);
memmove(v10, a3, v9);
*((_QWORD *)OwningRing + 31) = FUNC((__int64)a1);
return 1i64;
}
}
else if ( !a2 )
{
return 1i64;
}
if ( (unsigned int)FUNC((__int64)a1) )
{
v7 = FUNC((__int64)a1);
AES_set_encrypt_key(a2, (unsigned int)(8 * v7), OwningRing);
}
else
{
v8 = FUNC((__int64)a1);
AES_set_decrypt_key(a2, (unsigned int)(8 * v8), OwningRing);
}
if ( a3 )
goto LABEL_10;
*((_QWORD *)OwningRing + 31) = 0i64;
return 1i64;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2, __int64 a3)
{
__int64 v5; // rax
const char *v6; // rbp
bio_st *v7; // rcx
unsigned __int8 *v8; // rbx
unsigned __int8 i; // di
v5 = FUNC(a1, 0i64);
v6 = (const char *)v5;
if ( v5 )
{
v7 = *(bio_st **)(a3 + 8);
if ( v7 )
{
v8 = (unsigned __int8 *)v5;
BIO_printf(v7, "Hostname in TLS extension: \"");
for ( i = *v8; *v8; i = *v8 )
{
++v8;
if ( i < 0x80u && isprint(i) )
BIO_printf(*(bio_st **)(a3 + 8), "%c", i);
else
BIO_printf(*(bio_st **)(a3 + 8), "\\x%02x", i);
}
BIO_printf(*(bio_st **)(a3 + 8), "\"\n");
}
}
if ( !*(_QWORD *)a3 )
return 3i64;
if ( v6 )
{
if ( stricmp(v6, *(const char **)a3) )
return *(unsigned int *)(a3 + 16);
if ( qword_140280A78 )
{
BIO_printf(*(bio_st **)(a3 + 8), "Switching server context.\n");
FUNC(a1, qword_140280A78);
}
}
return 0i64;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2)
{
__int64 v2; // rax
unsigned int v3; // r12d
__int64 v5; // rsi
evp_pkey_st *pkey; // rax
evp_pkey_st *v9; // rbp
unsigned __int64 v10; // rax
unsigned __int8 *v11; // [rsp+50h] [rbp+8h] BYREF
v2 = *(_QWORD *)(a1 + 168);
v3 = 0;
v11 = 0i64;
v5 = *(_QWORD *)(v2 + 1032);
if ( v5 )
{
pkey = ssl_generate_pkey(*(evp_pkey_st **)(v2 + 1032));
v9 = pkey;
if ( pkey )
{
if ( (unsigned int)FUNC(a1, (__int64)pkey, v5, 0) )
{
v10 = EVP_PKEY_get1_tls_encodedpoint_0(v9, &v11);
if ( v10 )
{
if ( (unsigned int)FUNC(a2, v11, v10, 1i64) )
v3 = 1;
else
FUNC((_DWORD *)a1, 0x50u, 405, 68, (__int64)"ssl\\statem\\statem_clnt.c", 3150);
}
else
{
FUNC((_DWORD *)a1, 0x50u, 405, 16, (__int64)"ssl\\statem\\statem_clnt.c", 3144);
}
}
}
else
{
FUNC((_DWORD *)a1, 0x50u, 405, 65, (__int64)"ssl\\statem\\statem_clnt.c", 3130);
}
CRYPTO_free(v11, "ssl\\statem\\statem_clnt.c", 3156);
FUNC(v9);
return v3;
}
else
{
FUNC((_DWORD *)a1, 0x50u, 405, 68, (__int64)"ssl\\statem\\statem_clnt.c", 3123);
return 0i64;
}
}
| openssl |
char *__fastcall FUNC(char *a1)
{
char *v1; // rbx
char *v3; // rcx
unsigned int v4; // eax
char *v5; // rdi
v1 = a1;
if ( *a1 )
{
while ( (unsigned int)FUNC((unsigned int)*v1, 8i64) )
{
if ( !*++v1 )
return 0i64;
}
}
if ( !*v1 )
return 0i64;
v3 = v1;
v4 = 0;
do
{
if ( v4 >= 0x80000000 )
break;
++v3;
++v4;
}
while ( *v3 );
v5 = &v1[(v4 & 0x7FFFFFFF) - 1];
if ( v5 != v1 )
{
while ( (unsigned int)FUNC((unsigned int)*v5, 8i64) )
{
if ( --v5 == v1 )
goto LABEL_16;
}
if ( v1 != v5 )
v5[1] = 0;
}
LABEL_16:
if ( !*v1 )
return 0i64;
return v1;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2)
{
*(_QWORD *)(a1 + 96) = a2;
return 1i64;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, unsigned __int8 ***a2, _DWORD *a3, unsigned __int8 ****a4)
{
unsigned __int8 ***v7; // rbx
int v8; // eax
unsigned __int8 **v9; // rax
unsigned __int8 **v10; // r11
unsigned __int8 **v11; // [rsp+58h] [rbp+20h] BYREF
if ( !a4 )
return 0i64;
v7 = *a4;
v8 = FUNC(**a4, 0i64, (__int64)(*a4)[1]);
v9 = (unsigned __int8 **)CRYPTO_malloc(v8, "crypto\\asn1\\bio_ndef.c", 116i64);
v11 = v9;
if ( !v9 )
{
FUNC(13, 127, 65, (__int64)"crypto\\asn1\\bio_ndef.c", 117);
return 0i64;
}
v7[5] = v9;
*a2 = v11;
FUNC(*v7, (__int64 *)&v11, (__int64)v7[1]);
v10 = v7[4];
if ( !*v10 )
return 0i64;
*a3 = *(_DWORD *)v10 - *(_DWORD *)a2;
return 1i64;
}
| openssl |
void __fastcall FUNC(_QWORD *a1)
{
if ( a1 )
{
FUNC(a1);
CRYPTO_free(a1, "crypto\\x509\\x509_vfy.c", 2200i64);
}
}
| openssl |
__int64 __fastcall FUNC(int a1, int a2, int a3, int a4, __int64 a5, int a6)
{
if ( a6 )
return FUNC(a1, a2, a3, a4, a5, (__int64)FUNC);
else
return FUNC(a1, a2, a3, a4, a5, (__int64)FUNC);
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2, unsigned int *a3, __int64 a4, _BYTE *a5, int a6)
{
_BYTE *v6; // rdi
_BYTE *v10; // rbp
int v11; // eax
size_t v12; // r14
int v13; // esi
int v14; // r15d
int v15; // r11d
__int64 *v16; // rsi
int v17; // ecx
int v18; // r12d
size_t v19; // rbx
_BYTE *v20; // rax
_BYTE *v21; // rcx
__int64 v22; // rdi
char v23; // al
unsigned int v24; // r13d
int v25; // ebx
_BYTE *v26; // rax
__int64 v27; // rax
int v28; // ebx
int v29; // r12d
int v31; // [rsp+20h] [rbp-C8h]
__int64 *v32; // [rsp+30h] [rbp-B8h]
_BYTE *Buf2; // [rsp+38h] [rbp-B0h]
char Buf1[64]; // [rsp+50h] [rbp-98h] BYREF
v6 = a5;
v10 = 0i64;
v32 = (__int64 *)EVP_MD_CTX_new_0();
if ( !v32 )
{
v16 = 0i64;
goto LABEL_51;
}
if ( !a4 )
a4 = (__int64)a3;
v11 = FUNC((__int64)a3);
v12 = v11;
if ( v11 < 0 )
goto LABEL_11;
v13 = a6;
if ( a6 == -1 )
{
v13 = v11;
}
else if ( a6 < -3 )
{
FUNC(4, 126, 136, (__int64)"crypto\\rsa\\rsa_pss.c", 63);
goto LABEL_11;
}
v14 = ((unsigned __int8)FUNC(*(_QWORD *)(a1 + 24)) - 1) & 7;
v15 = RSA_size_0((const rsa_st *)a1);
if ( ((unsigned __int8)(255 << v14) & *a5) != 0 )
{
FUNC(4, 126, 133, (__int64)"crypto\\rsa\\rsa_pss.c", 70);
v16 = v32;
LABEL_51:
v24 = 0;
goto LABEL_52;
}
if ( !v14 )
{
v6 = a5 + 1;
--v15;
}
if ( v15 < (int)v12 + 2 )
{
v31 = 78;
LABEL_16:
FUNC(4, 126, 109, (__int64)"crypto\\rsa\\rsa_pss.c", v31);
LABEL_17:
v16 = v32;
goto LABEL_51;
}
v17 = v15 - v12;
if ( v13 == -3 )
{
v13 = v17 - 2;
}
else if ( v13 > v17 - 2 )
{
v31 = 84;
goto LABEL_16;
}
if ( v6[v15 - 1] != 0xBC )
{
FUNC(4, 126, 134, (__int64)"crypto\\rsa\\rsa_pss.c", 88);
goto LABEL_17;
}
v18 = v17 - 1;
v19 = v17 - 1;
Buf2 = &v6[v19];
v20 = CRYPTO_malloc(v19, "crypto\\rsa\\rsa_pss.c", 93i64);
v10 = v20;
if ( !v20 )
{
FUNC(4, 126, 65, (__int64)"crypto\\rsa\\rsa_pss.c", 95);
goto LABEL_17;
}
if ( (int)FUNC((_DWORD)v20, v18, (_DWORD)Buf2, v12, a4) < 0 )
{
LABEL_11:
v16 = v32;
goto LABEL_51;
}
if ( v18 > 0 )
{
v21 = v10;
v22 = v6 - v10;
do
{
v23 = (v21++)[v22];
*(v21 - 1) ^= v23;
--v19;
}
while ( v19 );
}
if ( v14 )
*v10 &= 255 >> (8 - v14);
v24 = 0;
v25 = 0;
if ( !*v10 )
{
v26 = v10;
do
{
if ( v25 >= v18 - 1 )
break;
++v26;
++v25;
}
while ( !*v26 );
}
v27 = v25;
v28 = v25 + 1;
if ( v10[v27] == 1 )
{
if ( v13 == -2 || v18 - v28 == v13 )
{
v16 = v32;
if ( (unsigned int)FUNC((__int64)v32, a3, 0i64) )
{
if ( (unsigned int)FUNC((__int64)v32, (__int64)&unk_14023D038, 8i64) )
{
if ( (unsigned int)FUNC((__int64)v32, a2, v12) )
{
v29 = v18 - v28;
if ( !v29 || (unsigned int)FUNC((__int64)v32, (__int64)&v10[v28], v29) )
{
if ( (unsigned int)FUNC(v32, (__int64)Buf1, 0i64) )
{
if ( !memcmp(Buf1, Buf2, v12) )
v24 = 1;
else
FUNC(4, 126, 104, (__int64)"crypto\\rsa\\rsa_pss.c", 124);
}
}
}
}
}
}
else
{
FUNC(4, 126, 136, (__int64)"crypto\\rsa\\rsa_pss.c", 110);
v16 = v32;
}
}
else
{
FUNC(4, 126, 135, (__int64)"crypto\\rsa\\rsa_pss.c", 106);
v16 = v32;
}
LABEL_52:
CRYPTO_free(v10, "crypto\\rsa\\rsa_pss.c", 131i64);
FUNC(v16);
return v24;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, int a2, __int64 a3)
{
__int64 v3; // rax
if ( !a1 || a2 < 0 || a2 >= *(_DWORD *)a1 )
return 0i64;
*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8i64 * a2) = a3;
v3 = *(_QWORD *)(a1 + 8);
*(_DWORD *)(a1 + 16) = 0;
return *(_QWORD *)(v3 + 8i64 * a2);
}
| openssl |
unsigned int *__fastcall FUNC(__int64 a1, __int64 a2, unsigned int *a3)
{
int v6; // esi
unsigned int *v7; // rdi
int v9; // ebx
__int64 v10; // rax
__int64 v11; // rax
v6 = FUNC(a3);
v7 = (unsigned int *)FUNC(0i64, v6);
if ( v7 )
{
v9 = 0;
if ( v6 <= 0 )
{
return v7;
}
else
{
while ( 1 )
{
v10 = FUNC((__int64)a3, v9);
v11 = FUNC(0i64, a1, a2, v10, 0);
if ( !v11 )
break;
OPENSSL_sk_push_0(v7, v11);
if ( ++v9 >= v6 )
return v7;
}
FUNC(v7, (void (__fastcall *)(_QWORD))FUNC);
return 0i64;
}
}
else
{
FUNC(34, 118, 65, (__int64)"crypto\\x509v3\\v3_alt.c", 389);
FUNC(0i64);
return 0i64;
}
}
| openssl |
struct evp_pkey_st *__fastcall ssl_dh_to_pkey(struct dh_st *dh)
{
__int64 v3; // rbx
if ( !dh )
return 0i64;
v3 = FUNC();
if ( (int)FUNC(v3, dh) > 0 )
return (struct evp_pkey_st *)v3;
FUNC(v3);
return 0i64;
}
| openssl |
void __fastcall FUNC(void *a1)
{
ASN1_item_free(a1, (__int64)&unk_140221040);
}
| openssl |
BOOL __fastcall _crtInitCritSecAndSpinCount(_RTL_CRITICAL_SECTION *lpCriticalSection, DWORD dwSpinCount)
{
return InitializeCriticalSectionAndSpinCount(lpCriticalSection, dwSpinCount);
}
| openssl |
__int64 __fastcall FUNC()
{
int v0; // eax
return FUNC((unsigned int)(v0 - 30));
}
| openssl |
__int64 ENGINE_register_all_complete_0()
{
__int64 i; // rbx
for ( i = FUNC(); i; i = FUNC(i) )
{
if ( (*(_BYTE *)(i + 152) & 8) == 0 )
{
FUNC(i);
FUNC(i);
ENGINE_register_RSA(i);
ENGINE_register_DSA(i);
ENGINE_register_DH(i);
ENGINE_register_ECDH(i);
ENGINE_register_ECDSA(i);
ENGINE_register_ciphers(i);
ENGINE_register_digests(i);
}
}
return 1i64;
}
| openssl |
_QWORD *__fastcall OCSP_cert_to_id(unsigned int *a1, __int64 a2, __int64 a3)
{
unsigned int *v5; // rdi
int v6; // ebp
__int64 v7; // rbx
int *v8; // rax
v5 = a1;
if ( !a1 )
v5 = (unsigned int *)FUNC();
if ( a2 )
{
v6 = FUNC(a2);
v7 = FUNC(a2);
}
else
{
v7 = 0i64;
v6 = FUNC(a3);
}
v8 = (int *)FUNC(a3);
return FUNC(v5, v6, v8, v7);
}
| openssl |
__int64 __fastcall FUNC(__int64 a1)
{
__int64 v2; // rax
__int64 v3; // rbx
v2 = FUNC(a1);
v3 = v2;
if ( v2 )
{
CryptDestroyKey(*(_QWORD *)(v2 + 16));
CryptReleaseContext(*(_QWORD *)(v3 + 8), 0);
if ( *(_QWORD *)v3 )
CertFreeCertificateContext(*(PCCERT_CONTEXT *)v3);
CRYPTO_free((void *)v3, "engines\\e_capi.c", 1594i64);
}
FUNC(a1);
return 1i64;
}
| openssl |
_BYTE *__fastcall FUNC(_QWORD *a1, _BYTE *a2)
{
__int64 v2; // rdi
_BYTE *v5; // r8
unsigned int i; // eax
unsigned __int64 v7; // rsi
_BYTE *v9; // rax
unsigned int j; // ebx
int v11; // ebx
_BYTE *v12; // r11
const char *v13; // rax
__int64 v14; // rcx
char v15; // al
v2 = 0i64;
v5 = a2;
for ( i = 0; *v5; ++i )
{
if ( i >= 0x80000000 )
break;
++v5;
}
v7 = i & 0x7FFFFFFF;
if ( v7 >= 0xFFFF )
return 0i64;
v9 = a2;
for ( j = 0; *v9; ++j )
{
if ( j >= 0x80000000 )
break;
++v9;
}
v11 = (j & 0x7FFFFFFF) + 1;
v12 = CRYPTO_malloc(v11, "apps\\apps.c", 957);
if ( !v12 )
{
v13 = (const char *)FUNC();
BIO_printf(qword_1402808E8, "%s: Could not allocate %d bytes for %s\n", v13, (unsigned int)v11, "NPN buffer");
X509_ALGOR_dup_0(qword_1402808E8);
exit(1);
}
v14 = 0i64;
while ( v14 != v7 )
{
v15 = a2[v14];
if ( v15 == 44 )
break;
v12[v14 + 1] = v15;
LABEL_17:
if ( ++v14 > v7 )
{
*a1 = v7 + 1;
return v12;
}
}
if ( (unsigned __int64)(v14 - v2) <= 0xFF )
{
v12[v2] = v14 - v2;
v2 = v14 + 1;
goto LABEL_17;
}
CRYPTO_free(v12, "apps\\apps.c", 1974);
return 0i64;
}
| openssl |
__int64 __fastcall strtoxl(const __m128i *a1, const char *a2, const char **a3, int a4, int a5)
{
unsigned __int8 v8; // bp
struct __crt_locale_data *locinfo; // r8
unsigned int v10; // edi
const char *i; // rbx
int v12; // eax
int v13; // esi
__int64 v14; // r10
unsigned int v15; // r9d
unsigned int v16; // ecx
int v17; // ecx
const char *v18; // rbx
__crt_locale_pointers Locale; // [rsp+30h] [rbp-38h] BYREF
__int64 v21; // [rsp+40h] [rbp-28h]
char v22; // [rsp+48h] [rbp-20h]
_LocaleUpdate::_LocaleUpdate((_LocaleUpdate *)&Locale, a1);
if ( a3 )
*a3 = a2;
if ( !a2 || a4 && (a4 < 2 || a4 > 36) )
{
*errno() = 22;
invalid_parameter(0i64, 0i64, 0i64, 0, 0i64);
if ( v22 )
*(_DWORD *)(v21 + 200) &= ~2u;
return 0i64;
}
v8 = *a2;
locinfo = Locale.locinfo;
v10 = 0;
for ( i = a2 + 1; ; ++i )
{
if ( *((int *)locinfo + 67) <= 1 )
{
v12 = *(_WORD *)(*((_QWORD *)locinfo + 40) + 2i64 * v8) & 8;
}
else
{
v12 = isctype_l(v8, 8, &Locale);
locinfo = Locale.locinfo;
}
if ( !v12 )
break;
v8 = *i;
}
v13 = a5;
if ( v8 == 45 )
{
v13 = a5 | 2;
}
else if ( v8 != 43 )
{
goto LABEL_18;
}
v8 = *i++;
LABEL_18:
if ( a4 )
{
if ( a4 != 16 || v8 != 48 )
goto LABEL_30;
}
else
{
if ( v8 != 48 )
{
a4 = 10;
goto LABEL_30;
}
if ( *i != 120 && *i != 88 )
{
a4 = 8;
goto LABEL_30;
}
a4 = 16;
}
if ( *i == 120 || *i == 88 )
{
v8 = i[1];
i += 2;
}
LABEL_30:
v14 = *((_QWORD *)locinfo + 40);
v15 = 0xFFFFFFFF / a4;
while ( 1 )
{
if ( (*(_WORD *)(v14 + 2i64 * v8) & 4) != 0 )
{
v16 = (char)v8 - 48;
}
else
{
if ( (*(_WORD *)(v14 + 2i64 * v8) & 0x103) == 0 )
break;
v17 = (char)v8;
if ( (unsigned __int8)(v8 - 97) <= 0x19u )
v17 = (char)v8 - 32;
v16 = v17 - 55;
}
if ( v16 >= a4 )
break;
v13 |= 8u;
if ( v10 < v15 || v10 == v15 && v16 <= 0xFFFFFFFF % a4 )
{
v10 = v16 + a4 * v10;
}
else
{
v13 |= 4u;
if ( !a3 )
break;
}
v8 = *i++;
}
v18 = i - 1;
if ( (v13 & 8) != 0 )
{
if ( (v13 & 4) != 0 || (v13 & 1) == 0 && ((v13 & 2) != 0 && v10 > 0x80000000 || (v13 & 2) == 0 && v10 > 0x7FFFFFFF) )
{
*errno() = 34;
if ( (v13 & 1) != 0 )
v10 = -1;
else
v10 = ((v13 & 2) != 0) + 0x7FFFFFFF;
}
}
else
{
if ( a3 )
v18 = a2;
v10 = 0;
}
if ( a3 )
*a3 = v18;
if ( (v13 & 2) != 0 )
v10 = -v10;
if ( v22 )
*(_DWORD *)(v21 + 200) &= ~2u;
return v10;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1)
{
return *(unsigned int *)(a1 + 1484);
}
| openssl |
__int64 __fastcall FUNC(const unsigned __int8 *a1, int a2, unsigned int a3)
{
__int64 v6; // rbx
const unsigned __int8 *v8; // rsi
__int64 v9; // rax
__int64 v10; // rax
__int64 v11; // rax
int v12; // edi
unsigned int v13; // eax
__int64 v14; // rax
__int64 v15; // rax
__int64 v16[7]; // [rsp+30h] [rbp-38h] BYREF
int v17; // [rsp+88h] [rbp+20h] BYREF
v6 = FUNC();
if ( !v6 )
{
FUNC(13, 179, 65, (unsigned int)"crypto\\asn1\\asn1_gen.c", 587);
return 0i64;
}
v8 = (const unsigned __int8 *)&byte_1401BE510;
if ( a1 )
v8 = a1;
switch ( a3 )
{
case 1u:
if ( a2 != 1 )
{
FUNC(13, 179, 190, (unsigned int)"crypto\\asn1\\asn1_gen.c", 605);
goto LABEL_54;
}
v16[1] = 0i64;
v16[0] = 0i64;
v16[2] = (__int64)v8;
if ( (unsigned int)FUNC(v16, v6 + 8) )
goto LABEL_46;
FUNC(13, 179, 176, (unsigned int)"crypto\\asn1\\asn1_gen.c", 612);
goto LABEL_53;
case 2u:
case 0xAu:
if ( a2 != 1 )
{
FUNC(13, 179, 185, (unsigned int)"crypto\\asn1\\asn1_gen.c", 620);
goto LABEL_54;
}
v9 = FUNC(0i64, v8);
*(_QWORD *)(v6 + 8) = v9;
if ( v9 )
goto LABEL_46;
FUNC(13, 179, 180, (unsigned int)"crypto\\asn1\\asn1_gen.c", 625);
goto LABEL_53;
case 3u:
case 4u:
v14 = FUNC();
*(_QWORD *)(v6 + 8) = v14;
if ( !v14 )
{
FUNC(13, 179, 65, (unsigned int)"crypto\\asn1\\asn1_gen.c", 692);
goto LABEL_54;
}
if ( a2 == 3 )
{
v15 = FUNC(v8, &v17);
if ( !v15 )
{
FUNC(13, 179, 178, (unsigned int)"crypto\\asn1\\asn1_gen.c", 698);
goto LABEL_53;
}
*(_QWORD *)(*(_QWORD *)(v6 + 8) + 8i64) = v15;
**(_DWORD **)(v6 + 8) = v17;
*(_DWORD *)(*(_QWORD *)(v6 + 8) + 4i64) = a3;
goto LABEL_44;
}
if ( a2 == 1 )
{
FUNC(v14, v8, 0xFFFFFFFFi64);
LABEL_44:
if ( a3 == 3 )
{
*(_DWORD *)(*(_QWORD *)(v6 + 8) + 16i64) &= 0xFFFFFFF0;
*(_DWORD *)(*(_QWORD *)(v6 + 8) + 16i64) |= 8u;
}
goto LABEL_46;
}
if ( a2 != 4 || a3 != 3 )
{
FUNC(13, 179, 175, (unsigned int)"crypto\\asn1\\asn1_gen.c", 716);
goto LABEL_54;
}
if ( (unsigned int)FUNC((_DWORD)v8, 44, 1, (unsigned int)FUNC, v14) )
goto LABEL_46;
FUNC(13, 179, 188, (unsigned int)"crypto\\asn1\\asn1_gen.c", 710);
LABEL_53:
ERR_add_error_data(2, "string=", v8);
LABEL_54:
FUNC(v6);
return 0i64;
case 5u:
if ( !v8 || !*v8 )
goto LABEL_46;
FUNC(13, 179, 182, (unsigned int)"crypto\\asn1\\asn1_gen.c", 598);
goto LABEL_54;
case 6u:
if ( a2 != 1 )
{
FUNC(13, 179, 191, (unsigned int)"crypto\\asn1\\asn1_gen.c", 632);
goto LABEL_54;
}
v10 = FUNC(v8, 0i64);
*(_QWORD *)(v6 + 8) = v10;
if ( v10 )
goto LABEL_46;
FUNC(13, 179, 183, (unsigned int)"crypto\\asn1\\asn1_gen.c", 636);
goto LABEL_53;
case 0xCu:
case 0x12u:
case 0x13u:
case 0x14u:
case 0x16u:
case 0x1Au:
case 0x1Bu:
case 0x1Cu:
case 0x1Eu:
if ( a2 == 1 )
{
v12 = 4097;
}
else
{
if ( a2 != 2 )
{
FUNC(13, 179, 177, (unsigned int)"crypto\\asn1\\asn1_gen.c", 677);
goto LABEL_54;
}
v12 = 4096;
}
v13 = FUNC(a3);
if ( ASN1_mbstring_copy_0((asn1_string_st **)(v6 + 8), v8, -1, v12, v13) > 0 )
goto LABEL_46;
FUNC(13, 179, 65, (unsigned int)"crypto\\asn1\\asn1_gen.c", 683);
goto LABEL_53;
case 0x17u:
case 0x18u:
if ( a2 != 1 )
{
FUNC(13, 179, 193, (unsigned int)"crypto\\asn1\\asn1_gen.c", 644);
goto LABEL_54;
}
v11 = FUNC();
*(_QWORD *)(v6 + 8) = v11;
if ( !v11 )
{
FUNC(13, 179, 65, (unsigned int)"crypto\\asn1\\asn1_gen.c", 648);
goto LABEL_53;
}
if ( !(unsigned int)FUNC(v11, v8, 0xFFFFFFFFi64) )
{
FUNC(13, 179, 65, (unsigned int)"crypto\\asn1\\asn1_gen.c", 652);
goto LABEL_53;
}
*(_DWORD *)(*(_QWORD *)(v6 + 8) + 4i64) = a3;
if ( !(unsigned int)ASN1_TIME_check_0(*(_QWORD *)(v6 + 8)) )
{
FUNC(13, 179, 184, (unsigned int)"crypto\\asn1\\asn1_gen.c", 657);
goto LABEL_53;
}
LABEL_46:
*(_DWORD *)v6 = a3;
return v6;
default:
FUNC(13, 179, 196, (unsigned int)"crypto\\asn1\\asn1_gen.c", 729);
goto LABEL_53;
}
}
| openssl |
void *FUNC()
{
return &unk_14020AC30;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1)
{
__int64 v1; // rbx
const char *v2; // rax
__int64 v3; // rax
_QWORD *v4; // rax
_QWORD *v5; // r12
unsigned int v6; // edi
unsigned int v7; // eax
const char *v8; // rbx
const char *v9; // rax
__int64 v10; // rax
__int64 v11; // rax
__int64 v12; // rdi
__int64 v13; // r9
unsigned int v14; // eax
const char *v15; // rbx
unsigned int v16; // eax
__int64 v17; // rax
__int64 v18; // rax
_QWORD *v19; // rbp
int v20; // esi
int v21; // edi
unsigned int v22; // ebx
unsigned int v23; // eax
__int64 v24; // rax
__int64 v25; // rax
__int64 v26; // rbx
unsigned int v27; // eax
int v29; // [rsp+68h] [rbp+10h] BYREF
__int64 v30; // [rsp+70h] [rbp+18h] BYREF
__int64 v31; // [rsp+78h] [rbp+20h] BYREF
X509_ALGOR_get0(&v30, &v29, &v31, a1);
v1 = (unsigned int)FUNC(v30);
v2 = (const char *)FUNC(v1);
BIO_printf(qword_1402808E8, "%s", v2);
if ( (_DWORD)v1 != 161 )
{
if ( v29 == 16 )
{
v24 = FUNC();
v25 = FUNC(v31, v24);
v26 = v25;
if ( v25 )
{
v27 = FUNC(*(_QWORD *)(v25 + 8));
BIO_printf(qword_1402808E8, ", Iteration %ld", v27);
FUNC(v26);
goto LABEL_20;
}
}
goto LABEL_19;
}
if ( v29 != 16 )
goto LABEL_19;
v3 = FUNC();
v4 = (_QWORD *)FUNC(v31, v3);
v5 = v4;
if ( !v4 )
goto LABEL_19;
X509_ALGOR_get0(&v30, &v29, &v31, *v4);
v6 = FUNC(v30);
X509_ALGOR_get0(&v30, 0i64, 0i64, v5[1]);
v7 = FUNC(v30);
v8 = (const char *)FUNC(v7);
v9 = (const char *)FUNC(v6);
BIO_printf(qword_1402808E8, ", %s, %s", v9, v8);
if ( v6 != 69 )
{
if ( v6 == 973 )
{
if ( v29 != 16 )
goto LABEL_19;
v17 = FUNC();
v18 = FUNC(v31, v17);
v19 = (_QWORD *)v18;
if ( !v18 )
goto LABEL_19;
v20 = FUNC(*(_QWORD *)(v18 + 24));
v21 = FUNC(v19[2]);
v22 = FUNC(v19[1]);
v23 = FUNC(*v19);
BIO_printf(
qword_1402808E8,
", Salt length: %d, Cost(N): %ld, Block size(r): %ld, Parallelism(p): %ld",
v23,
v22,
v21,
v20);
FUNC(v19);
}
FUNC(v5);
goto LABEL_20;
}
if ( v29 != 16 || (v10 = FUNC(), v11 = FUNC(v31, v10), (v12 = v11) == 0) )
{
LABEL_19:
FUNC(qword_1402808E8, ", <unsupported parameters>");
goto LABEL_20;
}
v13 = *(_QWORD *)(v11 + 24);
if ( v13 )
{
X509_ALGOR_get0(&v30, 0i64, 0i64, v13);
v14 = FUNC(v30);
}
else
{
v14 = 163;
}
v15 = (const char *)FUNC(v14);
v16 = FUNC(*(_QWORD *)(v12 + 8));
BIO_printf(qword_1402808E8, ", Iteration %ld, PRF %s", v16, v15);
FUNC(v12);
FUNC(v5);
LABEL_20:
FUNC(qword_1402808E8, "\n");
return 1i64;
}
| openssl |
__int64 __fastcall FUNC(volatile signed __int32 *a1, __int64 a2, __int64 a3, int a4, __int64 a5)
{
int v5; // eax
__int64 v6; // r12
__int64 v9; // rbx
unsigned int v11; // ebp
int v13; // eax
volatile signed __int32 *v14; // rbx
volatile signed __int32 *v15; // [rsp+30h] [rbp-48h] BYREF
volatile signed __int32 *v16; // [rsp+38h] [rbp-40h]
__int64 v17; // [rsp+40h] [rbp-38h]
__int64 v18; // [rsp+90h] [rbp+18h] BYREF
v18 = a3;
v6 = a5;
v9 = *(_QWORD *)(a5 + 24);
v11 = v5 - 79;
if ( (a4 & 0x40) == 0 || (a4 & 0x8000) != 0 )
{
FUNC(a2, (__int64)a1, a4);
return v11;
}
else if ( v9 && *(_QWORD *)(v9 + 24) )
{
v15 = a1;
v16 = 0i64;
v17 = 0i64;
if ( (*(int (__fastcall **)(_QWORD, __int64 *, __int64, volatile signed __int32 **))(v9 + 24))(
(unsigned int)(v5 - 68),
&v18,
a5,
&v15) > 0 )
{
FUNC(a2, (__int64)v16, a4);
v13 = (*(__int64 (__fastcall **)(__int64, __int64 *, __int64, volatile signed __int32 **))(v9 + 24))(
13i64,
&v18,
v6,
&v15);
v14 = v16;
if ( v13 <= 0 )
v11 = 0;
if ( v16 != a1 )
{
do
{
v14 = (volatile signed __int32 *)FUNC(v14);
FUNC(v16);
v16 = v14;
}
while ( v14 != a1 );
}
return v11;
}
else
{
return 0i64;
}
}
else
{
FUNC(13, 214, 202, (__int64)"crypto\\asn1\\asn_mime.c", 332);
return 0i64;
}
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2)
{
int v2; // eax
return FUNC(v2 - 38, a1, a2);
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2, int a3)
{
int v3; // eax
__int64 result; // rax
__int64 v5; // [rsp+58h] [rbp+20h] BYREF
if ( a3 >= 0 )
{
result = FUNC(a1, a2, a3, &v5);
if ( (int)result > 0 )
return (unsigned int)v5;
}
else
{
FUNC(v3 - 36, 223, 271, (unsigned int)"ssl\\ssl_lib.c", 1771);
return 0xFFFFFFFFi64;
}
return result;
}
| openssl |
__int64 __fastcall FUNC(Concurrency::details::VirtualProcessor *a1, int a2, int a3, int a4)
{
struct Concurrency::details::SchedulingRing *OwningRing; // rax
__int64 v9; // rbp
struct Concurrency::details::SchedulingRing *v10; // rsi
__int64 v11; // rbx
__int64 v12; // rax
int v14[4]; // [rsp+40h] [rbp-28h] BYREF
v14[0] = FUNC((__int64)a1);
OwningRing = Concurrency::details::VirtualProcessor::GetOwningRing(a1);
v9 = *((_QWORD *)OwningRing + 36);
v10 = OwningRing;
v11 = FUNC((__int64)a1);
v12 = FUNC((__int64)a1);
if ( v9 )
FUNC(a3, a2, a4, (_DWORD)v10, v12, v11, (__int64)v14, v9);
else
CRYPTO_ctr128_encrypt(a3, a2, a4, (_DWORD)v10, v12, v11, (__int64)v14, *((_QWORD *)v10 + 35));
FUNC((__int64)a1, v14[0]);
return 1i64;
}
| openssl |
__int64 __fastcall PEM_write_SSL_SESSION_2(__int64 a1, __int64 a2)
{
return FUNC(
(__int64 (__fastcall *)(__int64, char **))FUNC,
"NEW CERTIFICATE REQUEST",
a1,
a2,
0i64,
0i64,
0,
0i64,
0i64);
}
| openssl |
__int64 __fastcall FUNC(int *a1)
{
int v1; // eax
__int64 result; // rax
v1 = a1[13];
if ( v1 || a1[14] )
{
result = (unsigned int)(v1 + 1);
a1[13] = result;
}
else
{
result = FUNC((__int64)(a1 + 8), a1[12]);
if ( !(_DWORD)result )
{
result = (__int64)FUNC(3, 129, 109, (__int64)"crypto\\bn\\bn_ctx.c", 189);
++a1[13];
}
}
return result;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1)
{
return a1 + 24;
}
| openssl |
_QWORD *__fastcall FUNC(__int64 *a1, unsigned int *a2)
{
int v2; // eax
int v4; // ebx
_QWORD *v6; // rdi
int attr_by_NID; // r12d
__int64 entry_0; // rax
__int64 v9; // rax
__int64 v10; // rsi
_BYTE *v11; // rax
void *v12; // rsi
__int64 v13; // rax
void *v15; // [rsp+50h] [rbp+18h] BYREF
v4 = 0;
v6 = 0i64;
v15 = 0i64;
attr_by_NID = X509at_get_attr_by_NID(a1, v2 + 16, -1);
if ( attr_by_NID < 0 )
{
LABEL_11:
if ( (int)FUNC(a2) <= 0 )
return v6;
while ( 1 )
{
v13 = FUNC((__int64)a2, v4);
if ( *(_DWORD *)v13 == 1 && !(unsigned int)FUNC(&v15, *(_QWORD *)(v13 + 8)) )
break;
if ( ++v4 >= (int)FUNC(a2) )
return v15;
}
}
else
{
while ( 1 )
{
entry_0 = X509_NAME_get_entry_0(a1, attr_by_NID);
v9 = FUNC(entry_0);
v10 = v9;
if ( *(_DWORD *)(v9 + 4) == 22 && *(_QWORD *)(v9 + 8) && *(_DWORD *)v9 )
{
if ( !v6 )
{
v6 = FUNC((__int64)FUNC);
v15 = v6;
if ( !v6 )
return 0i64;
}
if ( (unsigned int)FUNC((int *)v6, *(_QWORD *)(v10 + 8)) == -1 )
{
v11 = FUNC(*(char **)(v10 + 8), "crypto\\x509v3\\v3_utl.c", 514i64);
v12 = v11;
if ( !v11 || !(unsigned int)OPENSSL_sk_push_0((unsigned int *)v6, (__int64)v11) )
break;
}
}
attr_by_NID = X509at_get_attr_by_NID(a1, 0x30u, attr_by_NID);
if ( attr_by_NID < 0 )
goto LABEL_11;
}
CRYPTO_free(v12, "crypto\\x509v3\\v3_utl.c", 516i64);
FUNC(v6, (void (__fastcall *)(_QWORD))FUNC);
}
return 0i64;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, _QWORD *a2, _QWORD *a3, _QWORD *a4)
{
int v4; // eax
_QWORD *v6; // rcx
if ( *(_DWORD *)a1 )
{
FUNC(v4 - 10, v4 + 86, v4 + 68, (__int64)"crypto\\cms\\cms_env.c", 238);
return 0i64;
}
else
{
v6 = *(_QWORD **)(a1 + 8);
if ( a2 )
*a2 = v6[5];
if ( a3 )
*a3 = v6[4];
if ( a4 )
*a4 = v6[2];
return 1i64;
}
}
| openssl |
void __fastcall FUNC(void *a1)
{
CRYPTO_free(a1, "crypto\\evp\\evp_pbe.c", 240i64);
}
| openssl |
__int64 __fastcall FUNC(__int64 a1)
{
return FUNC(*(_QWORD *)(a1 + 40));
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 *a2, _DWORD *a3, int *a4)
{
unsigned int v4; // esi
__int64 v10; // rax
const bignum_st *v11; // rbp
v4 = 0;
if ( *a3 )
{
FUNC(a4);
v10 = FUNC(a4);
v11 = (const bignum_st *)v10;
if ( v10 )
{
if ( (unsigned int)FUNC(v10, *a3 - 1) )
v4 = FUNC(a1, a2, v11, a3, a4);
}
FUNC((__int64)a4);
return v4;
}
else
{
FUNC(a1, 0i64);
return 1i64;
}
}
| openssl |
_QWORD *__fastcall FUNC(__int64 *a1)
{
_QWORD *v2; // rbx
__int64 v4; // rsi
int v5; // edi
__int64 v6; // rax
__int64 v7; // rax
v2 = 0i64;
if ( (unsigned int)FUNC(*a1) == 22 )
{
v4 = a1[1];
if ( v4 )
{
if ( *(_DWORD *)(*(_QWORD *)(v4 + 16) + 16i64) )
FUNC(v4);
v5 = 0;
if ( (int)FUNC(*(unsigned int **)(v4 + 8)) <= 0 )
{
return v2;
}
else
{
while ( 1 )
{
v6 = FUNC(*(_QWORD *)(v4 + 8), v5);
v7 = FUNC(v6);
if ( !v7 )
break;
if ( v2 )
FUNC(v2, v7);
else
v2 = (_QWORD *)v7;
if ( ++v5 >= (int)FUNC(*(unsigned int **)(v4 + 8)) )
return v2;
}
FUNC((__int64)v2);
return 0i64;
}
}
else
{
return 0i64;
}
}
else
{
FUNC(46, 133, 108, (__int64)"crypto\\cms\\cms_sd.c", 26);
return 0i64;
}
}
| openssl |
__int64 ERR_load_X509_strings_0()
{
if ( !ERR_func_error_string_0(0xB064000u) )
{
ERR_load_strings_const_0((const ERR_string_data_st *)&unk_14024D230);
ERR_load_strings_const_0((const ERR_string_data_st *)&unk_14024D610);
}
return 1i64;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2, __int64 a3)
{
__int64 v5; // rax
__int64 v6; // rax
__int64 v7; // rsi
__int64 v8; // rbx
const char *v9; // rax
int rfd_1; // eax
__int16 optval; // [rsp+58h] [rbp+20h] BYREF
__int16 v13; // [rsp+5Ah] [rbp+22h]
v5 = FUNC();
v6 = FUNC(v5);
v7 = v6;
if ( !v6 )
return 0i64;
FUNC(v6, 100i64, 0i64);
FUNC(v7, 155i64, 16i64);
if ( a1 )
{
v8 = a1;
FUNC(a1);
}
else
{
v8 = FUNC(a3);
}
SSL_set_bio_0(v8, v7, v7);
if ( (int)SSL_connect_0(v8) <= 0 )
{
BIO_printf(qword_1402808E8, "ERROR\n");
if ( dword_140278AD8 )
{
v9 = (const char *)X509_verify_cert_error_string_0((unsigned int)dword_140278AD8);
BIO_printf(qword_1402808E8, "verify error:%s\n", v9);
}
else
{
X509_ALGOR_dup_0(qword_1402808E8);
}
if ( !a1 )
FUNC(v8);
return 0i64;
}
optval = 1;
v13 = 0;
rfd_1 = SSL_get_rfd_1(v8);
if ( rfd_1 >= 0 )
setsockopt(rfd_1, 0xFFFF, 128, (const char *)&optval, 4);
return v8;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, unsigned __int64 a2)
{
unsigned __int64 v2; // rdi
unsigned int v4; // edi
__int64 result; // rax
int v6; // edx
__int64 v7; // rcx
__int64 v8; // r8
int v9; // eax
v2 = a2;
if ( !a2 )
return 1i64;
if ( !FUNC(a1) )
{
if ( *(_DWORD *)(a1 + 16) )
{
*(_DWORD *)(a1 + 16) = 0;
result = FUNC(a1, v2);
*(_DWORD *)(a1 + 16) = 1;
return result;
}
if ( *(_DWORD *)(a1 + 8) == 1 && **(_QWORD **)a1 < v2 )
{
**(_QWORD **)a1 = v2 - **(_QWORD **)a1;
*(_DWORD *)(a1 + 16) = 1;
return 1i64;
}
v6 = 0;
v7 = 0i64;
if ( **(_QWORD **)a1 < v2 )
{
v8 = 0i64;
do
{
++v7;
++v6;
*(_QWORD *)(*(_QWORD *)a1 + v8) -= v2;
v8 = 8 * v7;
v2 = 1i64;
}
while ( !*(_QWORD *)(8 * v7 + *(_QWORD *)a1) );
}
*(_QWORD *)(*(_QWORD *)a1 + 8i64 * v6) -= v2;
if ( !*(_QWORD *)(*(_QWORD *)a1 + 8i64 * v6) )
{
v9 = *(_DWORD *)(a1 + 8) - 1;
if ( v6 == v9 )
*(_DWORD *)(a1 + 8) = v9;
}
return 1i64;
}
v4 = FUNC(a1, v2);
if ( v4 )
FUNC(a1, 1);
return v4;
}
| openssl |
__int64 _onexitinit()
{
_QWORD *v0; // rbx
v0 = (_QWORD *)calloc_crt(32i64, 8i64);
qword_140286DC0 = EncodePointer(v0);
qword_140286DB8 = qword_140286DC0;
if ( !v0 )
return 24i64;
*v0 = 0i64;
return 0i64;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, unsigned int *a2, _QWORD *a3, __int16 a4)
{
unsigned int *v7; // r12
x509_store_ctx_st *v8; // r13
x509_st *v9; // r14
evp_pkey_st *pubkey_1; // rdi
unsigned int v11; // eax
int v12; // ebx
__int64 v13; // rax
unsigned int *v14; // rax
unsigned int *v15; // rbx
unsigned int ExecutionResourceTls; // ebx
__int64 v17; // rax
int v18; // eax
__int64 v19; // rax
unsigned int *v21; // [rsp+70h] [rbp+8h]
v21 = 0i64;
v7 = 0i64;
v8 = 0i64;
v9 = (x509_st *)FUNC(a2, a1 + 8);
if ( v9 )
{
LODWORD(pubkey_1) = 2;
}
else
{
if ( (a4 & 2) != 0 || (v9 = (x509_st *)FUNC(*(unsigned int **)(a1 + 72), a1 + 8)) == 0i64 )
{
LODWORD(pubkey_1) = 0;
FUNC(39, 105, 118, (__int64)"crypto\\ocsp\\ocsp_vfy.c", 41);
goto LABEL_39;
}
LODWORD(pubkey_1) = 1;
}
v8 = (x509_store_ctx_st *)FUNC();
if ( !v8 )
{
FUNC(39, 105, 65, (__int64)"crypto\\ocsp\\ocsp_vfy.c", 46);
LODWORD(pubkey_1) = -1;
goto LABEL_39;
}
if ( (_DWORD)pubkey_1 == 2 && (a4 & 0x200) != 0 )
a4 |= 0x10u;
if ( (a4 & 4) == 0 )
{
pubkey_1 = X509_get_pubkey_1(v9);
if ( !pubkey_1 )
{
FUNC(39, 105, 130, (__int64)"crypto\\ocsp\\ocsp_vfy.c", 55);
goto LABEL_39;
}
v11 = (unsigned int)FUNC();
LODWORD(pubkey_1) = FUNC(v11, (int)a1 + 48, *(_QWORD *)(a1 + 64), a1, (__int64)pubkey_1);
if ( (int)pubkey_1 <= 0 )
{
FUNC(39, 105, 117, (__int64)"crypto\\ocsp\\ocsp_vfy.c", 60);
goto LABEL_39;
}
}
if ( (a4 & 0x10) != 0 )
goto LABEL_39;
if ( (a4 & 8) != 0 )
goto LABEL_27;
v7 = *(unsigned int **)(a1 + 72);
if ( !v7 )
{
if ( a2 )
v7 = a2;
goto LABEL_27;
}
if ( !a2 || (v12 = 0, v7 = (unsigned int *)FUNC(*(int **)(a1 + 72)), (int)FUNC(a2) <= 0) )
{
LABEL_27:
if ( (unsigned int)FUNC((__int64)v8, a3, (__int64)v9, (__int64)v7) )
{
FUNC((__int64)v8, 8u);
LODWORD(pubkey_1) = FUNC((__int64)v8);
v14 = (unsigned int *)X509_STORE_CTX_get1_chain_0(v8);
v15 = v14;
v21 = v14;
if ( (int)pubkey_1 > 0 )
{
if ( (a4 & 0x100) != 0 )
{
LODWORD(pubkey_1) = 1;
}
else
{
LODWORD(pubkey_1) = FUNC(a1, v14);
if ( !(_DWORD)pubkey_1 && (a4 & 0x20) == 0 )
{
v18 = FUNC(v15);
v19 = FUNC((__int64)v15, v18 - 1);
if ( (unsigned int)FUNC(v19, 180i64, 0i64) == 1 )
LODWORD(pubkey_1) = 1;
else
FUNC(39, 105, 112, (__int64)"crypto\\ocsp\\ocsp_vfy.c", 121);
}
}
}
else
{
ExecutionResourceTls = Concurrency::details::ResourceManager::GetExecutionResourceTls(v8);
FUNC(39, 105, 101, (__int64)"crypto\\ocsp\\ocsp_vfy.c", 93);
v17 = X509_verify_cert_error_string_0(ExecutionResourceTls);
ERR_add_error_data(2, "Verify error:", v17);
}
}
else
{
FUNC(39, 105, 11, (__int64)"crypto\\ocsp\\ocsp_vfy.c", 83);
LODWORD(pubkey_1) = -1;
}
goto LABEL_39;
}
while ( 1 )
{
v13 = FUNC((__int64)a2, v12);
if ( !(unsigned int)OPENSSL_sk_push_0(v7, v13) )
break;
if ( ++v12 >= (int)FUNC(a2) )
goto LABEL_27;
}
FUNC(39, 105, 65, (__int64)"crypto\\ocsp\\ocsp_vfy.c", 72);
LODWORD(pubkey_1) = -1;
LABEL_39:
FUNC(v8);
FUNC(v21, (void (__fastcall *)(_QWORD))FUNC);
if ( *(_QWORD *)(a1 + 72) && a2 )
FUNC((void **)v7);
return (unsigned int)pubkey_1;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2)
{
return (*(__int64 (__fastcall **)(__int64))(*(_QWORD *)(a1 + 8) + 144i64))(a2);
}
| openssl |
__int64 __fastcall FUNC(__int64 a1)
{
unsigned int **local_0; // rbx
local_0 = (unsigned int **)CRYPTO_THREAD_get_local_0(&dword_140285194);
CRYPTO_free(*(void **)(a1 + 24), "crypto\\async\\async.c", 139i64);
*(_QWORD *)(a1 + 24) = 0i64;
return OPENSSL_sk_push_0(*local_0, a1);
}
| openssl |
__int64 __fastcall FUNC(
_QWORD *a1,
__int64 a2,
__int64 a3,
void (__fastcall *a4)(_QWORD *, _QWORD *, __int64),
__int64 a5,
__int64 a6)
{
void *v10; // rax
char v12; // bl
__int64 v13; // rdi
char v14; // bl
_BYTE *v15; // rcx
_BYTE *v16; // rdi
char v17; // bl
__int64 v18; // rax
__int64 v19; // rdi
char v20; // bl
__int64 v21; // rax
__int64 v22; // rdi
char v23; // bl
__int64 v24; // rax
__int64 v25; // rdi
char v26; // bl
memset(a1, 0, 0xB0ui64);
a1[5] = 0i64;
a1[6] = 5i64;
v10 = CRYPTO_malloc(0x50ui64, "crypto\\modes\\ocb128.c", 158i64);
a1[11] = v10;
if ( v10 )
{
a1[1] = a5;
*a1 = a4;
a1[2] = a2;
a1[3] = a3;
a1[4] = a6;
a4(a1 + 7, a1 + 7, a2);
v12 = -(*((_BYTE *)a1 + 56) >> 7) & 0x87;
FUNC((__int64)(a1 + 7), 1, (__int64)(a1 + 9));
*((_BYTE *)a1 + 87) ^= v12;
v13 = a1[11];
v14 = -(*((_BYTE *)a1 + 72) >> 7) & 0x87;
FUNC((__int64)(a1 + 9), 1, v13);
*(_BYTE *)(v13 + 15) ^= v14;
v15 = (_BYTE *)a1[11];
v16 = v15 + 16;
v17 = -(*v15 >> 7) & 0x87;
FUNC((__int64)v15, 1, (__int64)(v15 + 16));
v16[15] ^= v17;
v18 = a1[11];
v19 = v18 + 32;
v20 = -(*(_BYTE *)(v18 + 16) >> 7) & 0x87;
FUNC(v18 + 16, 1, v18 + 32);
*(_BYTE *)(v19 + 15) ^= v20;
v21 = a1[11];
v22 = v21 + 48;
v23 = -(*(_BYTE *)(v21 + 32) >> 7) & 0x87;
FUNC(v21 + 32, 1, v21 + 48);
*(_BYTE *)(v22 + 15) ^= v23;
v24 = a1[11];
v25 = v24 + 64;
v26 = -(*(_BYTE *)(v24 + 48) >> 7) & 0x87;
FUNC(v24 + 48, 1, v24 + 64);
*(_BYTE *)(v25 + 15) ^= v26;
a1[5] = 4i64;
return 1i64;
}
else
{
FUNC(15, 122, 65, (__int64)"crypto\\modes\\ocb128.c", 159);
return 0i64;
}
}
| openssl |
__int64 __fastcall FUNC(int **a1, __int64 a2)
{
__int64 result; // rax
if ( *a1 )
return (int)FUNC(*a1, a2) >= 0 || (unsigned int)OPENSSL_sk_push_0((unsigned int *)*a1, a2) != 0;
result = FUNC();
if ( (*a1 = (int *)result) != 0i64 )
return (int)FUNC(*a1, a2) >= 0 || (unsigned int)OPENSSL_sk_push_0((unsigned int *)*a1, a2) != 0;
return result;
}
| openssl |
__int64 __fastcall FUNC(_DWORD **a1, char *a2, int a3, int a4, int a5, int a6, int a7)
{
__int64 (__fastcall *v7)(__int64, __int64); // r14
int v8; // r10d
int v9; // r12d
int v12; // eax
int v14; // edi
unsigned int v15; // ebx
int v16; // ebx
char *v17; // rsi
int v18; // eax
unsigned int v19; // ebx
int v20; // ebx
unsigned int v21; // esi
_DWORD *v22; // rbp
char v23; // r13
int v24; // ebx
int v25; // ebx
int v26; // ebx
int v27; // r8d
int v28; // [rsp+30h] [rbp-88h] BYREF
int v29; // [rsp+34h] [rbp-84h]
_BYTE *v30; // [rsp+38h] [rbp-80h] BYREF
int v31; // [rsp+40h] [rbp-78h] BYREF
_QWORD *v32; // [rsp+48h] [rbp-70h]
char v33[32]; // [rsp+50h] [rbp-68h] BYREF
v7 = 0i64;
v8 = a4;
v29 = a4;
v9 = a3;
v28 = 0;
v32 = a1;
if ( a3 == -1 )
v9 = strlen(a2);
v12 = a5;
if ( !a5 )
v12 = 10246;
a5 = v12;
switch ( a4 )
{
case 4096:
v14 = 0;
v16 = v9;
v17 = a2;
if ( v9 )
{
while ( 1 )
{
v18 = UTF8_getc(v17, v16, &v31);
if ( v18 < 0 )
break;
v16 -= v18;
v17 += v18;
if ( FUNC )
++v14;
if ( !v16 )
{
v8 = v29;
goto LABEL_13;
}
}
FUNC(13, 122, 134, (__int64)"crypto\\asn1\\a_mbstr.c", 85);
return 0xFFFFFFFFi64;
}
break;
case 4097:
v14 = v9;
break;
case 4098:
if ( (v9 & 1) != 0 )
{
FUNC(13, 122, 129, (__int64)"crypto\\asn1\\a_mbstr.c", 65);
return 0xFFFFFFFFi64;
}
v14 = v9 >> 1;
break;
case 4100:
if ( (v9 & 3) != 0 )
{
FUNC(13, 122, 133, (__int64)"crypto\\asn1\\a_mbstr.c", 74);
return 0xFFFFFFFFi64;
}
v14 = v9 >> 2;
break;
default:
FUNC(13, 122, 160, (__int64)"crypto\\asn1\\a_mbstr.c", 95);
return 0xFFFFFFFFi64;
}
LABEL_13:
v15 = a6;
if ( a6 > 0 && v14 < a6 )
{
FUNC(13, 122, 152, (__int64)"crypto\\asn1\\a_mbstr.c", 100);
FUNC(v33, 0x20ui64, "%ld", v15);
ERR_add_error_data(2, "minsize=", v33);
return 0xFFFFFFFFi64;
}
v19 = a7;
if ( a7 > 0 && v14 > a7 )
{
FUNC(13, 122, 151, (__int64)"crypto\\asn1\\a_mbstr.c", 107);
FUNC(v33, 0x20ui64, "%ld", v19);
ERR_add_error_data(2, "maxsize=", v33);
return 0xFFFFFFFFi64;
}
if ( (int)FUNC(a2, v9, v8, (__int64 (__fastcall *)(__int64, __int64))FUNC, (__int64)&a5) < 0 )
{
FUNC(13, 122, 124, (__int64)"crypto\\asn1\\a_mbstr.c", 115);
return 0xFFFFFFFFi64;
}
v20 = 4097;
if ( (a5 & 1) != 0 )
{
v21 = 18;
}
else if ( (a5 & 2) != 0 )
{
v21 = 19;
}
else if ( (a5 & 0x10) != 0 )
{
v21 = 22;
}
else if ( (a5 & 4) != 0 )
{
v21 = 20;
}
else if ( (a5 & 0x800) != 0 )
{
v21 = 30;
v20 = 4098;
}
else if ( (a5 & 0x100) != 0 )
{
v21 = 28;
v20 = 4100;
}
else
{
v21 = 12;
v20 = 4096;
}
if ( a1 )
{
v22 = *a1;
if ( v22 )
{
v23 = 0;
CRYPTO_free(*((void **)v22 + 1), "crypto\\asn1\\a_mbstr.c", 144i64);
*((_QWORD *)v22 + 1) = 0i64;
*v22 = 0;
v22[1] = v21;
}
else
{
v23 = 1;
v22 = FUNC(v21);
if ( !v22 )
{
FUNC(13, 122, 65, (__int64)"crypto\\asn1\\a_mbstr.c", 152);
return 0xFFFFFFFFi64;
}
*v32 = v22;
}
if ( v29 == v20 )
{
if ( !(unsigned int)FUNC((__int64)v22, a2, v9) )
{
FUNC(13, 122, 65, (__int64)"crypto\\asn1\\a_mbstr.c", 160);
return 0xFFFFFFFFi64;
}
}
else
{
v24 = v20 - 4096;
if ( v24 )
{
v25 = v24 - 1;
if ( v25 )
{
v26 = v25 - 1;
if ( v26 )
{
if ( v26 == 2 )
{
v7 = (__int64 (__fastcall *)(__int64, __int64))FUNC;
v28 = 4 * v14;
}
}
else
{
v7 = (__int64 (__fastcall *)(__int64, __int64))FUNC;
v28 = 2 * v14;
}
}
else
{
v28 = v14;
v7 = (__int64 (__fastcall *)(__int64, __int64))FUNC;
}
}
else
{
v28 = 0;
FUNC(a2, v9, v29, (__int64 (__fastcall *)(__int64, __int64))out_utf8, (__int64)&v28);
v7 = (__int64 (__fastcall *)(__int64, __int64))cpy_utf8;
}
v30 = CRYPTO_malloc(v28 + 1, "crypto\\asn1\\a_mbstr.c", 189i64);
if ( !v30 )
{
if ( v23 )
FUNC((__int64)v22);
FUNC(13, 122, 65, (__int64)"crypto\\asn1\\a_mbstr.c", 192);
return 0xFFFFFFFFi64;
}
v27 = v29;
*v22 = v28;
*((_QWORD *)v22 + 1) = v30;
v30[v28] = 0;
FUNC(a2, v9, v27, v7, (__int64)&v30);
}
}
return v21;
}
| openssl |
__int64 __fastcall FUNC(__int64 a1)
{
unsigned int *v2; // r13
__int64 v3; // r12
int v4; // ebp
__int64 v5; // rdi
__int64 v6; // rax
__int64 v7; // rbx
_QWORD *v9; // rax
int *v10; // rax
unsigned int *v11; // rdi
int v12; // eax
int v13; // ecx
__int64 v14; // rbx
__int64 v15; // rax
int v16; // eax
int v17; // [rsp+58h] [rbp+10h] BYREF
v2 = (unsigned int *)FUNC(a1);
v3 = 0i64;
v4 = 0;
if ( (int)FUNC(v2) <= 0 )
return 1i64;
while ( 1 )
{
v5 = FUNC((__int64)v2, v4);
v6 = FUNC(v5, 771i64, &v17, 0i64);
v7 = v6;
if ( v6 )
break;
if ( v17 != -1 )
goto LABEL_4;
LABEL_9:
*(_QWORD *)(v5 + 40) = v3;
v10 = (int *)FUNC(v5, 141i64, &v17, 0i64);
if ( v10 )
{
*(_DWORD *)(v5 + 48) = FUNC(v10);
FUNC();
}
else
{
if ( v17 != -1 )
{
LABEL_4:
*(_DWORD *)(a1 + 124) |= 0x80u;
return 1i64;
}
*(_DWORD *)(v5 + 48) = -1;
}
v11 = *(unsigned int **)(v5 + 32);
v17 = 0;
v12 = FUNC(v11);
v13 = v17;
if ( v17 < v12 )
{
while ( 1 )
{
v14 = FUNC((__int64)v11, v13);
if ( (unsigned int)FUNC(v14) )
{
v15 = FUNC(v14);
if ( (unsigned int)FUNC(v15) != 771 )
break;
}
++v17;
v16 = FUNC(v11);
v13 = v17;
if ( v17 >= v16 )
goto LABEL_19;
}
*(_DWORD *)(a1 + 124) |= 0x200u;
}
LABEL_19:
if ( ++v4 >= (int)FUNC(v2) )
return 1i64;
}
v3 = v6;
if ( *(_QWORD *)(a1 + 168) || (v9 = FUNC(), (*(_QWORD *)(a1 + 168) = v9) != 0i64) )
{
if ( (unsigned int)OPENSSL_sk_push_0(*(unsigned int **)(a1 + 168), v7) )
goto LABEL_9;
}
return 0i64;
}
| openssl |
void __fastcall ec_GFp_simple_point_finish_0(ec_point_st *point)
{
FUNC(*((_QWORD *)point + 2));
FUNC(*((_QWORD *)point + 3));
FUNC(*((_QWORD *)point + 4));
}
| openssl |
__int64 __fastcall FUNC(__int64 *a1, __int64 a2, unsigned int *a3, _QWORD *a4, int a5)
{
__int64 result; // rax
result = FUNC(a1, a3, a4, 0i64, 0i64, a5 & 0xFFFFFFBE);
if ( (int)result > 0 )
return FUNC((__int64)a1, a2);
return result;
}
| openssl |
int __cdecl mbsnbcmp(const unsigned __int8 *Str1, const unsigned __int8 *Str2, size_t MaxCount)
{
return mbsnbcmp_l(Str1, Str2, MaxCount, 0i64);
}
| openssl |
__int64 __fastcall i2d_CMS_ContentInfo_2(__int64 a1, __int64 a2)
{
void *v4; // rax
v4 = FUNC();
return FUNC(a1, a2, v4);
}
| openssl |
int __cdecl isspace(int C)
{
__int64 v1; // rbx
int v3; // r11d
__crt_locale_pointers Locale; // [rsp+20h] [rbp-28h] BYREF
__int64 v5; // [rsp+30h] [rbp-18h]
char v6; // [rsp+38h] [rbp-10h]
v1 = C;
if ( !dword_1402856E8 )
return off_14027FA90[C] & 8;
_LocaleUpdate::_LocaleUpdate((_LocaleUpdate *)&Locale, 0i64);
if ( *((int *)Locale.locinfo + 67) <= 1 )
v3 = *(_WORD *)(*((_QWORD *)Locale.locinfo + 40) + 2 * v1) & 8;
else
v3 = isctype_l(v1, 8, &Locale);
if ( v6 )
*(_DWORD *)(v5 + 200) &= ~2u;
return v3;
}
| openssl |
__int64 __fastcall FUNC(_BYTE *a1, int a2, __int64 a3)
{
_BYTE *v5; // rax
void *v6; // rsi
int v7; // edi
__int64 *v8; // rbx
void **v9; // [rsp+40h] [rbp+8h] BYREF
v9 = 0i64;
if ( !a1 )
return 1i64;
v5 = FUNC(a1, a2, "crypto\\ct\\ct_log.c", 0xA7u);
v6 = v5;
if ( v5 )
{
v7 = FUNC((__int64)&v9, *(_QWORD *)(a3 + 8), (__int64)v5);
CRYPTO_free(v6, "crypto\\ct\\ct_log.c", 172i64);
if ( v7 < 0 )
return (unsigned int)v7;
if ( !v7 )
{
++*(_QWORD *)(a3 + 16);
return 1i64;
}
if ( (unsigned int)OPENSSL_sk_push_0(**(unsigned int ***)a3, (__int64)v9) )
return 1i64;
}
v8 = (__int64 *)v9;
if ( v9 )
{
CRYPTO_free(*v9, "crypto\\ct\\ct_log.c", 266i64);
FUNC(v8[5]);
CRYPTO_free(v8, "crypto\\ct\\ct_log.c", 268i64);
}
FUNC(50, 130, 65, (__int64)"crypto\\ct\\ct_log.c", 191);
return 0xFFFFFFFFi64;
}
| openssl |
void __fastcall FUNC(bio_st *a1, __int64 a2, const X509_name_st *a3, unsigned int a4)
{
char v4; // si
int v5; // ebp
void *v9; // rbx
v4 = 0;
v5 = 0;
if ( a2 )
FUNC(a1, a2);
if ( (a4 & 0xF0000) == 0x40000 )
{
v4 = 1;
v5 = 4;
}
if ( a4 )
{
if ( v4 )
FUNC(a1, "\n");
X509_NAME_print_ex_0(a1, a3, v5, a4);
FUNC(a1, "\n");
}
else
{
v9 = (void *)FUNC(a3, 0i64, 0i64);
FUNC(a1, v9);
FUNC(a1, "\n");
CRYPTO_free(v9, "apps\\apps.c", 1184);
}
}
| openssl |
__int64 __fastcall FUNC(__int64 a1)
{
__int64 result; // rax
result = 0i64;
*(_QWORD *)(a1 + 3744) = 0i64;
return result;
}
| openssl |
void __fastcall FUNC(_QWORD *a1)
{
__int64 v2; // rdx
bool v3; // zf
void *v4; // rcx
if ( a1 )
{
if ( !*((_DWORD *)a1 + 4) )
{
v2 = a1[5];
v3 = *((_DWORD *)a1 + 5) == 0;
v4 = (void *)*a1;
if ( v3 )
FUNC(v4, v2, (__int64)"crypto\\rand\\rand_lib.c", 0x207u);
else
FUNC(v4, v2, "crypto\\rand\\rand_lib.c", 517i64);
}
CRYPTO_free(a1, "crypto\\rand\\rand_lib.c", 522i64);
}
}
| openssl |
__int64 __fastcall FUNC(__int64 a1, __int64 a2)
{
char *v4; // rdi
int v5; // eax
int v6; // ebx
int v7; // r12d
char *v8; // rax
int v10; // ebx
char v11[80]; // [rsp+30h] [rbp-78h] BYREF
v4 = v11;
if ( !a2 || !*(_QWORD *)(a2 + 24) )
return FUNC(a1, (__int64)"NULL", 4);
v5 = FUNC(v11, 80, a2, 0);
v6 = v5;
if ( v5 > 79 )
{
v7 = v5 + 1;
v8 = (char *)CRYPTO_malloc(v5 + 1, "crypto\\asn1\\a_object.c", 194i64);
v4 = v8;
if ( !v8 )
{
FUNC(13, 126, 65, (unsigned int)"crypto\\asn1\\a_object.c", 195);
return 0xFFFFFFFFi64;
}
FUNC(v8, v7, a2, 0);
}
if ( v6 > 0 )
{
FUNC(a1, (__int64)v4, v6);
if ( v4 != v11 )
CRYPTO_free(v4, "crypto\\asn1\\a_object.c", 207i64);
return (unsigned int)v6;
}
else
{
v10 = FUNC(a1, (__int64)"<INVALID>", 9);
return v10 + (unsigned int)BIO_dump(a1, *(_QWORD *)(a2 + 24), *(unsigned int *)(a2 + 20));
}
}
| openssl |
void __fastcall FUNC(__int64 a1)
{
__int64 v2; // rcx
if ( a1 )
{
v2 = *(_QWORD *)(a1 + 16);
if ( v2 )
{
FUNC(v2, 0);
FUNC(*(_QWORD *)(a1 + 16), (void (__fastcall *)(_QWORD, __int64))FUNC, *(_QWORD *)(a1 + 16));
FUNC(*(_QWORD *)(a1 + 16), FUNC);
FUNC(*(_QWORD *)(a1 + 16));
}
}
}
| openssl |
__int64 __fastcall FUNC(__int64 a1)
{
size_t v1; // rax
__int64 result; // rax
result = (__int64)CRYPTO_malloc(v1, "crypto\\dsa\\dsa_pmeth.c", (unsigned int)(v1 + 2));
if ( result )
{
*(_DWORD *)result = 2048;
*(_DWORD *)(result + 4) = 224;
*(_QWORD *)(result + 8) = 0i64;
*(_QWORD *)(result + 24) = 0i64;
*(_QWORD *)(a1 + 40) = result;
*(_DWORD *)(a1 + 72) = 2;
*(_QWORD *)(a1 + 64) = result + 16;
return 1i64;
}
return result;
}
| openssl |
void __fastcall FUNC(__int64 a1, int a2)
{
*(_DWORD *)(a1 + 68) = a2;
}
| openssl |
__int64 __fastcall BN_mod_add_quick_0(__int64 *a1, __int64 a2, __int64 a3, __int64 a4)
{
__int64 result; // rax
unsigned int v6; // ebx
result = FUNC((__int64)a1, a2, a3, a4);
v6 = result;
if ( (_DWORD)result )
{
FUNC(a1);
return v6;
}
return result;
}
| openssl |
__int64 __fastcall FUNC(const void *a1, int a2, _QWORD *a3)
{
__int64 v5; // rbx
int v6; // r11d
unsigned __int64 v7; // rdx
unsigned __int64 v8; // rcx
_DWORD *v9; // rax
char v10[24]; // [rsp+20h] [rbp-28h] BYREF
if ( !a1 )
return 0i64;
if ( *a3 == 30i64 )
return 0i64;
if ( a2 > 19 )
return 0i64;
v5 = a2;
memmove(v10, a1, a2);
v10[v5] = 0;
v6 = FUNC(v10);
if ( !v6 )
{
v6 = FUNC(v10);
if ( !v6 )
{
v6 = FUNC(v10);
if ( !v6 )
return 0i64;
}
}
v7 = *a3;
v8 = 0i64;
if ( *a3 )
{
v9 = a3 + 1;
while ( *v9 != v6 )
{
++v8;
++v9;
if ( v8 >= v7 )
goto LABEL_12;
}
return 0i64;
}
LABEL_12:
*((_DWORD *)a3 + v7 + 2) = v6;
++*a3;
return 1i64;
}
| openssl |
int __cdecl fileno(FILE *Stream)
{
if ( Stream )
return Stream->_file;
*errno() = 22;
invalid_parameter(0i64, 0i64, 0i64, 0, 0i64);
return -1;
}
| openssl |