0012FE40 | 00 01 02 03  04 05 06 07  08 09 0A 0B  0C 0D 0E 0F | ................ |
0012FE50 | 10 11 12 13  14 15 16 17  18 19 1A 1B  1C 1D 1E 1F | ................ |
0012FE60 | 20 21 22 23  24 25 26 27  28 29 2A 2B  2C 2D 2E 2F |  !"#$%&'()*+,-./ |
0012FE70 | 30 31 32 33  34 35 36 37  38 39 3A 3B  3C 3D 3E 3F | 0123456789:;<=>? |
0012FE80 | 40 41 42 43  44 45 46 47  48 49 4A 4B  4C 4D 4E 4F | @ABCDEFGHIJKLMNO |
0012FE90 | 50 51 52 53  54 55 56 57  58 59 5A 5B  5C 5D 5E 5F | PQRSTUVWXYZ[\]^_ |
0012FEA0 | 60 61 62 63  64 65 66 67  68 69 6A 6B  6C 6D 6E 6F | `abcdefghijklmno |
0012FEB0 | 70 71 72 73  74 75 76 77  78 79 7A 7B  7C 7D 7E 7F | pqrstuvwxyz{|}~  |
0012FEC0 | 80 81 82 83  84 85 86 87  88 89 8A 8B  8C 8D 8E 8F | ................ |
0012FED0 | 90 91 92 93  94 95 96 97  98 99 9A 9B  9C 9D 9E 9F | ................ |
0012FEE0 | A0 A1 A2 A3  A4 A5 A6 A7  A8 A9 AA AB  AC AD AE AF | ................ |
0012FEF0 | B0 B1 B2 B3  B4 B5 B6 B7  B8 B9 BA BB  BC BD BE BF | ................ |
0012FF00 | C0 C1 C2 C3  C4 C5 C6 C7  C8 C9 CA CB  CC CD CE CF | АБВГДЕЖЗИЙКЛМНОП |
0012FF10 | D0 D1 D2 D3  D4 D5 D6 D7  D8 D9 DA DB  DC DD DE DF | РСТУФХЦЧШЩЪЫЬЭЮЯ |
0012FF20 | E0 E1 E2 E3  E4 E5 E6 E7  E8 E9 EA EB  EC ED EE EF | абвгдежзийклмноп |
0012FF30 | F0 F1 F2 F3  F4 F5 F6 F7  F8 F9 FA FB  FC FD FE FF | рстуфхцчшщъыьэюя |

typedef enum _word_size {
    WORD_4_BYTE = 4,
    WORD_8_BYTE = 8
} word_size;

typedef enum _dump_width {
    WIDTH_4 = 4,
    WIDTH_8 = 8,
    WIDTH_16 = 16,
    WIDTH_32 = 32
} dump_width;


#define c_r(n, a, b) (((n) >= (a)) && ((n) <= (b)))

/*
    word:   размер слова (WORD_4_BYTE, WORD_8_BYTE)
    width:  ширина дампа в байтах (WIDTH_4, WIDTH_8, WIDTH_16, WIDTH_32)
    no_col: true - сплошные байты, false - разделять по размеру слова
    buf:    буфер
    num:    размер буфера
*/
void hex_dump(const word_size word, const dump_width width, bool no_col, void *const buf, const size_t num)
{
    if (width >= word && !(width % word) && c_r(width, WIDTH_4, WIDTH_32) && buf && num > 0) {
        const uint32_t pad = width - ((num - 1) % width) + num - 1;

        for (size_t i = 0; i < pad; i++) {
            if (!(i % width))
                printf("%08X | ", (uint32_t)buf + i);

            if (i < num)
                printf("%02X", ((uint8_t *)buf)[i]);
            else
                printf("--");

            printf((i + 1) % (width / (no_col ? 1 : width / word)) ? " " : ((i + 1) % width ? "  " : " | "));

            if (!((i + 1) % width) || i + 1 == pad) {
                for (size_t j = i + 1 - width; j < i + 1 ? true : (printf(" |\n"), false); j++) {
                    if (j < num) {
                        uint8_t c = ((uint8_t *)buf)[j];
                        putchar(c_r(c, 0x20, 0x7F) || c_r(c, 0xC0, 0xFF) ? c : '.');
                    } else {
                        putchar('.');
                    }
                }
            }
        }

        putchar('\n');
    } else {
        printf("hex_dump error!\n");
        exit(1);
    }
}

    char *s = "test string, тестовая сТрОкА, 1234567890";
    hex_dump(WORD_4_BYTE, WIDTH_16, false, s, strlen(s) + sizeof((char)'\n'));

00409000 | 74 65 73 74  20 73 74 72  69 6E 67 2C  20 F2 E5 F1 | test string, тес |
00409010 | F2 EE E2 E0  FF 20 F1 D2  F0 CE EA C0  2C 20 31 32 | товая сТрОкА, 12 |
00409020 | 33 34 35 36  37 38 39 30  00 -- -- --  -- -- -- -- | 34567890........ |

#ifndef ICOGEN_H
#define ICOGEN_H

#include <windows.h>

#define SystemFunction036 NTAPI SystemFunction036
#include <NTSecAPI.h>
#undef SystemFunction036

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>


typedef struct _ICONDIRENTRY {
    BYTE bWidth;
    BYTE bHeight;
    BYTE bColorCount;
    BYTE bReserved;
    WORD wPlanes;
    WORD wBitCount;
    DWORD dwBytesInRes;
    DWORD dwImageOffset;
} ICONDIRENTRY, *PICONDIRENTRY;

typedef struct _ICONDIR {
    WORD idReserved;
    WORD idType;
    WORD idCount;
    PICONDIRENTRY idEntries;
} ICONDIR, *PICONDIR;

typedef struct _ICONIMAGE {
    BITMAPINFOHEADER icHeader;
    RGBQUAD *icColors;
    BYTE *icMask;
} ICONIMAGE, *PICONIMAGE;


typedef struct _ICON {
    FILE *hFile;
    ICONDIR IconDir;
    PICONIMAGE pIconImage;
} ICON, *PICON;


/*
    szFileName - файл иконки
    aIcoSize - массив с требуемыми размерами иконок (min - 1x1, max - 256x256)
    uIcoCount - кол-во элементов (иконок) в массиве
    uIcoColor - кол-во используемых цветов
    bTransp - прозрачность (от 0 до 255)

    return: 0 - успех; -1 - ошибка
*/
int WINAPI icogen_create_ico(const char *szFileName, const uint32_t aIcoSize[], const size_t uIcoCount, const uint32_t uIcoColor, const uint8_t bTransp);

#endif

#include "icogen.h"

ULONG icogen_rnd(const uint32_t uMin, const uint32_t uMax)
{
    ULONG lRnd;

    return RtlGenRandom(&lRnd, sizeof(ULONG)) ? (uMin <= uMax ? lRnd % (uMax - uMin + 1) + uMin : -1) : -1;
}


int icogen_size_is_ok(const uint32_t aIcoSize[], const size_t uIcoCount) {
    for (size_t i = 0; i < uIcoCount; i++) {
        if (aIcoSize[i] < 1 || aIcoSize[i] > 256)
            return -1;
    }

    return 0;
}


#define get_mask_size(bit) (((bit)+31)/32*4*(bit))


PICON icogen_init(const char *szFileName, const uint32_t aIcoSize[], const size_t uIcoCount, const uint32_t uIcoColor)
{
    if (!icogen_size_is_ok(aIcoSize, uIcoCount) && uIcoCount >= 1 && uIcoColor >= 1) {
        PICON pIcon = NULL;

        if (pIcon = calloc(1, sizeof(ICON))) {
            if (pIcon->hFile = fopen(szFileName, "wb")) {
                if (pIcon->IconDir.idEntries = calloc(uIcoCount, sizeof(ICONDIRENTRY))) {
                    if (pIcon->pIconImage = calloc(uIcoCount, sizeof(ICONIMAGE))) {
                        for (size_t i = 0; i < uIcoCount; i++) {
                            if (!(pIcon->pIconImage[i].icColors = calloc(aIcoSize[i] * aIcoSize[i], sizeof(RGBQUAD))))
                                return NULL;

                            if (!(pIcon->pIconImage[i].icMask = calloc(1, get_mask_size(aIcoSize[i]))))
                                return NULL;
                        }

                        return pIcon;
                    }
                }
            }
        }
    }

    return NULL;
}


void icogen_clear(PICON pIcon, const size_t uIcoCount)
{
    for (size_t i = 0; i < uIcoCount; i++) {
        if (pIcon->pIconImage[i].icMask)
            free(pIcon->pIconImage[i].icMask);

        if (pIcon->pIconImage[i].icColors)
            free(pIcon->pIconImage[i].icColors);
    }

    if (pIcon->pIconImage)
        free(pIcon->pIconImage);

    if (pIcon->IconDir.idEntries)
        free(pIcon->IconDir.idEntries);

    fclose(pIcon->hFile);

    if (pIcon)
        free(pIcon);
}


void icogen_write(PICON pIcon, const uint32_t aIcoSize[], const size_t uIcoCount)
{
    // icondir
    fwrite(&pIcon->IconDir.idReserved, sizeof(pIcon->IconDir.idReserved), 1, pIcon->hFile);
    fwrite(&pIcon->IconDir.idType, sizeof(pIcon->IconDir.idType), 1, pIcon->hFile);
    fwrite(&pIcon->IconDir.idCount, sizeof(pIcon->IconDir.idCount), 1, pIcon->hFile);

    fwrite(pIcon->IconDir.idEntries, sizeof(ICONDIRENTRY), uIcoCount, pIcon->hFile);

    for (size_t i = 0; i < uIcoCount; i++) {
        // header
        fwrite(&pIcon->pIconImage[i].icHeader, sizeof(pIcon->pIconImage[i].icHeader), 1, pIcon->hFile);

        // rgb
        fwrite(pIcon->pIconImage[i].icColors, sizeof(RGBQUAD), aIcoSize[i] * aIcoSize[i], pIcon->hFile);

        // mask
        fwrite(pIcon->pIconImage[i].icMask, get_mask_size(aIcoSize[i]), 1, pIcon->hFile);
    }
}


int WINAPI icogen_create_ico(const char *szFileName, const uint32_t aIcoSize[], const size_t uIcoCount, const uint32_t uIcoColor, const uint8_t bTransp)
{
    PICON pIcon = NULL;

    if (pIcon = icogen_init(szFileName, aIcoSize, uIcoCount, uIcoColor)) {
        DWORD dwImageOffsetPrev = uIcoCount * sizeof(ICONDIRENTRY) + sizeof(WORD) * 3;

        pIcon->IconDir.idReserved = 0;
        pIcon->IconDir.idType = 1;
        pIcon->IconDir.idCount = (WORD)uIcoCount;

        for (size_t i = 0; i < uIcoCount; i++) {
            pIcon->IconDir.idEntries[i].bWidth = aIcoSize[i];
            pIcon->IconDir.idEntries[i].bHeight = aIcoSize[i];
            pIcon->IconDir.idEntries[i].bColorCount = 0;
            pIcon->IconDir.idEntries[i].bReserved = 0;
            pIcon->IconDir.idEntries[i].wPlanes = 1;
            pIcon->IconDir.idEntries[i].wBitCount = 32;
            pIcon->IconDir.idEntries[i].dwBytesInRes = sizeof(BITMAPINFOHEADER) + (sizeof(RGBQUAD) * aIcoSize[i] * aIcoSize[i]) + get_mask_size(aIcoSize[i]);
            pIcon->IconDir.idEntries[i].dwImageOffset = dwImageOffsetPrev;

            pIcon->pIconImage[i].icHeader.biSize = sizeof(BITMAPINFOHEADER);
            pIcon->pIconImage[i].icHeader.biWidth = aIcoSize[i];
            pIcon->pIconImage[i].icHeader.biHeight = 2 * aIcoSize[i];
            pIcon->pIconImage[i].icHeader.biPlanes = 1;
            pIcon->pIconImage[i].icHeader.biBitCount = 32;
            pIcon->pIconImage[i].icHeader.biCompression = 0;
            pIcon->pIconImage[i].icHeader.biSizeImage = 0;
            pIcon->pIconImage[i].icHeader.biXPelsPerMeter = 0;
            pIcon->pIconImage[i].icHeader.biYPelsPerMeter = 0;
            pIcon->pIconImage[i].icHeader.biClrUsed = 0;
            pIcon->pIconImage[i].icHeader.biClrImportant = 0;

            RGBQUAD *rgb = calloc(uIcoColor, sizeof(RGBQUAD));
            memset(rgb, bTransp, uIcoColor * sizeof(RGBQUAD));

            uint32_t jmp = 0;

            for (size_t j = 0; j < aIcoSize[i] * aIcoSize[i]; j++) {
                if (!(j % (aIcoSize[i] * aIcoSize[i] / icogen_rnd(1, aIcoSize[i])))) {
                    for (size_t k = 0; k < uIcoColor; k++) {
                        RtlGenRandom(rgb + k, 3);
                    }

                    jmp = jmp ? 0 : 1;
                }

                if (icogen_rnd(jmp, 1)) {
                    pIcon->pIconImage[i].icColors[j] = rgb[icogen_rnd(0, uIcoColor - 1)];
                }
            }

            if (rgb)
                free(rgb);

            RtlGenRandom(pIcon->pIconImage[i].icMask, get_mask_size(aIcoSize[i]));

            dwImageOffsetPrev += pIcon->IconDir.idEntries[i].dwBytesInRes;
        }

        icogen_write(pIcon, aIcoSize, uIcoCount);
        icogen_clear(pIcon, uIcoCount);

        return 0;
    }

    return -1;
}

#include "icogen.h"

int main(int argc, char **argv)
{
    const uint32_t ico[] = { 16, 24, 32, 48, 128, 256 };

    if (!icogen_create_ico("icon.ico", ico, sizeof(ico) / sizeof(ico[0]), 2, 255)) {
        printf("Successfully completed!\n");
    } else {
        printf("Error!\n");
    }

    return 0;
}

    format pe console 5.01


    section '.text' import readable executable

    include 'win32a.inc'

    library icogen_dll, 'icogen_dll.dll',\
            kernel32, 'kernel32.dll',\
            msvcrt, 'msvcrt.dll'


    import  icogen_dll,\
            icogen_create_ico, 'icogen_create_ico'

    import  kernel32,\
            ExitProcess, 'ExitProcess'

    import  msvcrt,\
            printf, 'printf'


entry $

    invoke icogen_create_ico, fname, ico, ico_sz, 2, 255
    test eax, eax
    jne .e
    cinvoke printf, s
    jmp .s
.e: cinvoke printf, e
.s: invoke ExitProcess, 0


    ico         dd 16, 24, 32, 48, 128, 256
    ico_sz      = ($ - ico) / 4

    fname       db 'icon.ico', 0

    s           db 'Successfully completed!', 13, 10, 0
    e           db 'Error!', 13, 10, 0

#!/usr/bin/env py -3

import ctypes
import struct

icogen_dll = ctypes.windll.LoadLibrary('icogen_dll.dll')

sz = 16, 24, 32, 48, 128, 256

if not icogen_dll.icogen_create_ico(b'icon.ico', struct.pack(str(len(sz)) + 'I', *sz), len(sz), 2, 255):
    print("Successfully completed!\n")
else:
    print("Error!\n")

; ------------------------------------
proc rc4, k, kn, d, dn
; k - ключ
; kn - розмір ключа
; d - буфер
; dn - розмір буфера
; ------------------------------------
    locals
        s rb 256
        v dd 256
    endl

    lea edi, [s]
    mov esi, edi

    xor ecx, ecx
    xor eax, eax
@@: stosb
    inc eax
    cmp eax, [v]
    jne @b

    xor edi, edi
@@: mov bl, byte[esi + ecx]
    add edi, ebx

    mov eax, ecx
    xor edx, edx
    mov ebx, [kn]
    div ebx

    mov eax, [k]
    mov bl, byte[eax + edx]
    add edi, ebx

    mov eax, edi
    mov ebx, [v]
    div ebx

    mov edi, edx

    mov bl, [esi + ecx]
    xchg [esi + edi], bl
    mov [esi + ecx], bl

    inc ecx
    cmp ecx, [v]
    jne @b

    xor ecx, ecx
    xor eax, eax
    xor edi, edi

@@: push eax
    inc ecx
    mov eax, ecx
    xor edx, edx
    mov ebx, [v]
    div ebx
    mov ecx, edx

    mov bl, byte[esi + ecx]
    add edi, ebx
    
    mov eax, edi
    mov ebx, [v]
    div ebx
    mov edi, edx

    mov bl, [esi + ecx]
    xchg [esi + edi], bl
    mov [esi + ecx], bl

    mov al, byte[esi + ecx]
    add al, byte[esi + edi]
    mov ebx, [v]
    div ebx

    mov bl, byte[esi + edx]

    pop eax
    add eax, [d]
    xor [eax], bl
    sub eax, [d]

    inc eax
    cmp eax, [dn]
    jne @b

    ret
endp

#define start(f) __declspec(naked) void start_##f(void) {};
#define end(f) __declspec(naked) void end_##f(void) {};
#define calc_size(f) (uint8_t*)end_##f - (uint8_t*)start_##f

start(func)
uint32_t func(...)
{
    ...
}
end(func)

printf("size: %d\n", calc_size(func));

fUnicode || pBuffer++;