#include <defs.h>
//-------------------------------------------------------------------------
// Function declarations
__int64 (**init_proc())(void);
void sub_1890();
// int printf(const char *format, ...);
// int inet_pton(int af, const char *cp, void *buf);
// char *strncat(char *dest, const char *src, size_t n);
// int puts(const char *s);
// int uname(struct utsname *name);
// __int64 __fastcall RSA_public_decrypt(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD); weak
// void __noreturn exit(int status);
// void *malloc(size_t size);
// FILE *fopen(const char *filename, const char *modes);
// int regexec(const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
char *__fastcall indexLicValues(char *);
// void *dlsym(void *handle, const char *name);
// void free(void *ptr);
// size_t strlen(const char *s);
// __int64 __fastcall PEM_read_bio_RSAPrivateKey(_QWORD, _QWORD, _QWORD, _QWORD); weak
// DIR *opendir(const char *name);
// char *dlerror(void);
__int64 __fastcall real_time2(__int64);
// const unsigned __int16 **__ctype_b_loc(void);
// int __fastcall __cxa_finalize(void *);
// int sprintf(char *s, const char *format, ...);
__int64 __fastcall real_fxstat64(unsigned int, unsigned int, __int64);
__int64 __fastcall real_xstat64(unsigned int, __int64, __int64);
__int64 __fastcall real_memmove(__int64, __int64, __int64);
// char *strstr(const char *haystack, const char *needle);
// char *strcat(char *dest, const char *src);
__int64 __fastcall real_write(unsigned int, __int64, __int64);
// int atoi(const char *nptr);
void *validateLicense();
// int regcomp(regex_t *preg, const char *pattern, int cflags);
// void *memcpy(void *dest, const void *src, size_t n);
_BOOL8 __fastcall isValidMacAddress(_BYTE *);
// __int64 __fastcall PEM_read_bio_RSA_PUBKEY(_QWORD, _QWORD, _QWORD, _QWORD); weak
// size_t fread(void *ptr, size_t size, size_t n, FILE *stream);
// char *getenv(const char *name);
// char *strdup(const char *s);
const char *__fastcall str_replace(const char *, const char *, const char *);
// int strcmp(const char *s1, const char *s2);
// char *strcpy(char *dest, const char *src);
__int64 __fastcall createRSA(__int64, int);
// char *strtok(char *s, const char *delim);
int __fastcall hex2char(const char *, char *);
_BOOL8 __fastcall prefix(char *, char *);
// void regfree(regex_t *preg);
// char *strncpy(char *dest, const char *src, size_t n);
__int64 __fastcall real_time(__int64);
// __int64 __fastcall BIO_new_mem_buf(_QWORD, _QWORD); weak
// int unsetenv(const char *name);
// int fscanf(FILE *stream, const char *format, ...);
void *checkLicenseInfo();
// __int64 strtoll(const char *nptr, char **endptr, int base);
// void *realloc(void *ptr, size_t size);
_DWORD *init();
// int fprintf(FILE *stream, const char *format, ...);
__int64 __fastcall str_replace3(_QWORD, _QWORD, _QWORD, _QWORD); // weak
__int64 __fastcall public_decrypt(__int64, unsigned int, __int64, __int64);
__int64 (**call_gmon_start())(void);
char *deregister_tm_clones();
__int64 register_tm_clones(); // weak
char *_do_global_dtors_aux();
__int64 __fastcall regex_replace(char **a1, char *a2, char *a3);
__int64 __fastcall real_time2(__int64 a1);
int __fastcall hex2char(const char *a1, char *a2);
_BYTE *__fastcall str_replace3(_BYTE *a1, __int64 a2, const char *a3, const char *a4);
__int64 __fastcall locate_forward(_QWORD *a1, _BYTE *a2, __int64 a3, unsigned __int64 a4);
__int64 __fastcall locate_backward(_QWORD *a1, _BYTE *a2, unsigned __int64 a3, __int64 a4);
__int64 __fastcall str_replace2(const char *a1, const char *a2, const char *a3);
const char *__fastcall str_replace(const char *a1, const char *a2, const char *a3);
_BYTE *__fastcall str_replace4(const char *a1, const char *a2, const char *a3);
_BOOL8 __fastcall prefix(char *a1, char *a2);
char *__fastcall indexLicValues(char *a1);
_BOOL8 __fastcall isValidMacAddress(_BYTE *a1);
unsigned int *validateLicense();
__int64 __fastcall createRSA(__int64 a1, int a2);
__int64 __fastcall public_decrypt(__int64 a1, unsigned int a2, __int64 a3, __int64 a4);
void *checkLicenseInfo();
_DWORD *init();
__int64 __fastcall real_write2(unsigned int a1, __int64 a2, __int64 a3);
__int64 __fastcall real_time(__int64 a1);
__int64 __fastcall time(__int64 a1);
int __fastcall ioctl(unsigned int a1, unsigned int a2, __int64 a3);
__int64 __fastcall real_xstat64(unsigned int a1, __int64 a2, __int64 a3);
__int64 __fastcall _xstat64(unsigned int a1, const char *a2, __int64 a3);
__int64 __fastcall real_fxstat64(unsigned int a1, unsigned int a2, __int64 a3);
__int64 __fastcall _fxstat64(unsigned int a1, unsigned int a2, __int64 a3);
__int64 __fastcall real_memmove(__int64 a1, __int64 a2, __int64 a3);
__int64 __fastcall memmove(__int64 a1, const char *a2, size_t a3);
__int64 __fastcall real_write(unsigned int a1, __int64 a2, __int64 a3);
char *__fastcall StringPadRight(char *a1, int a2, const char *a3);
__int64 __fastcall write(unsigned int a1, const char *a2, __int64 a3);
__int64 __fastcall syscall(__int64 a1, char *a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6, __int64 a7);
__int64 ptrace(); // weak
void term_proc();
// int __fastcall _cxa_finalize(void *);
// __int64 _gmon_start__(void); weak
//-------------------------------------------------------------------------
// Data declarations
_UNKNOWN unk_4C40; // weak
void *_dso_handle = &_dso_handle; // weak
_DWORD g_write_override_enabled = 1; // weak
_UNKNOWN padding; // weak
char edata; // weak
int g_NumberofIOctls; // weak
int g_StartDate; // weak
_DWORD g_StopDate; // weak
_UNKNOWN g_limitTimeFaking; // weak
int g_time_calls; // weak
int total_write_calls; // weak
int g_n_uname_syscall; // weak
_UNKNOWN g_old_method; // weak
_UNKNOWN g_mem_calls; // weak
__int64 (__fastcall *orig_ioctl_16094)(_QWORD, _QWORD, _QWORD); // weak
__int64 handle_16090; // weak
__int64 (__fastcall *orig_syscall_16362)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD, _QWORD, _QWORD); // weak
unsigned int g_License[222]; // weak
// extern _UNKNOWN _progname; weak
// extern struct _IO_FILE *stderr;
//----- (0000000000001880) ----------------------------------------------------
__int64 (**init_proc())(void)
{
return call_gmon_start();
}
//----- (0000000000001890) ----------------------------------------------------
void sub_1890()
{
JUMPOUT(0LL);
}
// 1896: control flows out of bounds to 0
//----- (0000000000001C20) ----------------------------------------------------
__int64 (**call_gmon_start())(void)
{
__int64 (**result)(void); // rax
result = &_gmon_start__;
if ( &_gmon_start__ )
return (__int64 (**)(void))_gmon_start__();
return result;
}
// 206700: using guessed type __int64 _gmon_start__(void);
//----- (0000000000001C40) ----------------------------------------------------
char *deregister_tm_clones()
{
return &edata;
}
// 2061E0: using guessed type char edata;
//----- (0000000000001C70) ----------------------------------------------------
__int64 register_tm_clones()
{
return 0LL;
}
// 1C70: using guessed type __int64 register_tm_clones();
//----- (0000000000001CB0) ----------------------------------------------------
char *_do_global_dtors_aux()
{
char *result; // rax
if ( !edata )
{
if ( &_cxa_finalize )
__cxa_finalize(&_dso_handle);
result = deregister_tm_clones();
edata = 1;
}
return result;
}
// 205D88: using guessed type void *_dso_handle;
// 2061E0: using guessed type char edata;
//----- (0000000000001CF5) ----------------------------------------------------
__int64 __fastcall regex_replace(char **a1, char *a2, char *a3)
{
void *v3; // rsp
size_t v5; // rbx
size_t v6; // rax
char *v7; // rax
size_t v8; // rax
char *v9; // rax
size_t v10; // rax
char *v11; // rax
__int64 v12[3]; // [rsp+0h] [rbp-E0h] BYREF
char *s; // [rsp+18h] [rbp-C8h]
char *pattern; // [rsp+20h] [rbp-C0h]
char **v15; // [rsp+28h] [rbp-B8h]
regex_t preg; // [rsp+30h] [rbp-B0h] BYREF
unsigned int v17; // [rsp+70h] [rbp-70h]
int v18; // [rsp+74h] [rbp-6Ch]
char *dest; // [rsp+78h] [rbp-68h]
regmatch_t *__attribute__((__org_arrdim(0,0))) pmatch; // [rsp+80h] [rbp-60h]
size_t v21; // [rsp+88h] [rbp-58h]
size_t re_nsub; // [rsp+90h] [rbp-50h]
int i; // [rsp+9Ch] [rbp-44h]
char *src; // [rsp+A0h] [rbp-40h]
int v25; // [rsp+A8h] [rbp-38h]
unsigned int v26; // [rsp+ACh] [rbp-34h]
char *v27; // [rsp+B0h] [rbp-30h]
char *v28; // [rsp+B8h] [rbp-28h]
v15 = a1;
pattern = a2;
s = a3;
v26 = 0;
if ( regcomp(&preg, a2, 1) )
return 0xFFFFFFFFLL;
re_nsub = preg.re_nsub;
v21 = preg.re_nsub;
v12[0] = preg.re_nsub + 1;
v12[1] = 0LL;
v3 = alloca(16 * ((8 * (preg.re_nsub + 1) + 15) / 0x10));
pmatch = (regmatch_t *)v12;
v25 = 0;
v28 = s;
while ( 1 )
{
do
++v28;
while ( *v28 > 31 );
if ( !*v28 )
break;
++v25;
}
if ( re_nsub == v25 )
{
src = *v15;
while ( !regexec(&preg, src, re_nsub + 1, pmatch, 1) )
{
v5 = strlen(*v15);
v6 = strlen(s);
dest = (char *)malloc(v5 + v6);
if ( !dest )
exit(1);
*dest = 0;
strncat(dest, *v15, src - *v15);
v27 = s;
v28 = s;
strncat(dest, src, pmatch->rm_so);
for ( i = 0; re_nsub > i; ++i )
{
do
++v28;
while ( *v28 > 31 );
v18 = *v28;
strncat(dest, v27, v28 - v27);
strncat(dest, &src[pmatch[v18].rm_so], pmatch[v18].rm_eo - pmatch[v18].rm_so);
v7 = v28++;
v27 = v7;
}
strcat(dest, v28);
v17 = strlen(dest);
strcat(dest, &src[pmatch->rm_eo]);
free(*v15);
v8 = strlen(dest);
v9 = (char *)malloc(v8 + 1);
*v15 = v9;
strcpy(*v15, dest);
src = &(*v15)[v17];
free(dest);
++v26;
}
regfree(&preg);
v10 = strlen(*v15);
v11 = (char *)realloc(*v15, v10 + 1);
*v15 = v11;
return v26;
}
else
{
regfree(&preg);
return 4294967294LL;
}
}
//----- (00000000000020D2) ----------------------------------------------------
__int64 __fastcall real_time2(__int64 a1)
{
__int64 (__fastcall *v1)(__int64); // rax
v1 = (__int64 (__fastcall *)(__int64))dlsym((void *)0xFFFFFFFFFFFFFFFFLL, "time");
return v1(a1);
}
//----- (00000000000020FF) ----------------------------------------------------
int __fastcall hex2char(const char *a1, char *a2)
{
int v2; // eax
int v4; // eax
char v5; // cl
int v6; // eax
char v7[2512]; // [rsp+10h] [rbp-1D70h] BYREF
char dest[5008]; // [rsp+9E0h] [rbp-13A0h] BYREF
int v9; // [rsp+1D70h] [rbp-10h]
int v10; // [rsp+1D74h] [rbp-Ch]
int v11; // [rsp+1D78h] [rbp-8h]
int v12; // [rsp+1D7Ch] [rbp-4h]
strcpy(dest, a1);
v12 = 0;
v11 = 0;
while ( dest[v12] )
{
if ( dest[v12] <= 47 || dest[v12] > 57 )
v2 = dest[v12] - 87;
else
v2 = dest[v12] - 48;
v10 = v2;
if ( !dest[++v12] )
return puts("invalid format");
if ( dest[v12] <= 47 || dest[v12] > 57 )
v4 = dest[v12] - 87;
else
v4 = dest[v12] - 48;
v9 = v4;
v5 = 16 * v10 + v4;
v6 = v11++;
v7[v6] = v5;
++v12;
}
v7[v11] = 0;
return (unsigned int)strcpy(a2, v7);
}
// 20FF: using guessed type char dest[5008];
// 20FF: using guessed type char var_1D70[2512];
//----- (0000000000002265) ----------------------------------------------------
_BYTE *__fastcall str_replace3(_BYTE *a1, __int64 a2, const char *a3, const char *a4)
{
const char *v7; // [rsp+28h] [rbp-48h] BYREF
size_t v10; // [rsp+38h] [rbp-38h]
const char *v12; // [rsp+48h] [rbp-28h]
size_t n; // [rsp+50h] [rbp-20h]
size_t v14; // [rsp+58h] [rbp-18h]
void *dest; // [rsp+60h] [rbp-10h]
_BYTE *v16; // [rsp+68h] [rbp-8h]
v14 = strlen(a3);
n = strlen(a4);
v12 = &a3[v14 - 1];
if ( !v14 )
return a1;
if ( n > v14 )
{
v10 = n - v14;
v7 = a3;
v16 = a1;
dest = a1;
while ( *v16 )
{
if ( (unsigned __int8)locate_forward(&v7, v16, (__int64)a3, (unsigned __int64)v12) )
dest = (char *)dest + v10;
if ( dest >= &a1[a2] )
return 0LL;
++v16;
dest = (char *)dest + 1;
}
v7 = v12;
while ( dest >= a1 )
{
*(_BYTE *)dest = *v16;
if ( (unsigned __int8)locate_backward(&v7, v16, (unsigned __int64)a3, (__int64)v12) )
{
dest = (char *)dest - v10;
memcpy(dest, a4, n);
}
dest = (char *)dest - 1;
--v16;
}
return a1;
}
else
{
v7 = a3;
v16 = a1;
dest = a1;
while ( *v16 )
{
*(_BYTE *)dest = *v16;
if ( (unsigned __int8)locate_forward(&v7, v16, (__int64)a3, (unsigned __int64)v12) )
{
dest = (char *)dest - v14;
memcpy((char *)dest + 1, a4, n);
dest = (char *)dest + n;
}
++v16;
dest = (char *)dest + 1;
}
*(_BYTE *)dest = 0;
return a1;
}
}
// 2265: using guessed type const char *var_48;
//----- (000000000000245C) ----------------------------------------------------
__int64 __fastcall locate_forward(_QWORD *a1, _BYTE *a2, __int64 a3, unsigned __int64 a4)
{
if ( *(_BYTE *)*a1 == *a2 )
{
if ( a4 < ++*a1 )
{
*a1 = a3;
return 1LL;
}
}
else
{
*a1 = a3;
}
return 0LL;
}
//----- (00000000000024C8) ----------------------------------------------------
__int64 __fastcall locate_backward(_QWORD *a1, _BYTE *a2, unsigned __int64 a3, __int64 a4)
{
if ( *(_BYTE *)*a1 == *a2 )
{
if ( a3 > --*a1 )
{
*a1 = a4;
return 1LL;
}
}
else
{
*a1 = a4;
}
return 0LL;
}
//----- (0000000000002534) ----------------------------------------------------
__int64 __fastcall str_replace2(const char *a1, const char *a2, const char *a3)
{
int v3; // ebx
size_t v4; // rax
size_t v5; // rax
size_t v6; // rax
_BYTE v9[12]; // [rsp+2Ch] [rbp-34h]
int v10; // [rsp+3Ch] [rbp-24h]
int v11; // [rsp+3Ch] [rbp-24h]
char *src; // [rsp+40h] [rbp-20h]
char *i; // [rsp+48h] [rbp-18h]
char *j; // [rsp+48h] [rbp-18h]
v10 = 0;
*(_QWORD *)v9 = (unsigned int)strlen(a1);
for ( i = strstr(a3, a1); i; i = strstr(&i[*(int *)v9], a1) )
++v10;
v3 = v10 * (strlen(a2) - *(_DWORD *)v9);
v11 = v3 + strlen(a3);
*(_QWORD *)&v9[4] = malloc(v11);
src = (char *)a3;
for ( j = strstr(a3, a1); j; j = strstr(src, a1) )
{
v4 = strlen(*(const char **)&v9[4]);
strncpy((char *)(v4 + *(_QWORD *)&v9[4]), src, j - src);
v5 = strlen(*(const char **)&v9[4]);
strcpy((char *)(*(_QWORD *)&v9[4] + v5), a2);
src = &j[*(int *)v9];
}
v6 = strlen(*(const char **)&v9[4]);
strcpy((char *)(*(_QWORD *)&v9[4] + v6), src);
return *(_QWORD *)&v9[4];
}
//----- (00000000000026EC) ----------------------------------------------------
const char *__fastcall str_replace(const char *a1, const char *a2, const char *a3)
{
int v5; // [rsp+20h] [rbp-30h]
int v6; // [rsp+24h] [rbp-2Ch]
int n; // [rsp+28h] [rbp-28h]
int m; // [rsp+2Ch] [rbp-24h]
int k; // [rsp+30h] [rbp-20h]
int j; // [rsp+34h] [rbp-1Ch]
int i; // [rsp+38h] [rbp-18h]
int v12; // [rsp+3Ch] [rbp-14h]
v6 = strlen(a2);
v5 = strlen(a3);
for ( i = 0; i < strlen(a1); ++i )
{
if ( a1[i] == *a2 )
{
v12 = 1;
for ( j = 1; j < v6 && a1[i + j] == a2[j]; ++j )
++v12;
if ( v12 == v6 )
{
if ( v6 < v5 )
{
for ( k = strlen(a1); k > i; --k )
a1[k + v5 - v6] = a1[k];
}
if ( v6 > v5 )
{
for ( m = i + v6 - v5; m < strlen(a1); ++m )
a1[m - (v6 - v5)] = a1[m];
a1[strlen(a1) - (v6 - v5)] = 0;
}
for ( n = 0; n < v5; ++n )
a1[i + n] = a3[n];
if ( v6 != v5 )
i += v5 - 1;
}
}
}
return a1;
}
//----- (00000000000028E3) ----------------------------------------------------
_BYTE *__fastcall str_replace4(const char *a1, const char *a2, const char *a3)
{
int v4; // eax
int v5; // eax
int v6; // eax
_BYTE *v8; // [rsp+28h] [rbp-38h]
int v9; // [rsp+34h] [rbp-2Ch]
int v10; // [rsp+38h] [rbp-28h]
int v11; // [rsp+3Ch] [rbp-24h]
int v12; // [rsp+40h] [rbp-20h]
int v13; // [rsp+44h] [rbp-1Ch]
_BYTE *ptr; // [rsp+48h] [rbp-18h]
_BYTE *ptra; // [rsp+48h] [rbp-18h]
int i; // [rsp+54h] [rbp-Ch]
int j; // [rsp+54h] [rbp-Ch]
int v18; // [rsp+58h] [rbp-8h]
int k; // [rsp+5Ch] [rbp-4h]
int v20; // [rsp+5Ch] [rbp-4h]
v11 = strlen(a1);
v10 = strlen(a2);
v9 = strlen(a3);
if ( v11 )
{
v13 = 2 * (strlen(a3) + 1);
ptra = malloc(v13);
v12 = 0;
v8 = malloc(v11);
v20 = 0;
v18 = 0;
while ( v20 <= v9 )
{
if ( v13 > v18 + v10 )
{
if ( a3[v20] == a1[v12] )
{
v8[v12++] = a3[v20];
if ( v12 == v11 )
{
v12 = 0;
for ( i = 0; i < v10; ++i )
{
v4 = v18++;
ptra[v4] = a2[i];
}
}
}
else
{
for ( j = 0; j < v12; ++j )
{
v5 = v18++;
ptra[v5] = v8[j];
}
v12 = 0;
v6 = v18++;
ptra[v6] = a3[v20];
}
}
else
{
v13 *= 2;
ptra = realloc(ptra, v13);
}
++v20;
}
free(v8);
return ptra;
}
else
{
ptr = malloc(v9 + 1);
for ( k = 0; k <= v9; ++k )
ptr[k] = a3[k];
return ptr;
}
}
//----- (0000000000002B1B) ----------------------------------------------------
_BOOL8 __fastcall prefix(char *a1, char *a2)
{
char *v3; // rax
char *v4; // rax
char *v6; // [rsp+8h] [rbp-18h]
char v7; // [rsp+1Eh] [rbp-2h]
char v8; // [rsp+1Fh] [rbp-1h]
v6 = a1;
if ( !*a1 )
return 1LL;
while ( 1 )
{
v3 = v6++;
v7 = *v3;
if ( !*v3 )
break;
v4 = a2++;
v8 = *v4;
if ( !*v4 )
break;
if ( v7 != v8 )
return 0LL;
}
return v8 != 0;
}
// 2B7D: variable 'v8' is possibly undefined
//----- (0000000000002B8D) ----------------------------------------------------
char *__fastcall indexLicValues(char *a1)
{
char *v1; // rax
char *v2; // rax
char *v3; // rax
char *v4; // rax
char *v5; // rax
char *v6; // rax
char *v7; // rax
char *v8; // rax
char *v9; // rax
char *v10; // rax
char *v11; // rax
char *v12; // rax
char *v13; // rax
char *v14; // rax
char *v15; // rax
char *v16; // rax
char *v17; // rax
char *v18; // rax
char *v19; // rax
char *v20; // rax
char *v21; // rax
char *v22; // rax
char *result; // rax
char *v24; // rax
char *v25; // [rsp+18h] [rbp-B8h]
char *v26; // [rsp+20h] [rbp-B0h]
char *v27; // [rsp+28h] [rbp-A8h]
char *v28; // [rsp+30h] [rbp-A0h]
char *v29; // [rsp+38h] [rbp-98h]
char *v30; // [rsp+40h] [rbp-90h]
char *v31; // [rsp+48h] [rbp-88h]
char *v32; // [rsp+50h] [rbp-80h]
char *v33; // [rsp+58h] [rbp-78h]
char *v34; // [rsp+60h] [rbp-70h]
char *v35; // [rsp+68h] [rbp-68h]
char *v36; // [rsp+70h] [rbp-60h]
char *v37; // [rsp+78h] [rbp-58h]
char *v38; // [rsp+80h] [rbp-50h]
char *v39; // [rsp+88h] [rbp-48h]
char *v40; // [rsp+90h] [rbp-40h]
char *v41; // [rsp+98h] [rbp-38h]
char *v42; // [rsp+A0h] [rbp-30h]
char *v43; // [rsp+A8h] [rbp-28h]
char *v44; // [rsp+B0h] [rbp-20h]
char *v45; // [rsp+B8h] [rbp-18h]
char *src; // [rsp+C0h] [rbp-10h]
char *nptr; // [rsp+C8h] [rbp-8h]
if ( prefix("FO=", a1) )
{
v1 = strdup(a1);
nptr = (char *)str_replace(v1, "FO=", (const char *)&unk_4C40);
g_License[2] = atoi(nptr);
}
if ( prefix("FMA=", a1) )
{
v2 = strdup(a1);
src = (char *)str_replace(v2, "FMA=", (const char *)&unk_4C40);
strcpy((char *)&g_License[7], src);
}
if ( prefix("FIP=", a1) )
{
v3 = strdup(a1);
v45 = (char *)str_replace(v3, "FIP=", (const char *)&unk_4C40);
strcpy((char *)&g_License[3], v45);
}
if ( prefix("FR=", a1) )
{
v4 = strdup(a1);
v44 = (char *)str_replace(v4, "FR=", (const char *)&unk_4C40);
strcpy((char *)&g_License[39] + 2, v44);
}
if ( prefix("FV=", a1) )
{
v5 = strdup(a1);
v43 = (char *)str_replace(v5, "FV=", (const char *)&unk_4C40);
strcpy((char *)&g_License[58] + 1, v43);
}
if ( prefix("FMM=", a1) )
{
v6 = strdup(a1);
v42 = (char *)str_replace(v6, "FMM=", (const char *)&unk_4C40);
strcpy((char *)&g_License[77], v42);
}
if ( prefix("FD=", a1) )
{
v7 = strdup(a1);
v41 = (char *)str_replace(v7, "FD=", (const char *)&unk_4C40);
strcpy((char *)&g_License[95] + 3, v41);
}
if ( prefix("FIU=", a1) )
{
v8 = strdup(a1);
v40 = (char *)str_replace(v8, "FIU=", (const char *)&unk_4C40);
*(_QWORD *)&g_License[118] = strtoll(v40, 0LL, 10);
}
if ( prefix("FIV=", a1) )
{
v9 = strdup(a1);
v39 = (char *)str_replace(v9, "FIV=", (const char *)&unk_4C40);
*(_QWORD *)&g_License[120] = strtoll(v39, 0LL, 10);
}
if ( prefix("FIL=", a1) )
{
v10 = strdup(a1);
v38 = (char *)str_replace(v10, "FIL=", (const char *)&unk_4C40);
*(_QWORD *)&g_License[122] = strtoll(v38, 0LL, 10);
}
if ( prefix("FK=", a1) )
{
v11 = strdup(a1);
v37 = (char *)str_replace(v11, "FK=", (const char *)&unk_4C40);
g_License[115] = atoi(v37);
}
if ( prefix("FKT=", a1) )
{
v12 = strdup(a1);
v36 = (char *)str_replace(v12, "FKT=", (const char *)&unk_4C40);
*(_QWORD *)&g_License[116] = atoi(v36);
}
if ( prefix("FKTH=", a1) )
{
v13 = strdup(a1);
v35 = (char *)str_replace(v13, "FKTH=", (const char *)&unk_4C40);
strcpy((char *)&g_License[13] + 1, v35);
}
if ( prefix("H=", a1) )
{
v14 = strdup(a1);
v34 = (char *)str_replace(v14, "H=", (const char *)&unk_4C40);
strcpy((char *)&g_License[153], v34);
}
if ( prefix("R=", a1) )
{
v15 = strdup(a1);
v33 = (char *)str_replace(v15, "R=", (const char *)&unk_4C40);
strcpy((char *)&g_License[171] + 3, v33);
}
if ( prefix("IP=", a1) )
{
v16 = strdup(a1);
v32 = (char *)str_replace(v16, "IP=", (const char *)&unk_4C40);
strcpy((char *)&g_License[124], v32);
}
if ( prefix("MAC=", a1) )
{
v17 = strdup(a1);
v31 = (char *)str_replace(v17, "MAC=", (const char *)&unk_4C40);
strcpy((char *)&g_License[128], v31);
}
if ( prefix("UT=", a1) )
{
v18 = strdup(a1);
v30 = (char *)str_replace(v18, "UT=", (const char *)&unk_4C40);
*(_QWORD *)&g_License[218] = atoi(v30);
}
if ( prefix("EW=", a1) )
{
v19 = strdup(a1);
v29 = (char *)str_replace(v19, "EW=", (const char *)&unk_4C40);
*(_QWORD *)&g_License[220] = atoi(v29);
}
if ( prefix("CI=", a1) )
{
v20 = strdup(a1);
v28 = (char *)str_replace(v20, "CI=", (const char *)&unk_4C40);
*(_QWORD *)&g_License[216] = strtoll(v28, 0LL, 10);
}
if ( prefix("CIDT=", a1) )
{
v21 = strdup(a1);
v27 = (char *)str_replace(v21, "CIDT=", (const char *)&unk_4C40);
strcpy((char *)&g_License[134] + 1, v27);
}
if ( prefix("LTD=", a1) )
{
v22 = strdup(a1);
v26 = (char *)str_replace(v22, "LTD=", (const char *)&unk_4C40);
strcpy((char *)&g_License[209] + 1, v26);
}
result = (char *)prefix("FN=", a1);
if ( (_DWORD)result )
{
v24 = strdup(a1);
v25 = (char *)str_replace(v24, "FN=", (const char *)&unk_4C40);
return strcpy((char *)&g_License[20] + 3, v25);
}
return result;
}
// 206240: using guessed type unsigned int g_License[222];
//----- (0000000000003539) ----------------------------------------------------
_BOOL8 __fastcall isValidMacAddress(_BYTE *a1)
{
int v3; // [rsp+18h] [rbp-8h]
int v4; // [rsp+1Ch] [rbp-4h]
v4 = 0;
v3 = 0;
while ( *a1 )
{
if ( ((*__ctype_b_loc())[(char)*a1] & 0x1000) != 0 )
{
++v4;
}
else if ( *a1 == 58 || *a1 == 45 )
{
if ( !v4 || v3 != v4 / 2 - 1 )
return v4 == 12 && (v3 == 5 || !v3);
++v3;
}
else
{
v3 = -1;
}
++a1;
}
return v4 == 12 && (v3 == 5 || !v3);
}
//----- (00000000000035F0) ----------------------------------------------------
unsigned int *validateLicense()
{
unsigned int *result; // rax
size_t v1; // rbx
char s[160]; // [rsp+0h] [rbp-2A0h] BYREF
char s1[64]; // [rsp+A0h] [rbp-200h] BYREF
struct utsname name; // [rsp+E0h] [rbp-1C0h] BYREF
__int64 v5; // [rsp+268h] [rbp-38h]
__int64 v6; // [rsp+270h] [rbp-30h]
FILE *stream; // [rsp+278h] [rbp-28h]
int v9; // [rsp+28Ch] [rbp-14h]
v9 = 0;
if ( uname(&name) )
{
g_License[1] = 0;
return 0LL;
}
if ( strcmp((const char *)&g_License[153], name.nodename) )
{
g_License[1] = 0;
return 0LL;
}
v1 = strlen((const char *)&g_License[153]);
if ( v1 > strlen((const char *)&g_License[20] + 3) )
g_old_method = 1;
if ( opendir("/sys/class/net/") )
{
sprintf(s, "/sys/class/net/%s/address", (const char *)&g_License[134] + 1);
stream = fopen(s, "r");
if ( stream )
{
fscanf(stream, "%s", s1);
if ( !strcmp(s1, (const char *)&g_License[128]) )
{
v9 = 1;
}
else
{
if ( isValidMacAddress(s1) )
{
v9 = 0;
g_License[1] = 0;
return 0LL;
}
v9 = 1;
}
}
else
{
v9 = 1;
g_License[1] = 1;
}
}
else
{
v9 = 1;
}
v6 = real_time2(0LL);
v5 = v6;
if ( v6 <= *(_QWORD *)&g_License[220] )
{
result = g_License;
g_License[1] = 1;
}
else
{
g_License[1] = 0;
return 0LL;
}
return result;
}
// 206240: using guessed type unsigned int g_License[222];
//----- (00000000000037FD) ----------------------------------------------------
__int64 __fastcall createRSA(__int64 a1, int a2)
{
__int64 v3; // [rsp+10h] [rbp-10h] BYREF
__int64 v4; // [rsp+18h] [rbp-8h]
v3 = 0LL;
v4 = BIO_new_mem_buf(a1, 0xFFFFFFFFLL);
if ( v4 )
{
if ( a2 )
return PEM_read_bio_RSA_PUBKEY(v4, &v3, 0LL, 0LL);
else
return PEM_read_bio_RSAPrivateKey(v4, &v3, 0LL, 0LL);
}
else
{
printf("Failed to create key BIO");
return 0LL;
}
}
// 1980: using guessed type __int64 __fastcall PEM_read_bio_RSAPrivateKey(_QWORD, _QWORD, _QWORD, _QWORD);
// 1AA0: using guessed type __int64 __fastcall PEM_read_bio_RSA_PUBKEY(_QWORD, _QWORD, _QWORD, _QWORD);
// 1B80: using guessed type __int64 __fastcall BIO_new_mem_buf(_QWORD, _QWORD);
//----- (0000000000003892) ----------------------------------------------------
__int64 __fastcall public_decrypt(__int64 a1, unsigned int a2, __int64 a3, __int64 a4)
{
__int64 RSA; // [rsp+28h] [rbp-8h]
RSA = createRSA(a3, 1);
return (unsigned int)RSA_public_decrypt(a2, a1, a4, RSA, padding);
}
// 18F0: using guessed type __int64 __fastcall RSA_public_decrypt(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD);
//----- (00000000000038E8) ----------------------------------------------------
void *checkLicenseInfo()
{
void *result; // rax
char delim[2]; // [rsp+Eh] [rbp-43E2h] BYREF
char s[5008]; // [rsp+10h] [rbp-43E0h] BYREF
char ptr[5008]; // [rsp+13A0h] [rbp-3050h] BYREF
char v4[2336]; // [rsp+2730h] [rbp-1CC0h] BYREF
char v5[5004]; // [rsp+3050h] [rbp-13A0h] BYREF
int v6; // [rsp+43DCh] [rbp-14h]
FILE *stream; // [rsp+43E0h] [rbp-10h]
char *i; // [rsp+43E8h] [rbp-8h]
if ( !strstr(_progname, "whostmgr")
&& !strstr(_progname, "xml-api")
&& !strstr(_progname, "queueprocd")
&& !strstr(_progname, "cpanel")
&& !strstr(_progname, "uapi")
&& !strstr(_progname, "cpsrvd") )
{
return 0LL;
}
strcpy(
v4,
"2d2d2d2d2d424547494e205055424c4943204b45592d2d2d2d2d0d0a4d494944496a414e42676b71686b6947397730424151454641414f434177"
"38414d49494443674b43417745417845656a772f306f4145336753754f52536c37550d0a6f654a574d754c2f39516d2f33494c617759575a6f6d"
"38432b4c4a695a4d2b5931674a64744f594c386f596b646c34426b36785068347235616b54593679435a0d0a6d4737317052784d30396d797334"
"585572664b32737669625a4366653563504930754b78737436353149396b4e396a557143466d39306371374f686c35512f4c0d0a57526a4e4d55"
"694e3671543450633943307255677535686f7332362f6f6d49685563464978764d4d3932386a734578544976793866483836466859486835654c"
"0d0a31727870527771515155656a35304d644531357337334a36622b5a6a78343752526c62633145796c68655367756c464e7454346457703074"
"74646b6348674c510d0a6c7a6370526c6b615a724c39736f55354e464a784639476a73626961733844366345435362496270314f486d5373746c"
"7a594d4d776c427871624b3441326c4f0d0a493274463646323254436d7875766a576a423574394d6474336865784b5137594e3142705270776e"
"756c536c4c4e4f75414e3043305838335a4d556b32396c490d0a39343451696f6648306a6442734e642b2b623432706e306444394b50464a326c"
"6e35436a596c5a617a37595570577954774558617133576e526d5469456a51560d0a4d41727059694a7436346774536c72744f58753145683378"
"706658714d7268486e4d4b55675375634e4458577876324837392f51474e5835497950754f4e65680d0a39456a474f5350534d78654832632b51"
"3537494a694e584a3259435474475a7239714257626b4263622b715057765471495a415a4e617543656177464f4f74500d0a4a7a3362614f6c63"
"376e636c7444447963586d776d3231524a4533554e366c544f365a396377314d496351597974326e704f74533772513574457844304d41520d0a"
"52435968786738506333746167335659597a4268386454394b62655a55786a4b66383534725a5a4e6371344342624f2f796669485a35454a3669"
"766c51414e740d0a456e36754a2f6b426f50677873435156516179516f7250566445545848485a623432563352617a746a4b2f534a4a375a4e71"
"4d34546454466a557264652b4a630d0a74734435656532534a6e417473727334436f796754327838376b776e63596f617a5441523477532b4769"
"7032484970577075423052376248324c4b736d7a44580d0a37326f6e593858652b364b65782b375242457563746339575730695059754143534f"
"614879326a684e2f487a6f7571436b533450582f526941556157534e75520d0a717a7067664d2b482b7771354959715657436b46653932546830"
"30547a5946413741704d7a45536f434575627732465341425359612f6d576e5a6a6d32444f680d0a4f39354b3341796c484673545a355a7a6a38"
"794f2f73594d744562516f3062365148547a47676641525a477841674d424141453d0d0a2d2d2d2d2d454e44205055424c4943204b45592d2d2d2d2d");
hex2char(v4, v5);
stream = fopen("/usr/local/RCBIN/icore/lkey", "rb");
if ( !stream )
return 0LL;
fread(ptr, 0x300uLL, 1uLL, stream);
result = (void *)public_decrypt((__int64)ptr, 0x300u, (__int64)v5, (__int64)s);
v6 = (int)result;
strcpy(delim, ",");
if ( (_DWORD)result != -1 )
{
for ( i = strtok(s, delim); i; i = strtok(0LL, delim) )
indexLicValues(i);
return validateLicense();
}
return result;
}
//----- (0000000000003ADF) ----------------------------------------------------
_DWORD *init()
{
_DWORD *result; // rax
int v1; // edx
const char *v2; // [rsp+10h] [rbp-10h]
const char *nptr; // [rsp+18h] [rbp-8h]
unsetenv("LD_PRELOAD");
result = (_DWORD *)g_License[0];
if ( !g_License[0] )
{
checkLicenseInfo();
g_License[0] = 1;
nptr = getenv("StartDate");
v2 = getenv("StopDate");
getenv("WriteDisabled");
if ( getenv("WriteDisabled") )
{
result = &g_write_override_enabled;
g_write_override_enabled = 0;
}
else
{
result = &g_write_override_enabled;
g_write_override_enabled = 1;
}
if ( nptr )
{
if ( v2 )
{
g_limitTimeFaking = 1;
g_StartDate = atoi(nptr);
v1 = atoi(v2);
result = &g_StopDate;
g_StopDate = v1;
}
}
}
return result;
}
// 2061D8: using guessed type _DWORD g_write_override_enabled;
// 2061EC: using guessed type int g_StartDate;
// 2061F0: using guessed type _DWORD g_StopDate;
// 206240: using guessed type unsigned int g_License[222];
//----- (0000000000003BC4) ----------------------------------------------------
__int64 __fastcall real_write2(unsigned int a1, __int64 a2, __int64 a3)
{
__int64 (__fastcall *v3)(_QWORD, __int64, __int64); // rax
v3 = (__int64 (__fastcall *)(_QWORD, __int64, __int64))dlsym((void *)0xFFFFFFFFFFFFFFFFLL, "write");
return v3(a1, a2, a3);
}
//----- (0000000000003C02) ----------------------------------------------------
__int64 __fastcall real_time(__int64 a1)
{
__int64 (__fastcall *v1)(__int64); // rax
v1 = (__int64 (__fastcall *)(__int64))dlsym((void *)0xFFFFFFFFFFFFFFFFLL, "time");
return v1(a1);
}
//----- (0000000000003C2F) ----------------------------------------------------
__int64 __fastcall time(__int64 a1)
{
init();
++g_time_calls;
if ( g_License[1]
&& g_License[115]
&& (!g_StartDate || g_time_calls >= g_StartDate)
&& (!g_StopDate || g_time_calls <= g_StopDate) )
{
return *(_QWORD *)&g_License[116];
}
else
{
return real_time(a1);
}
}
// 2061EC: using guessed type int g_StartDate;
// 2061F0: using guessed type _DWORD g_StopDate;
// 2061F8: using guessed type int g_time_calls;
// 206240: using guessed type unsigned int g_License[222];
//----- (0000000000003D12) ----------------------------------------------------
int __fastcall ioctl(unsigned int a1, unsigned int a2, __int64 a3)
{
int result; // eax
char *v4; // rax
char *v5; // rax
char *v6; // rax
__int64 v7; // rax
int v9; // [rsp+1Ah] [rbp-66h]
__int16 v10; // [rsp+1Eh] [rbp-62h]
__int64 v11; // [rsp+20h] [rbp-60h]
char *v12; // [rsp+28h] [rbp-58h]
char *v13; // [rsp+30h] [rbp-50h]
char *v14; // [rsp+38h] [rbp-48h]
char *dest; // [rsp+40h] [rbp-40h]
char *s1; // [rsp+48h] [rbp-38h]
char *v17; // [rsp+50h] [rbp-30h]
char *cp; // [rsp+58h] [rbp-28h]
char *v19; // [rsp+60h] [rbp-20h]
int v20; // [rsp+6Ch] [rbp-14h]
unsigned __int8 v21; // [rsp+72h] [rbp-Eh]
unsigned __int8 v22; // [rsp+73h] [rbp-Dh]
int v23; // [rsp+74h] [rbp-Ch]
char *v24; // [rsp+78h] [rbp-8h]
init();
++g_NumberofIOctls;
if ( !g_License[1] )
return orig_ioctl_16094(a1, a2, a3);
v19 = strdup((const char *)&g_License[7]);
cp = strdup((const char *)&g_License[3]);
if ( !handle_16090 )
{
orig_ioctl_16094 = (__int64 (__fastcall *)(_QWORD, _QWORD, _QWORD))dlsym((void *)0xFFFFFFFFFFFFFFFFLL, "ioctl");
v17 = dlerror();
if ( v17 )
{
fprintf(stderr, "%s\n", v17);
exit(1);
}
}
if ( !g_License[1] || g_NumberofIOctls > 5 || a2 != 35111 && a2 != 35093 )
return orig_ioctl_16094(a1, a2, a3);
s1 = (char *)(a3 + 2);
dest = (char *)a3;
if ( !strcmp((const char *)(a3 + 2), "lo") )
return orig_ioctl_16094(a1, a2, a3);
if ( !strcmp(dest, (const char *)&g_License[13] + 1) )
{
v14 = dest + 16;
strncpy(dest, (const char *)&g_License[134] + 1, 0xFuLL);
}
if ( a2 == 35093 )
{
v20 = orig_ioctl_16094(a1, 35093LL, a3);
v13 = (char *)a3;
if ( !strcmp((const char *)a3, (const char *)&g_License[134] + 1) )
{
v12 = v13 + 16;
inet_pton(2, cp, v13 + 20);
return 0;
}
else
{
return v20;
}
}
else
{
if ( strcmp(dest, (const char *)&g_License[134] + 1) )
return orig_ioctl_16094(a1, a2, a3);
v20 = orig_ioctl_16094(a1, 35111LL, a3);
result = (int)v19;
v24 = v19;
if ( v19 )
{
v23 = 0;
do
{
v4 = v24++;
v22 = *v4;
if ( v22 <= 0x2Fu || v22 > 0x39u )
{
if ( v22 <= 0x40u || v22 > 0x46u )
{
if ( v22 <= 0x60u || v22 > 0x66u )
{
v24 = 0LL;
goto LABEL_44;
}
v22 -= 87;
}
else
{
v22 -= 55;
}
}
else
{
v22 -= 48;
}
v5 = v24++;
v21 = *v5;
if ( v21 <= 0x2Fu || v21 > 0x39u )
{
if ( v21 <= 0x40u || v21 > 0x46u )
{
if ( v21 <= 0x60u || v21 > 0x66u )
{
v24 = 0LL;
goto LABEL_44;
}
v21 -= 87;
}
else
{
v21 -= 55;
}
}
else
{
v21 -= 48;
}
*((_BYTE *)&v9 + v23++) = (16 * v22) | v21;
if ( v23 > 5 )
goto LABEL_44;
v6 = v24++;
}
while ( *v6 == 58 );
v24 = 0LL;
LABEL_44:
if ( v24 && !*v24 )
{
v11 = a3 + 16;
*(_WORD *)(a3 + 16) = 1;
v7 = v11 + 2;
*(_DWORD *)(v11 + 2) = v9;
*(_WORD *)(v7 + 4) = v10;
return 0;
}
else
{
return v20;
}
}
}
return result;
}
// 3F83: conditional instruction was optimized away because %var_78.4==8927
// 4102: conditional instruction was optimized away because %var_8.8!=0
// 2061E8: using guessed type int g_NumberofIOctls;
// 206210: using guessed type __int64 (__fastcall *orig_ioctl_16094)(_QWORD, _QWORD, _QWORD);
// 206218: using guessed type __int64 handle_16090;
// 206240: using guessed type unsigned int g_License[222];
//----- (0000000000004155) ----------------------------------------------------
__int64 __fastcall real_xstat64(unsigned int a1, __int64 a2, __int64 a3)
{
__int64 (__fastcall *v3)(_QWORD, __int64, __int64); // rax
v3 = (__int64 (__fastcall *)(_QWORD, __int64, __int64))dlsym((void *)0xFFFFFFFFFFFFFFFFLL, "__xstat64");
return v3(a1, a2, a3);
}
//----- (0000000000004193) ----------------------------------------------------
__int64 __fastcall _xstat64(unsigned int a1, const char *a2, __int64 a3)
{
unsigned int v5; // [rsp+2Ch] [rbp-4h]
init();
v5 = real_xstat64(a1, (__int64)a2, a3);
if ( !g_License[1] )
return v5;
if ( !strcmp(a2, "/usr/local/cpanel") )
*(_QWORD *)(a3 + 8) = *(_QWORD *)&g_License[118];
if ( !strcmp(a2, "/var/cpanel") )
*(_QWORD *)(a3 + 8) = *(_QWORD *)&g_License[120];
return v5;
}
// 206240: using guessed type unsigned int g_License[222];
//----- (000000000000423A) ----------------------------------------------------
__int64 __fastcall real_fxstat64(unsigned int a1, unsigned int a2, __int64 a3)
{
void *v3; // rax
v3 = dlsym((void *)0xFFFFFFFFFFFFFFFFLL, "__fxstat64");
return ((__int64 (__fastcall *)(_QWORD, _QWORD, __int64))v3)(a1, a2, a3);
}
//----- (0000000000004275) ----------------------------------------------------
__int64 __fastcall _fxstat64(unsigned int a1, unsigned int a2, __int64 a3)
{
unsigned int v5; // [rsp+1Ch] [rbp-4h]
init();
v5 = real_fxstat64(a1, a2, a3);
if ( !g_License[1] )
return v5;
if ( *(_QWORD *)(a3 + 8) == *(_QWORD *)&g_License[216] )
*(_QWORD *)(a3 + 8) = *(_QWORD *)&g_License[122];
return v5;
}
// 206240: using guessed type unsigned int g_License[222];
//----- (00000000000042F0) ----------------------------------------------------
__int64 __fastcall real_memmove(__int64 a1, __int64 a2, __int64 a3)
{
__int64 (__fastcall *v3)(__int64, __int64, __int64); // rax
v3 = (__int64 (__fastcall *)(__int64, __int64, __int64))dlsym((void *)0xFFFFFFFFFFFFFFFFLL, "memmove");
return v3(a1, a2, a3);
}
//----- (0000000000004331) ----------------------------------------------------
__int64 __fastcall memmove(__int64 a1, const char *a2, size_t a3)
{
char *dest; // [rsp+28h] [rbp-8h]
init();
if ( g_mem_calls > 3
|| !g_License[1]
|| !strstr(a2, "\nhst:")
|| !strstr(a2, "\nuexp:")
|| !strstr(a2, "ltd:")
|| !strstr(a2, "\nlpt:")
|| !strstr(a2, "\nflags:")
|| !strstr(a2, "\nuid:")
|| !strstr(a2, "\nmu:")
|| !strstr(a2, "\nlt:")
|| !strstr(a2, "\npb:")
|| !strstr(a2, "\nhse:")
|| !strstr(a2, "\nm0:")
|| !strstr(a2, "\nm1:")
|| !strstr(a2, "\nm2:")
|| !strstr(a2, "\nm3:")
|| !strstr(a2, "\nm4:")
|| !strstr(a2, "\nm5:")
|| !strstr(a2, "\nm6:")
|| !strstr(a2, "\nm7:")
|| !strstr(a2, "\nm8:")
|| !strstr(a2, "\nm9:") )
{
return real_memmove(a1, (__int64)a2, a3);
}
dest = (char *)malloc(a3 + 10);
strncpy(dest, a2, a3);
if ( !g_old_method )
str_replace3(dest, a3, (char *)&g_License[20] + 3, &g_License[153]);
++g_mem_calls;
return real_memmove(a1, (__int64)dest, a3);
}
// 1C00: using guessed type __int64 __fastcall str_replace3(_QWORD, _QWORD, _QWORD, _QWORD);
// 206240: using guessed type unsigned int g_License[222];
//----- (000000000000467B) ----------------------------------------------------
__int64 __fastcall real_write(unsigned int a1, __int64 a2, __int64 a3)
{
__int64 (__fastcall *v3)(_QWORD, __int64, __int64); // rax
v3 = (__int64 (__fastcall *)(_QWORD, __int64, __int64))dlsym((void *)0xFFFFFFFFFFFFFFFFLL, "write");
return v3(a1, a2, a3);
}
//----- (00000000000046B9) ----------------------------------------------------
char *__fastcall StringPadRight(char *a1, int a2, const char *a3)
{
int v5; // [rsp+28h] [rbp-8h]
int i; // [rsp+2Ch] [rbp-4h]
v5 = strlen(a1);
if ( v5 >= a2 )
return a1;
for ( i = 0; i < a2 - v5; ++i )
strcat(a1, a3);
return a1;
}
//----- (000000000000471A) ----------------------------------------------------
__int64 __fastcall write(unsigned int a1, const char *a2, __int64 a3)
{
char *v4; // rax
char *v5; // rax
char v7[160]; // [rsp+60h] [rbp-170h] BYREF
char v8[160]; // [rsp+100h] [rbp-D0h] BYREF
char *dest; // [rsp+1A0h] [rbp-30h]
char *v10; // [rsp+1A8h] [rbp-28h]
char *v11; // [rsp+1B0h] [rbp-20h]
char *v12; // [rsp+1B8h] [rbp-18h]
char *s; // [rsp+1C0h] [rbp-10h]
__int64 v14; // [rsp+1C8h] [rbp-8h]
v14 = a3;
if ( a1 != 1 )
return real_write(a1, (__int64)a2, a3);
init();
if ( !g_old_method )
return real_write(a1, (__int64)a2, a3);
if ( !g_write_override_enabled )
return real_write(1u, (__int64)a2, a3);
if ( !g_License[1] || total_write_calls > 2 )
return real_write(a1, (__int64)a2, a3);
s = strdup((const char *)&g_License[20] + 3);
v12 = strdup((const char *)&g_License[153]);
v4 = strdup(s);
v11 = strtok(v4, ".");
v5 = strdup(v12);
v10 = strtok(v5, ".");
sprintf(v8, "[%s]", v11);
sprintf(v7, "[%s]", v10);
if ( !strstr(a2, s) )
return real_write(1u, (__int64)a2, a3);
dest = (char *)malloc(a3 + 500);
strncpy(dest, a2, a3);
++total_write_calls;
if ( strstr(a2, s) )
str_replace3(dest, a3, s, v12);
return real_write(1u, (__int64)dest, a3);
}
// 1C00: using guessed type __int64 __fastcall str_replace3(_QWORD, _QWORD, _QWORD, _QWORD);
// 2061D8: using guessed type _DWORD g_write_override_enabled;
// 2061FC: using guessed type int total_write_calls;
// 206240: using guessed type unsigned int g_License[222];
// 471A: using guessed type char var_D0[160];
// 471A: using guessed type char var_170[160];
//----- (00000000000049C0) ----------------------------------------------------
__int64 __fastcall syscall(__int64 a1, char *a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6, __int64 a7)
{
char *v8; // rax
char *v9; // rax
char *v10; // rax
__int64 v15; // [rsp+30h] [rbp-10h]
const char *src; // [rsp+38h] [rbp-8h]
init();
orig_syscall_16362 = (__int64 (__fastcall *)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD, _QWORD, _QWORD))dlsym((void *)0xFFFFFFFFFFFFFFFFLL, "syscall");
if ( !g_License[1] || a1 != 63 || g_n_uname_syscall > 0 )
return (int)orig_syscall_16362(a1, a2, a3, a4, a5, a6, a7);
++g_n_uname_syscall;
v15 = (int)orig_syscall_16362(63LL, a2, a3, a4, a5, a6, a7);
if ( g_old_method )
src = strdup((const char *)&g_License[20] + 3);
else
src = strdup((const char *)&g_License[153]);
strcpy(a2, "Linux");
strcpy(a2 + 65, src);
v8 = strdup((const char *)&g_License[39] + 2);
strcpy(a2 + 130, v8);
v9 = strdup((const char *)&g_License[58] + 1);
strcpy(a2 + 195, v9);
v10 = strdup((const char *)&g_License[77]);
strcpy(a2 + 260, v10);
strcpy(a2 + 325, "GNU/Linux");
return v15;
}
// 206200: using guessed type int g_n_uname_syscall;
// 206220: using guessed type __int64 (__fastcall *orig_syscall_16362)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD, _QWORD, _QWORD);
// 206240: using guessed type unsigned int g_License[222];
//----- (0000000000004C0E) ----------------------------------------------------
__int64 ptrace()
{
return 0LL;
}
// 4C0E: using guessed type __int64 ptrace();
//----- (0000000000004C1C) ----------------------------------------------------
void term_proc()
{
;
}
// nfuncs=136 queued=39 decompiled=39 lumina nreq=0 worse=0 better=0
// ALL OK, 39 function(s) have been successfully decompiled
Write, Run & Share C++ code online using OneCompiler's C++ online compiler for free. It's one of the robust, feature-rich online compilers for C++ language, running on the latest version 17. Getting started with the OneCompiler's C++ compiler is simple and pretty fast. The editor shows sample boilerplate code when you choose language as C++ and start coding!
OneCompiler's C++ online compiler supports stdin and users can give inputs to programs using the STDIN textbox under the I/O tab. Following is a sample program which takes name as input and print your name with hello.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string name;
cout << "Enter name:";
getline (cin, name);
cout << "Hello " << name;
return 0;
}
C++ is a widely used middle-level programming language.
When ever you want to perform a set of operations based on a condition If-Else is used.
if(conditional-expression) {
//code
}
else {
//code
}
You can also use if-else for nested Ifs and If-Else-If ladder when multiple conditions are to be performed on a single variable.
Switch is an alternative to If-Else-If ladder.
switch(conditional-expression){
case value1:
// code
break; // optional
case value2:
// code
break; // optional
......
default:
code to be executed when all the above cases are not matched;
}
For loop is used to iterate a set of statements based on a condition.
for(Initialization; Condition; Increment/decrement){
//code
}
While is also used to iterate a set of statements based on a condition. Usually while is preferred when number of iterations are not known in advance.
while (condition) {
// code
}
Do-while is also used to iterate a set of statements based on a condition. It is mostly used when you need to execute the statements atleast once.
do {
// code
} while (condition);
Function is a sub-routine which contains set of statements. Usually functions are written when multiple calls are required to same set of statements which increases re-usuability and modularity. Function gets run only when it is called.
return_type function_name(parameters);
function_name (parameters)
return_type function_name(parameters) {
// code
}