aesctre.asm

AES高级加密标准的C代码

    mov		ebp,[esp+eax+key]		; offset to key
    mov		ecx,[ebp]				; load 128 bit key into
    mov		edx,[ebp+4]				; four 32-bit words
    mov		esi,[ebp+8]
    mov		edi,[ebp+12]
    mov		[esp+exp_key],ecx		; store key into expanded
    mov		[esp+exp_key+4],edx		; key schedule on the stack
    mov		[esp+exp_key+8],esi
    mov		[esp+exp_key+12],edi
    mov		eax,edi					; eax must contain the last 32-bit
                                    ; word key from the previous round
    step_key   1, 16
    step_key   2, 16
    step_key   3, 16
    step_key   4, 16
    step_key   5, 16
    step_key   6, 16
    step_key   7, 16
    step_key   8, 16
    step_key   9, 16
    step_key  10, 16
    mov		ebp,[esp+stk_offset]	; pointer to parameters
    add		ebp,esp
    cmp		[ebp+n_block],dword 0	; number of blocks to encrypt
    je		.1						; exit if none

.0: mov     esi,[ebp+ctr]           ; load ctr into eax, ebx, ecx
    mov		eax,[esi]				; and edx.  Increment the 
    mov		edx,[esi+12]			; counter after the load
    mov		ecx,edx
%ifdef  BIG_ENDIAN_CTR    
    bswap	ecx
%endif
    inc		ecx
%ifdef  BIG_ENDIAN_CTR    
    bswap	ecx
%endif
    mov		[esi+12],ecx
    mov		ebx,[esi+4]				; and edx and increment the 
    mov		ecx,[esi+8]				; counter after the load 
    xor		eax,[esp+exp_key]
    xor		ebx,[esp+exp_key+4]
    xor		ecx,[esp+exp_key+8]
    xor		edx,[esp+exp_key+12]
    
    round   0						; do 10 rounds for 128-bit key
    round   1
    round   2
    round   3
    round   4
    round   5
    round   6
    round   7
    round   8
    last_round 9

    mov		ebp,[esp+stk_offset]	; recover output buffer pointer
    add		ebp,esp

    mov     esi,[ebp+in_blk]        ; xor the current input block and
    xor		eax,[esi]				; the key into eax, ebx, ecx and edx
    xor		ebx,[esi+4]
    xor		ecx,[esi+8]
    xor		edx,[esi+12]
    add		esi,16					; increment and store input
    mov		[ebp+in_blk],esi		; pointer
    
    mov		esi,[ebp+out_blk]
    mov		[esi],eax				; store result to the output
    mov		[esi+4],ebx				; buffer
    mov		[esi+8],ecx
    mov		[esi+12],edx
    add		esi,16
    mov		[ebp+out_blk],esi		; increment and store new buffer
    dec		dword [ebp+n_block]		; pointer
    jne		.0

.1: mov     eax,[esp+stk_offset]
    mov     edi,[esp+edi_save]
    mov     esi,[esp+esi_save]
    mov     ebx,[esp+ebx_save]
    mov     ebp,[esp+ebp_save]
    add     esp,eax
    do_exit
ctr_128_end:

%endif

; AES Encryption Subroutine (192 bit key)

%ifdef AES_192

