home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / crypl200.zip / RC / RC4.ASM < prev    next >
Assembly Source File  |  1995-10-11  |  3KB  |  138 lines
  1. ; Simple RC4 implementation, Peter Gutmann, 21 September 1995.
  2. ; This code was written in about 30 minutes as a testbed for an asm.RC4.  It
  3. ; uses a static data area as the key so it's not terribly practical as it
  4. ; stands.  In addition, the RC4 algorithm leads to an almost solid block of
  5. ; pipeline stalls on anything >= '486, so I wouldn't recommend using it on
  6. ; anything except perhaps 8-bit microcontrollers and smart cards.
  7.  
  8.         INCLUDE MISC.INC
  9.         MODULE RC4
  10.  
  11.         PUBLIC _rc4expandKey, _rc4crypt
  12.  
  13.         DATA
  14.  
  15. ; The RC4 keying information
  16.  
  17. rc4key    DB        256 DUP (?)
  18. rc4x    DB        0
  19. rc4y    DB        0
  20.  
  21.         CODE
  22.  
  23. ; void rc4ExpandKey( unsigned char const *key, int keylen )
  24.  
  25. _rc4expandKey PROCEDURE
  26.     push bp
  27.     mov bp, sp
  28.     push si
  29.     push di                            ; Save register vars
  30.     les si, [bp+4]                    ; ES:SI = key
  31.     mov dx, [bp+8]                    ; DX = keylen
  32.     mov dh, dl                        ; keylenTmp = keylen
  33.  
  34.     ; rc4word y = 0;
  35.     xor ax, ax                        ; y = 0
  36.     sub di, di                        ; DI = AX as an index register
  37.  
  38.     ; for( x = 0; x < 256; x++ )
  39.     ;    rc4key[ x ] = x;
  40.     xor bx, bx                        ; x = 0
  41. @@initLoop:
  42.     mov rc4key[bx], bl                ; rc4key[ x ] = x
  43.     inc bl                            ; x++
  44.     jnz SHORT @@initLoop
  45.  
  46.     ; for( x = 0; x < 256; x++ )
  47.     ;    {
  48.     ;    sx = rc4key[ x ];
  49.     ;    y += sx + key[ keypos ];
  50.     ;    rc4key[ x ] = rc4key[ y ];
  51.     ;    rc4key[ y ] = sx;
  52.     ;
  53.     ;    if( ++keypos == keylen )
  54.     ;        keypos = 0;
  55.     ;    }
  56. @@keyLoop:
  57.     mov cl, rc4key[bx]                ; sx = rc4key[ x ]
  58.     add al, es:[si]                    ; y += key[ keypos ]
  59.     add al, cl                        ; y += sx
  60.     mov di, ax
  61.     mov ch, rc4key[di]                ; temp = rc4key[ y ]
  62.     mov rc4key[bx], ch                ; rc4key[ x ] = temp
  63.     mov rc4key[di], cl                ; rc4key[ y ] = sx
  64.     inc si                            ; ++keypos
  65.     dec dh                            ; keylenTmp--
  66.     jnz SHORT @@noResetKeypos        ; if( !keylenTmp )
  67.     sub si, dx                        ; keypos = 0
  68.     mov dh, dl                        ; keylenTmp = keylen
  69. @@noResetKeypos:
  70.     inc bl                            ; x++
  71.     jnz SHORT @@keyLoop
  72.  
  73.     ; rc4->x = rc4->y = 0;
  74.     mov rc4x, bl                    ; rc4->x = 0
  75.     mov rc4y, bl                    ; rc4->y = 0
  76.  
  77.     pop di
  78.     pop si                            ; Restore register vars
  79.     pop bp
  80.     ret
  81. _rc4expandKey ENDP
  82.  
  83. ; void rc4Crypt( unsigned char *data, int len )
  84.  
  85. _rc4crypt PROCEDURE
  86.     push bp
  87.     mov bp, sp
  88.     push si
  89.     push di                            ; Save register vars
  90.     les si, [bp+4]                    ; ES:SI = data
  91.     mov dx, [bp+8]                    ; DX = len
  92.     test dx, dx                        ; Check that len != 0
  93.     jz SHORT @@exit                    ; Yes, exit now
  94.  
  95.     xor bx, bx
  96.     mov bl, rc4x                    ; BX = rc4x
  97.     xor ax, ax
  98.     mov al, rc4y                    ; AX = rc4y
  99.     xor di, di                        ; DI = AX as an index register
  100.  
  101.     ; while( len-- )
  102.     ;    {
  103.     ;    x++;
  104.     ;    sx = rc4key[ x ];
  105.     ;    y += sx;
  106.     ;    sy = rc4key[ y ];
  107.     ;    rc4key[ y ] = sx;
  108.     ;    rc4key[ x ] = sy;
  109.     ;    *data++ ^= rc4key[ ( sx + sy ) & 0xFF ];
  110.     ;    }
  111. @@rc4loop:
  112.     inc bl                            ; x++
  113.     mov cl, rc4key[bx]                ; sx = rc4key[ x ]
  114.     add al, cl                        ; y += sx
  115.     mov di, ax
  116.     mov ch, rc4key[di]                ; sy = rc4key[ y ]
  117.     mov rc4key[di], cl                ; rc4key[ y ] = sx
  118.     mov rc4key[bx], ch                ; rc4key[ x ] = sy
  119.     add cl, ch
  120.     xor ch, ch
  121.     mov di, cx                        ; temp = ( sx + sy ) & 0xFF
  122.     mov cl, rc4key[di]
  123.     xor es:[si], cl                    ; *data ^= rc4key[ temp ]
  124.     inc si                            ; data++
  125.     dec dx                            ; len--
  126.     jnz SHORT @@rc4loop
  127.  
  128.     mov rc4x, bl
  129.     mov rc4y, al                    ; Remember x and y values
  130.  
  131. @@exit:
  132.     pop di
  133.     pop si                            ; Restore register vars
  134.     pop bp
  135.     ret
  136. _rc4crypt ENDP
  137. ENDMODULE
  138.