des486.asm

des的变形算法

        and bx,1111000b
        shr edx,4
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx,dx               ;nybble 3
        and bx,1111000b
        shr edx,4
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx,dx               ;nybble 4
        and bx,1111000b
        shr edx,4
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx,dx               ;nybble 5
        and bx,1111000b
        shr edx,4
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx,dx               ;nybble 6
        and bx,1111000b
        shr edx,4
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx,dx               ;nybble 7
        and bx,1111000b
        shr edx,4
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx,dx               ;nybble 8
        and bx,1111000b
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

; do low dword
        mov bx,ax               ;nybble 1
        shl bx,3                ;index * 8
        and bx,1111000b
        shr eax,1
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

@@3:
        mov bx, ax              ;nybble 2
        and bx,1111000b
        shr eax,4               ;next nybble
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx, ax              ;nybble 3
        and bx,1111000b
        shr eax,4               ;next nybble
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx, ax              ;nybble 4
        and bx,1111000b
        shr eax,4               ;next nybble
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx, ax              ;nybble 5
        and bx,1111000b
        shr eax,4               ;next nybble
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx, ax              ;nybble 6
        and bx,1111000b
        shr eax,4               ;next nybble
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx, ax              ;nybble 7
        and bx,1111000b
        shr eax,4               ;next nybble
        or ebp,[si+bx]
        or edi,[si+4+bx]
        add si,8*16

        mov bx, ax              ;nybble 8
        and bx,1111000b
        or ebp,[si+bx]
        or edi,[si+4+bx]

        ret


;----------------------------------------------------------------------
;               void encrypt_block(void);
;            encrypts data in (unsigned char block[8] ),
;            returning it in the same block[].
align 16
proc encrypt_block near
        push si
        push di
        push bp

        mov si, offset p1
        mov edx,dword ptr[block]
        mov eax,dword ptr[block+4]
        call l_permute                  ;returns with output in ebp:edi

        mov eax,edi                     ;f() input is ebp:eax
ifdef TRIPLE_DES
        mov si,[en_keyptr]
else
        mov si,[keyptr]
endif
        add si,7
        mov [loopcount],16              ;yes, this is the full 16 round DES
        jmp short @@1
align 16
@@1:
        mov edx,eax                     ;prepare to operate on right half
        mov ecx,eax                     ;and save it: it becomes left half
        bswap edx                       ;edx has f() input
        sub eax,eax                     ;output gets zero
        mov di,offset sp_table+7*4*64   ;point to combined s & p boxes
        rol edx,3                       ;prepare for E() function

                 ;THE F() FUNCTION (encrypt)
        mov bx,dx               ;nybble 1
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ; (E function)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 2
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ; (E function)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 3
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ; (E function)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 4
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ; (E function)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 5
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ; (E function)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 6
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ; (E function)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 7
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ; (E function)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 8
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble

        xor eax,ebp             ;left half^= f(right half,keytbl[n]);
        add si,16               ;point to next keytable
        mov ebp,ecx             ;old right half becomes new left half
        dec [loopcount]
        jnz @@1

        mov si, offset p2
        mov edx,eax
        mov eax,ebp
        call l_permute
        mov dword ptr[block],ebp
        mov dword ptr[block+4],edi

        pop bp
        pop di
        pop si
        ret
encrypt_block endp
;----------------------------------------------------------------------
align 16
proc decrypt_block near
        push si
        push di
        push bp

        mov si, offset p1
        mov edx,dword ptr[block]        ;get input for l_permute
        mov eax,dword ptr[block+4]
        call l_permute

        mov [loopcount],16              ;yes, this is the full 16 round DES
ifdef TRIPLE_DES
        mov si,[de_keyptr]
else
        mov si,[keyptr]
endif
        add si,15*8+7
        mov eax, edi                    ;ip.L=op.R

align 4
@@1:
        mov edx,eax                     ;f() input is ip.L
        mov ecx,edx                     ;op.R=ip.L
        bswap edx
        sub eax,eax                     ;output gets zero
        mov di,offset sp_table + 7*4*64 ;point to s&p boxes
        rol edx,3                       ;set up bits 32,1,2,3,4,5 shl 2

            ;THE F() FUNCTION (decrypt)
        mov bx,dx               ;nybble 1
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ;(see E Bit-Selection Table)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 2
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ;(see E Bit-Selection Table)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 3
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ;(see E Bit-Selection Table)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 4
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ;(see E Bit-Selection Table)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 5
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ;(see E Bit-Selection Table)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 6
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ;(see E Bit-Selection Table)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 7
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble
        ror edx,4               ;(see E Bit-Selection Table)
        sub di,4*64             ;sizeof(long)*sizeof(table)

        mov bx,dx               ;nybble 8
        xor bl,[si]             ;XOR with key bits
        and bx,11111100b
        dec si
        or eax, [bx+di]         ;set bits for this nybble

        xor eax,ebp                  ;ip.R ^ f(ip.L,keytbl[n]);
        mov ebp,ecx                  ;ip.R=op.R;
        dec [loopcount]
        jnz @@1

        mov si,offset p2                ;set up for inverse permutation
        mov edx,eax                     ;get input
        mov eax,ebp
        call l_permute
        mov dword ptr[block],ebp
        mov dword ptr[block+4],edi

        pop bp
        pop di
        pop si
        ret
decrypt_block endp

align 16
proc mov64 near
 arg dest:dataptr,source:dataptr

        push bp
        mov bp,sp
        push si
        mov si,[source]
        mov bx,[dest]

        mov eax,[si]
        mov [bx],eax
        mov eax,[si+4]
        mov [bx+4],eax
        
        mov ax,bx       ;return with pointer to dest
        pop si
        pop bp
        ret
mov64 endp

align 16
proc xor64 near
; arg dest:dataptr,source:dataptr

        push bp
        mov bp,sp
        push si
        mov si,[source]
        mov bx,[dest]

        mov eax,[si]
        xor [bx],eax
        mov eax,[si+4]
        xor [bx+4],eax

        mov ax,bx       ;return with pointer to dest
        pop si
        pop bp
        ret
xor64 endp

c32seg ends
end