%assign rc_val                  1   ; start value for the round constant
%assign exp_key                 0   ; stack offset to expanded key
%assign ks_len            13 * 16   ; length of expanded key
%assign ebx_save           ks_len
%assign edi_save     ebx_save + 4
%assign esi_save     edi_save + 4
%assign ebp_save     esi_save + 4
%assign stk_offset   ebp_save + 4   ; stack offset used to avoid cache conflicts
%assign stx_spc       ks_len + 32   ; stack space needed for locals

    do_name _aes_ctr_encrypt_192

    mov      eax,esp				; use Daniel Bernstein's technique for
    sub      eax,_aes_etab			; positioning stack based variables
    and      eax,4095
    add      eax,stx_spc
    sub      esp,eax

    mov		[esp+stk_offset],eax	; save stack offset
    mov     [esp+ebp_save],ebp
    mov     [esp+ebx_save],ebx
    mov     [esp+esi_save],esi
    mov     [esp+edi_save],edi

    mov		ebp,[esp+eax+key]
    mov		ecx,[ebp]
    mov		edx,[ebp+4]
    mov		esi,[ebp+8]
    mov		edi,[ebp+12]
    mov		[esp+exp_key],ecx
    mov		[esp+exp_key+4],edx
    mov		[esp+exp_key+8],esi
    mov		[esp+exp_key+12],edi
    mov		eax,[ebp+16]
    mov		[esp+exp_key+16],eax
    mov		eax,[ebp+20]
    mov		[esp+exp_key+20],eax

    step_key  1, 24
    step_key  2, 24
    step_key  3, 24
    step_key  4, 24
    step_key  5, 24
    step_key  6, 24
    step_key  7, 24
    step_key  8, 24
    mov		ebp,[esp+stk_offset]
    add		ebp,esp
    cmp		[ebp+n_block],dword 0
    je		.1

.0: mov     esi,[ebp+ctr]           ; load ctr into eax, ebx, ecx
    mov		eax,[esi]				; and edx.  Increment the 
    mov		edx,[esi+12]			; counter after the load
    mov		ecx,edx
%ifdef  BIG_ENDIAN_CTR    
    bswap	ecx
%endif
    inc		ecx
%ifdef  BIG_ENDIAN_CTR    
    bswap	ecx
%endif
    mov		[esi+12],ecx
    mov		ebx,[esi+4]				; and edx and increment the 
    mov		ecx,[esi+8]				; counter after the load 
    xor		eax,[esp+exp_key]
    xor		ebx,[esp+exp_key+4]
    xor		ecx,[esp+exp_key+8]
    xor		edx,[esp+exp_key+12]

    round   0
    round   1
    round   2
    round   3
    round   4
    round   5
    round   6
    round   7
    round   8
    round   9
    round   10
    last_round 11

    mov		ebp,[esp+stk_offset]	; recover output buffer pointer
    add		ebp,esp

    mov     esi,[ebp+in_blk]        ; xor the current input block and
    xor		eax,[esi]				; the key into eax, ebx, ecx and edx
    xor		ebx,[esi+4]
    xor		ecx,[esi+8]
    xor		edx,[esi+12]
    add		esi,16					; increment and store input
    mov		[ebp+in_blk],esi		; pointer
    
    mov		esi,[ebp+out_blk]
    mov		[esi],eax				; store result to the output
    mov		[esi+4],ebx				; buffer
    mov		[esi+8],ecx
    mov		[esi+12],edx
    add		esi,16
    mov		[ebp+out_blk],esi		; increment and store new buffer
    dec		dword [ebp+n_block]		; pointer
    jne		.0

.1: mov     eax,[esp+stk_offset]
    mov     edi,[esp+edi_save]
    mov     esi,[esp+esi_save]
    mov     ebx,[esp+ebx_save]
    mov     ebp,[esp+ebp_save]
    add     esp,eax
    do_exit
ctr_192_end:

%endif

; AES Encryption Subroutine (256 bit key)

%ifdef AES_256

