вобщем, ситуация такова: шаг1: ввожу в проге пароль, он гамируется и переводится в клю4 вида 00A1E7B0 EF 2A BA 75 96 01 00 00 28 5A A1 00 1C 00 00 00 п*єu–..(ZЎ. ... //"123456" 00A1E7B0 EF 2A BA 75 96 00 4D 00 28 5A A1 00 1C 00 00 00 п*єu–.M.(ZЎ. ... //"12345" 00A220C8 EF 2A BA 75 16 00 00 00 01 00 00 00 07 00 00 00 п*єu......... //"1234" дальше непосредственно его перестановками создается S-Box на 100h шаг2: с S-box 8ю циклами по 20 проходов генерируется по одному байту за проход результируещего клю4а дальше 64байтный клю4 сравнивается с известным эталонным подмена результата не катит, зада4а - узнать нужный пас под известный коне4ный результат(брут также актуален) кто уже имел дело с RC4, просьба истолковать 4то в данном слу4ае будет зашифрованным текстом, а 4то клю4ем(ведь тут юзается шифровка и паралельно дешифровка) если нужно - есть сама прога, примеры паролей\гаммированых клю4ей к ним\дампы S-box
Нашел подходящею тему для своего вопроса, Если не лень, и вы знаете делфи пожалуйста объясните как работает эта прога шифрования RC4, мне надо переписать её на асм, но я понятия не имею что это: Code (Text): var str,str_dec:array[0..MAX_MSG_SIZE-1] of byte; {str,str_dec - массивы в которых лежат сообщения (кодированное и декодированное соответсвенно)} procedure DecodeMessage(leng:integer); //leng - длина закодированного пакета const s:string='text'; //ключ var i,j,sw:byte; KeyLen,k:word; fs:array [0..255] of byte; begin {$R-} KeyLen:=Length(s); j:=0; for i:=0 to 255 do fs[i]:=i; for i:=0 to 255 do begin j:=j+fs[i]+byte(s[(i mod KeyLen)+1]); sw:=fs[i]; fs[i]:=fs[j]; fs[j]:=sw; end; i:=0; j:=0; for k:=0 to (leng-1) do begin i:=i+1; j:=j+fs[i]; sw:=fs[i]; fs[i]:=fs[j]; fs[j]:=sw; sw:=fs[i]+fs[j]; str_dec[k]:=fs[sw] xor str[k]; end; end;
найди на vx.netlux.org в журнале 29A-8 исходники Beagle - он написан на асме и использует этот алгоритм
MSoft, по моему Beagle - это вобще кладезь знаней Perre, а что там сложного? инициализируецо ключ на 255 байтов путем 255 перестановок (зависящих от ключа) масива заполненного индексами элемента. а потом сообщение декодируется с помощью этого массива, при чем во время расшифровки массив опять же перетасовуецо
MSoft Спасибо поищю FreeManCPM "масива заполненного индексами элемента" - Насколько я понял – ключ копируется в массив до тех пор, пока не заполнит весь массив (255 байт), а потом: Берём байт из не кодированной строки, берём байт из массива который мы получили, делаем xor и записываем в в кодированную строку, добавляем смещение по всем трём массивам, и если не вылезли за пределы строки исходных данных повторяем всё с начала ?
Perre, ну очень приблизительно. ключ не копируецо, а задает перестановки, никакого смещения не добавляецо. делаюцо только перестановки массива fs.
ещё не разобрался, но помоему это оно Code (Text): ; Simple RC4 implementation, Peter Gutmann, 21 September 1995. ; This code was written in about 30 minutes as a testbed for an asm.RC4. It ; uses a static data area as the key so it's not terribly practical as it ; stands. In addition, the RC4 algorithm leads to an almost solid block of ; pipeline stalls on anything >= '486, so I wouldn't recommend using it on ; anything except perhaps 8-bit microcontrollers and smart cards. INCLUDE MISC.INC MODULE RC4 PUBLIC _rc4expandKey, _rc4crypt DATA ; The RC4 keying information rc4key DB 256 DUP (?) rc4x DB 0 rc4y DB 0 CODE ; void rc4ExpandKey( unsigned char const *key, int keylen ) _rc4expandKey PROCEDURE push bp mov bp, sp push si push di ; Save register vars les si, [bp+4] ; ES:SI = key mov dx, [bp+8] ; DX = keylen mov dh, dl ; keylenTmp = keylen ; rc4word y = 0; xor ax, ax ; y = 0 sub di, di ; DI = AX as an index register ; for( x = 0; x < 256; x++ ) ; rc4key[ x ] = x; xor bx, bx ; x = 0 @@initLoop: mov rc4key[bx], bl ; rc4key[ x ] = x inc bl ; x++ jnz SHORT @@initLoop ; for( x = 0; x < 256; x++ ) ; { ; sx = rc4key[ x ]; ; y += sx + key[ keypos ]; ; rc4key[ x ] = rc4key[ y ]; ; rc4key[ y ] = sx; ; ; if( ++keypos == keylen ) ; keypos = 0; ; } @@keyLoop: mov cl, rc4key[bx] ; sx = rc4key[ x ] add al, es:[si] ; y += key[ keypos ] add al, cl ; y += sx mov di, ax mov ch, rc4key[di] ; temp = rc4key[ y ] mov rc4key[bx], ch ; rc4key[ x ] = temp mov rc4key[di], cl ; rc4key[ y ] = sx inc si ; ++keypos dec dh ; keylenTmp-- jnz SHORT @@noResetKeypos ; if( !keylenTmp ) sub si, dx ; keypos = 0 mov dh, dl ; keylenTmp = keylen @@noResetKeypos: inc bl ; x++ jnz SHORT @@keyLoop ; rc4->x = rc4->y = 0; mov rc4x, bl ; rc4->x = 0 mov rc4y, bl ; rc4->y = 0 pop di pop si ; Restore register vars pop bp ret _rc4expandKey ENDP ; void rc4Crypt( unsigned char *data, int len ) _rc4crypt PROCEDURE push bp mov bp, sp push si push di ; Save register vars les si, [bp+4] ; ES:SI = data mov dx, [bp+8] ; DX = len test dx, dx ; Check that len != 0 jz SHORT @@exit ; Yes, exit now xor bx, bx mov bl, rc4x ; BX = rc4x xor ax, ax mov al, rc4y ; AX = rc4y xor di, di ; DI = AX as an index register ; while( len-- ) ; { ; x++; ; sx = rc4key[ x ]; ; y += sx; ; sy = rc4key[ y ]; ; rc4key[ y ] = sx; ; rc4key[ x ] = sy; ; *data++ ^= rc4key[ ( sx + sy ) & 0xFF ]; ; } @@rc4loop: inc bl ; x++ mov cl, rc4key[bx] ; sx = rc4key[ x ] add al, cl ; y += sx mov di, ax mov ch, rc4key[di] ; sy = rc4key[ y ] mov rc4key[di], cl ; rc4key[ y ] = sx mov rc4key[bx], ch ; rc4key[ x ] = sy add cl, ch xor ch, ch mov di, cx ; temp = ( sx + sy ) & 0xFF mov cl, rc4key[di] xor es:[si], cl ; *data ^= rc4key[ temp ] inc si ; data++ dec dx ; len-- jnz SHORT @@rc4loop mov rc4x, bl mov rc4y, al ; Remember x and y values @@exit: pop di pop si ; Restore register vars pop bp ret _rc4crypt ENDP ENDMODULE
и для 64х разрядных Code (Text): format MS64 COFF include '%fasminc%\win32a.inc' public rc4_prepare_key as 'rc4_prepare_key' public rc4_crypt as 'rc4_crypt' struct rc4_key state rb 256 x db ? y db ? ends rc4_prepare_key: ; u_char *key_data, int key_len, rc4_key *key push rbx mov [r8+rc4_key.x], 0 mov [r8+rc4_key.y], 0 mov ebx, edx ; create initial state xor r11, r11 @@: mov byte [r8+r11], r11b inc r11 cmp r11, 255 jbe @B ; r9 - idx1, r10 - idx2 xor r9, r9 xor r10, r10 ; mix state and key data xor r11, r11 @@: add r10b, byte [rcx+r9] ; idx2 += key_data[idx1] mov al, byte [r8+r11] ; t = state[num] add r10b, al ; idx2 += t mov dl, byte [r8+r10] ; z = state[idx2] mov byte [r8+r10], al ; state[idx2] = t mov byte [r8+r11], dl ; state[num] = z lea eax, [r9d+1] ; div bl ; shr eax, 8 ; idx1 = (idx1 + 1) % key_len; mov r9b, al ; inc r11 cmp r11, 255 jbe @B pop rbx ret rc4_crypt: ; u_char *buf, int len, rc4_key *key ; load params movzx r9, byte [r8+rc4_key.x] movzx r10, byte [r8+rc4_key.y] xor rax, rax ; crypt loop @@: inc r9b ; x++ mov al, byte [r8+r9] ; t = state[x] add r10b, al ; y += t mov r11b, byte [r8+r10] ; z = state[y] mov byte [r8+r9], r11b ; state[x] = z mov byte [r8+r10], al ; state[y] = t add al, r11b ; idx = t+z mov al, byte [r8+rax] ; xor byte [rcx], al ; *buf ^= state[idx] inc rcx ; buf++ dec rdx ; len-- jnz @B ; store params mov byte [r8+rc4_key.x], r9b mov byte [r8+rc4_key.y], r10b ret
FreeManCPM а что, найти алгоритм щас сложно? на васме лежит исходник. cryptohash назиывается - там и RC4 для 32 рализован. Или тут о другом говорят?
Да таблицы не самое сложное. Меня щас пугает расширение ключа. Я думал, первоначально обычный ключ расширяетс по строкам. Т.е. первые 4 байта начального ключа - первая строка расширенного. Однако в одной статье прочитал, что первый 4 байта оригинального - первый столбец расширенного. Вот щас медитирую, не напутал ли чего-нибудь с массивами ранее... и еще голова болит, как это на асме написать
