Forum du club des d�veloppeurs et IT Pro - Contribuez

RC4 Cipher du virus bagle

n5Rzn1D9dC — Fri, 16 May 2025 00:36:43 GMT

Je vois que pas mal de monde s'int�resse aux outils de bagle alors j'ai d�cid� de poster ce RC4.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
; RC4 Cipher
; #########################################################################
 
rc4_state struct
    x   BYTE   ?
    y   BYTE   ?
    m   BYTE   256 dup(?)
rc4_state ends
 
; Reset RC4 state, initialize encryption key
RC4Setup proc uses esi edi ebx state, key, len: DWORD
        LOCAL   a: BYTE
        LOCAL   j: BYTE
 
        invoke  ZeroMemory, state, sizeof rc4_state
        mov     edi, state
        inc     edi
        inc     edi             ; m
 
        xor     edx, edx
        mov     ecx, 256
@l:
        mov     byte ptr[edi+edx], dl
        inc     dl
        loop    @l
 
        mov     edi, state
        inc     edi
        inc     edi             ; m
        mov     esi, key
 
        mov     j, 0
        xor     ecx, ecx        ; k
        xor     ebx, ebx        ; i
 
@l_gen:
        mov     al, byte ptr[edi+ebx]
        mov     a, al
 
        add     j, al
        mov     al, byte ptr[esi+ecx]
        add     j, al
 
        movzx   edx, j
        mov     al, byte ptr[edi+edx]
        mov     byte ptr[edi+ebx], al
        mov     al, a
        mov     byte ptr[edi+edx], al
 
        inc     ecx
        .IF     ecx >= len
                xor     ecx, ecx
        .ENDIF
        inc     bl
        jnz     @l_gen
        ret
RC4Setup endp
 
; Crypt data using RC4 algorithm & update the state
RC4Crypt proc uses ebx esi edi state, cdata, len: DWORD
        LOCAL   a: BYTE
        LOCAL   b: BYTE
        LOCAL   x: BYTE
        LOCAL   y: BYTE
        LOCAL   i: DWORD
 
        mov     ebx, state
        assume  ebx: ptr rc4_state
        mov     al, [ebx].x
        mov     x, al
        mov     al, [ebx].y
        mov     y, al
        mov     edi, ebx
        inc     edi
        inc     edi
 
        mov     esi, cdata
 
        mov     i, 0
 
        mov     ecx, len
        jecxz   @no_data
 
@l:
        ; x = (unsigned char) ( x + 1 ); a = m[x];
        inc     x
        movzx   eax, x
        movzx   edx, byte ptr[edi+eax]   ; a
        mov     a, dl
 
        ; y = (unsigned char) ( y + a );
        add     y, dl
 
        ; m[x] = b = m[y];
        movzx   eax, y
        mov     dl, byte ptr[edi+eax]
        mov     b, dl
        movzx   eax, x
        mov     byte ptr[edi+eax], dl
 
        ; m[y] = a;
        movzx   eax, y
        mov     dl, a
        mov     byte ptr[edi+eax], dl
 
        ; data[i] ^= m[(unsigned char) ( a + b )];
        mov     dl, a
        add     dl, b
        mov     dl, byte ptr[edi+edx]
        mov     eax, i
        xor     byte ptr[esi+eax], dl
 
        inc     i
        loop    @l
 
@no_data:
        mov     al, x
        mov     byte ptr[ebx], al
        mov     al, y
        mov     byte ptr[ebx+1], al
        ret
RC4Crypt endp

Exemple de base64 du virus Bagle

n5Rzn1D9dC — Sun, 04 May 2025 04:36:48 GMT

Bonjour,

Comme certains d'entre-vous doivent le savoir, le virus bagle a �t� �crit enti�rement en assembleur.
J'ai r�cup�r� la partie "encode" du base64 (il n'y pas de partie "decode).
Si vous regardez la diff�rence avec le miens que j'ai post� dans cette section du forum, vous verrez que contrairement � moi, il n'a pas utilis� de buffer pour stocker les diff�rentes valeurs, tout a �t� �crit en dynamique, ce qui est impressionnant (pour un non mateu comme moi)