%assign rc_val                  1   ; start value for the round constant
%assign exp_key                 0   ; stack offset to expanded key
%assign ks_len            15 * 16   ; length of expanded key (128 bits)
%assign ebx_save           ks_len
%assign edi_save     ebx_save + 4
%assign esi_save     edi_save + 4
%assign ebp_save     esi_save + 4
%assign stk_offset   ebp_save + 4   ; stack offset used to avoid cache conflicts
%assign stx_spc       ks_len + 32   ; stack space needed for locals

    do_name _aes_ctr_encrypt_256

    mov      eax,esp				; use Daniel Bernstein's technique for
    sub      eax,_aes_etab			; positioning stack based variables
    and      eax,4095
    add      eax,stx_spc
    sub      esp,eax

    mov		[esp+stk_offset],eax	; save stack offset
    mov     [esp+ebp_save],ebp
    mov     [esp+ebx_save],ebx
    mov     [esp+esi_save],esi
    mov     [esp+edi_save],edi

    mov		ebp,[esp+eax+key]
    mov		ecx,[ebp]
    mov		edx,[ebp+4]
    mov		esi,[ebp+8]
    mov		edi,[ebp+12]
    mov		[esp+exp_key],ecx
    mov		[esp+exp_key+4],edx
    mov		[esp+exp_key+8],esi
    mov		[esp+exp_key+12],edi
    mov		eax,[ebp+16]
    mov		[esp+exp_key+16],eax
    mov		eax,[ebp+20]
    mov		[esp+exp_key+20],eax
    mov		eax,[ebp+24]
    mov		[esp+exp_key+24],eax
    mov		eax,[ebp+28]
    mov		[esp+exp_key+28],eax

    step_key  1, 32
    step_key  2, 32
    step_key  3, 32
    step_key  4, 32
    step_key  5, 32
    step_key  6, 32
    step_key  7, 32
    mov		ebp,[esp+stk_offset]
    add		ebp,esp
    cmp		[ebp+n_block],dword 0
    je		.1

.0: mov     esi,[ebp+ctr]           ; load ctr into eax, ebx, ecx
    mov		eax,[esi]				; and edx.  Increment the 
    mov		edx,[esi+12]			; counter after the load
    mov		ecx,edx
%ifdef  BIG_ENDIAN_CTR    
    bswap	ecx
%endif
    inc		ecx
%ifdef  BIG_ENDIAN_CTR    
    bswap	ecx
%endif
    mov		[esi+12],ecx
    mov		ebx,[esi+4]				; and edx and increment the 
    mov		ecx,[esi+8]				; counter after the load 
    xor		eax,[esp+exp_key]
    xor		ebx,[esp+exp_key+4]
    xor		ecx,[esp+exp_key+8]
    xor		edx,[esp+exp_key+12]
    round   0
    round   1
    round   2
    round   3
    round   4
    round   5
    round   6
    round   7
    round   8
    round   9
    round   10
    round   11
    round   12
    last_round 13

    mov		ebp,[esp+stk_offset]	; recover output buffer pointer
    add		ebp,esp

    mov     esi,[ebp+in_blk]        ; xor the current input block and
    xor		eax,[esi]				; the key into eax, ebx, ecx and edx
    xor		ebx,[esi+4]
    xor		ecx,[esi+8]
    xor		edx,[esi+12]
    add		esi,16					; increment and store input
    mov		[ebp+in_blk],esi		; pointer
    
    mov		esi,[ebp+out_blk]
    mov		[esi],eax				; store result to the output
    mov		[esi+4],ebx				; buffer
    mov		[esi+8],ecx
    mov		[esi+12],edx
    add		esi,16
    mov		[ebp+out_blk],esi		; increment and store new buffer
    dec		dword [ebp+n_block]		; pointer
    jne		.0

.1: mov     eax,[esp+stk_offset]
    mov     edi,[esp+edi_save]
    mov     esi,[esp+esi_save]
    mov     ebx,[esp+ebx_save]
    mov     ebp,[esp+ebp_save]
    add     esp,eax
    do_exit
ctr_256_end:

%endif

%ifdef REPORT_LENGTH

    do_name _aes_ctr_128_len
    mov		eax,ctr_128_end - _aes_ctr_encrypt_128
    do_exit
    do_name _aes_ctr_192_len
    mov		eax,ctr_192_end - _aes_ctr_encrypt_192
    do_exit
    do_name _aes_ctr_256_len
    mov		eax,ctr_256_end - _aes_ctr_encrypt_256
    do_exit

%endif

    end