Voil� le code: (pour intel x86 sous Windows)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
; Encodes data to base64 format
Base64Encode proc uses esi edi ebx lpSrc, lpDst, dwSrcLen: DWORD
        mov     esi, lpSrc
        mov     edi, lpDst
        mov     ecx, dwSrcLen
 
        xor     ebx, ebx
 
@l:
        jecxz   @b64_ret
 
        lodsb
        shl     eax, 16
        cmp     ecx, 1
        jz      @work
        lodsb
        shl     ax, 8
        cmp     ecx, 2
        jz      @work
        lodsb
 
@work:
        ; Output b64 quad
        mov     edx, eax
        ror     edx, 24
 
        push    ecx
        push    4
        pop     ecx
@l2:
        call    @b64_write
        loop    @l2
        pop     ecx
 
        inc     ebx
        .IF     ebx == 18
                xor     ebx, ebx
                mov     ax, 0a0dh
                stosw
        .ENDIF
 
        sub     ecx, 3
        jns     @l
 
        ; Pad
        neg     ecx
        sub     edi, ecx
        mov     al, '='
        rep stosb
 
@b64_ret:
        ret
 
@b64_write:
        rol     edx, 6
        mov     eax, edx
        and     al, 00111111b
        cmp     al, 62
        jae     @write_spec
 
        cmp     al, 52
        jae     @write_number
 
        ; Uppercase
        add     al, 'A'
        cmp     al, 'A'+26
        jb      @write
        ; Lowercase
        add     al, 6
        jmp     @write
        ; Number
@write_number:
        add     al, '0'-52
        jmp     @write
        ; Special: +/
@write_spec:
        sub     al, 62
        shl     al, 2
        add     al, 43        
@write:
        stosb
 
        retn
Base64Encode endp

inversion de bits

n5Rzn1D9dC — Sun, 04 May 2025 04:26:58 GMT

Voil� un exemple propre d'un syst�me d'inversion de bits.
Attention, si vous voulez commencer par en faire un vous m�me, ne choisissait pas la lettre A ni la lettre B.
Je m'explique la lettre A est 0x41 ce qui donne 0100 0001b et on pourrait penser que son double est la solution puisque 0x82 donne le bon r�sultat 1000 0010b, donc on pourrait �tre tenter de penser qu'il suffit de faire x2 pour inverser les bits.
Ensuite vient le probl�me de la lettre B 0x42, qui est en faite un miroir d'elle m�me 0100 0010b donc non utilisable pour commencer � travailler. C'est pourquoi j'ai choisi la lettre C 0x43 qui donne 0xC2 en sortie et une inversion de bits parfaite.
Amusez-vous bien.

A compiler avec FASM, fonctionne sous Windows 11, intel x86

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
format PE console
include 'include/win32a.inc'
entry start
 
section '.text' code readable executable
 
start:
    xor eax,eax
    mov al,0x43
 
    call reverse_bits
 
    push eax
    push formh
    call [printf]
 
    push 0
    call [ExitProcess]
 
reverse_bits:
    push ecx
    push edx
 
    xor edx,edx
    mov cl,8
 
@@:
    shl al,1        ; bit de gauche → CF
    rcr dl,1        ; CF → bit de droite de DL
    dec cl
    jnz @b
 
    mov al,dl
 
    pop edx
    pop ecx
    ret
 
section '.data' data readable writeable
 
formh db '%08x',13,10,0
 
section '.idata' import data readable writeable
 
library kernel32,'kernel32.dll',\
		msvcrt,'msvcrt.dll',\
		user32,'user32.dll',\
		wsock32,'ws2_32.dll'
 
include 'include\api\kernel32.inc'
include 'include\api\user32.inc'
include 'include\api\wsock32.inc'
 
import msvcrt,\
printf,'printf'