/* md5-asm.S */ /* This file is part of the Crypto-avr-lib/microcrypt-lib. Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ /* * Author: Daniel Otte * License: GPLv3 or later * Date: 2008-11-15 */ .include "avr-asm-macros.S" ;########################################################### ; S-BOX T_table: .hword 0xa478, 0xd76a, 0xb756, 0xe8c7, 0x70db, 0x2420, 0xceee, 0xc1bd, 0x0faf, 0xf57c .hword 0xc62a, 0x4787, 0x4613, 0xa830, 0x9501, 0xfd46, 0x98d8, 0x6980, 0xf7af, 0x8b44 .hword 0x5bb1, 0xffff, 0xd7be, 0x895c, 0x1122, 0x6b90, 0x7193, 0xfd98, 0x438e, 0xa679 .hword 0x0821, 0x49b4, 0x2562, 0xf61e, 0xb340, 0xc040, 0x5a51, 0x265e, 0xc7aa, 0xe9b6 .hword 0x105d, 0xd62f, 0x1453, 0x0244, 0xe681, 0xd8a1, 0xfbc8, 0xe7d3, 0xcde6, 0x21e1 .hword 0x07d6, 0xc337, 0x0d87, 0xf4d5, 0x14ed, 0x455a, 0xe905, 0xa9e3, 0xa3f8, 0xfcef .hword 0x02d9, 0x676f, 0x4c8a, 0x8d2a, 0x3942, 0xfffa, 0xf681, 0x8771, 0x6122, 0x6d9d .hword 0x380c, 0xfde5, 0xea44, 0xa4be, 0xcfa9, 0x4bde, 0x4b60, 0xf6bb, 0xbc70, 0xbebf .hword 0x7ec6, 0x289b, 0x27fa, 0xeaa1, 0x3085, 0xd4ef, 0x1d05, 0x0488, 0xd039, 0xd9d4 .hword 0x99e5, 0xe6db, 0x7cf8, 0x1fa2, 0x5665, 0xc4ac, 0x2244, 0xf429, 0xff97, 0x432a .hword 0x23a7, 0xab94, 0xa039, 0xfc93, 0x59c3, 0x655b, 0xcc92, 0x8f0c, 0xf47d, 0xffef .hword 0x5dd1, 0x8584, 0x7e4f, 0x6fa8, 0xe6e0, 0xfe2c, 0x4314, 0xa301, 0x11a1, 0x4e08 .hword 0x7e82, 0xf753, 0xf235, 0xbd3a, 0xd2bb, 0x2ad7, 0xd391, 0xeb86 #define MD5_init_fast .global md5_init #ifndef MD5_init_fast ;########################################################### ;void md5_init(md5_ctx_t *state) ; param1: (r24,r25) 16-bit pointer to sha256_ctx_t struct in ram ; modifys: Z(r30,r31), X(r25,r26) ; size = 9+5*4 WORDS = 29 WORDS = 58 Bytes md5_init: movw r26, r24 ; (24,25) --> (26,27) load X with param1 ldi r30, lo8(md5_init_vector) ldi r31, hi8(md5_init_vector) ldi r24, 16+4 md5_init_vloop: lpm r0, Z+ st X+, r0 dec r24 brne md5_init_vloop ret md5_init_vector: .hword 0x2301, 0x6745 .hword 0xAB89, 0xEFCD .hword 0xDCFE, 0x98BA .hword 0x5476, 0x1032 .hword 0x0000, 0x0000 #else ;########################################################### .global md5_init_fast ;void md5_init(md5_ctx_t *state) ; param1: (r24,r25) 16-bit pointer to sha256_ctx_t struct in ram ; modifys: r23, r22 ; cycles = 1+16*3+4*2+4 = 1+48+12 = 61 ; size = 1+16*2+4+1 WORDS = 38 WORDS = 76 Bytes md5_init: md5_init_fast: movw r26, r24 ldi r24, 0x01 st X+, r24 ldi r24, 0x23 st X+, r24 ldi r24, 0x45 st X+, r24 ldi r24, 0x67 st X+, r24 ldi r24, 0x89 st X+, r24 ldi r24, 0xAB st X+, r24 ldi r24, 0xCD st X+, r24 ldi r24, 0xEF st X+, r24 ldi r24, 0xFE st X+, r24 ldi r24, 0xDC st X+, r24 ldi r24, 0xBA st X+, r24 ldi r24, 0x98 st X+, r24 ldi r24, 0x76 st X+, r24 ldi r24, 0x54 st X+, r24 ldi r24, 0x32 st X+, r24 ldi r24, 0x10 st X+, r24 st X+, r1 st X+, r1 st X+, r1 st X+, r1 ret #endif ;########################################################### /* static uint32_t md5_F(uint32_t x, uint32_t y, uint32_t z){ return ((x&y)|((~x)&z)); } */ ; x: r22-r25 ; y: r18-r21 ; z: r14-r17 md5_F: and r18, r22 and r19, r23 and r20, r24 and r21, r25 com r22 com r23 com r24 com r25 and r22, r14 and r23, r15 and r24, r16 and r25, r17 or r22, r18 or r23, r19 or r24, r20 or r25, r21 rjmp md5_core_F_exit /* static uint32_t md5_G(uint32_t x, uint32_t y, uint32_t z){ return ((x&z)|((~z)&y)); } */ ; x: r22-r25 ; y: r18-r21 ; z: r14-r17 md5_G: and r22, r14 and r23, r15 and r24, r16 and r25, r17 com r14 com r15 com r16 com r17 and r18, r14 and r19, r15 and r20, r16 and r21, r17 or r22, r18 or r23, r19 or r24, r20 or r25, r21 rjmp md5_core_F_exit /* static uint32_t md5_H(uint32_t x, uint32_t y, uint32_t z){ return (x^y^z); } */ ; x: r22-r25 ; y: r18-r21 ; z: r14-r17 md5_H: eor r22, r18 eor r22, r14 eor r23, r19 eor r23, r15 eor r24, r20 eor r24, r16 eor r25, r21 eor r25, r17 rjmp md5_core_F_exit /* static uint32_t md5_I(uint32_t x, uint32_t y, uint32_t z){ return (y ^ (x | (~z))); } */ jump_table: rjmp md5_F rjmp md5_G rjmp md5_H ; rjmp md5_I ; x: r22-r25 ; y: r18-r21 ; z: r14-r17 md5_I: com r14 com r15 com r16 com r17 or r22, r14 or r23, r15 or r24, r16 or r25, r17 eor r22, r18 eor r23, r19 eor r24, r20 eor r25, r21 rjmp md5_core_F_exit as_table: ; (as+0)&3 (as+3)&3 (as+1)&3 (as+2)&3 ; Z X Y ; AS_SAVE0 AS_SAVE1 AS_SAVE2 AS_SAVE3 .byte 1*4, 0*4, 2*4, 3*4 ;as=1 .byte 2*4, 1*4, 3*4, 0*4 ;as=2 .byte 3*4, 2*4, 0*4, 1*4 ;as=3 .byte 0*4, 3*4, 1*4, 2*4 ;as=4 ;########################################################### .global md5_core md5_core: mov r21, r20 mov r20, r18 mov r19, r16 mov r18, r14 ; rjmp md5_core_asm /* void md5_core(uint32_t* a, void* block, uint8_t as, uint8_t s, uint8_t i, uint8_t fi){ uint32_t t; md5_func_t* funcs[]={md5_F, md5_G, md5_H, md5_I}; as &= 0x3; / * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). * / t = a[as] + funcs[fi](a[(as+1)&3], a[(as+2)&3], a[(as+3)&3]) + *((uint32_t*)block) + md5_T[i] ; a[as]=a[(as+1)&3] + ROTL32(t, s); } */ ; a: r24-r25 ; block: r22-r23 ; as: r21 ; s: r20 ; i: r19 ; fi: r18 P_A0 = 24 P_A1 = 25 P_B0 = 22 P_B1 = 23 P_AS = 21 P_S = 20 P_I = 19 P_FI = 18 ; x: r22-r25 ; y: r18-r21 ; z: r14-r17 AS_SAVE0 = 4 AS_SAVE1 = 5 AS_SAVE2 = 6 AS_SAVE3 = 7 FI_SAVE = 8 S_SAVE = 9 ACCU0 = 10 ACCU1 = 11 ACCU2 = 12 ACCU3 = 13 ARG_X0 = 22 ARG_X1 = 23 ARG_X2 = 24 ARG_X3 = 25 ARG_Y0 = 18 ARG_Y1 = 19 ARG_Y2 = 20 ARG_Y3 = 21 ARG_Z0 = 14 ARG_Z1 = 15 ARG_Z2 = 16 ARG_Z3 = 17 md5_core_asm: push r28 push r29 push_range 4, 17 ldi r30, lo8(T_table) ldi r31, hi8(T_table) lsl P_I rol r1 lsl P_I rol r1 add r30, P_I adc r31, r1 clr r1 mov FI_SAVE, r18 /* loading T[i] into ACCU */ lpm ACCU0, Z+ lpm ACCU1, Z+ lpm ACCU2, Z+ lpm ACCU3, Z /* add *block to ACCU */ movw r30, P_B0 ld r0, Z+ add ACCU0, r0 ld r0, Z+ adc ACCU1, r0 ld r0, Z+ adc ACCU2, r0 ld r0, Z+ adc ACCU3, r0 /* add a[as+0&3] to ACCU */ ldi r30, lo8(as_table) ldi r31, hi8(as_table) dec P_AS andi P_AS, 0x03 lsl P_AS lsl P_AS add r30, r21 adc r31, r1 ; Z points to the correct row in as_table lpm AS_SAVE0, Z+ lpm AS_SAVE1, Z+ lpm AS_SAVE2, Z+ lpm AS_SAVE3, Z movw r26, r24 ; X points to a[0] add r26, AS_SAVE0 adc r27, r1 ; X points at a[as&3] ld r0, X+ add ACCU0, r0 ld r0, X+ adc ACCU1, r0 ld r0, X+ adc ACCU2, r0 ld r0, X+ adc ACCU3, r0 mov S_SAVE, r20 movw r28, r24 /* loading z value */ movw r26, r28 add r26, AS_SAVE1 adc r27, r1 ld ARG_Z0, X+ ld ARG_Z1, X+ ld ARG_Z2, X+ ld ARG_Z3, X /* loading x value */ movw r26, r28 add r26, AS_SAVE2 adc r27, r1 ld ARG_X0, X+ ld ARG_X1, X+ ld ARG_X2, X+ ld ARG_X3, X /* loading y value */ movw r26, r28 add r26, AS_SAVE3 adc r27, r1 ldi r30, pm_lo8(jump_table) ldi r31, pm_hi8(jump_table) add r30, FI_SAVE adc r31, r1 ; Z points to the correct entry in our jump table ld ARG_Y0, X+ ld ARG_Y1, X+ ld ARG_Y2, X+ ld ARG_Y3, X ijmp /* calls the function pointed by Z */ md5_core_F_exit: /* add ACCU to result of f() */ add r22, ACCU0 adc r23, ACCU1 adc r24, ACCU2 adc r25, ACCU3 /* rotate */ mov r20, S_SAVE rotl32: cpi r20, 8 brlo bitrotl mov r21, r25 mov r25, r24 mov r24, r23 mov r23, r22 mov r22, r21 subi r20, 8 rjmp rotl32 bitrotl: mov r21, r25 bitrotl_loop: tst r20 breq fixrotl bitrotl_loop2: lsl r21 rol r22 rol r23 rol r24 rol r25 dec r20 brne bitrotl_loop2 fixrotl: /* add a[(as+1)&3] */ movw r26, r28 add r26, AS_SAVE2 adc r27, r1 ld r0, X+ add r22, r0 ld r0, X+ adc r23, r0 ld r0, X+ adc r24, r0 ld r0, X adc r25, r0 /* store result */ movw r26, r28 add r26, AS_SAVE0 adc r27, r1 st X+, r22 st X+, r23 st X+, r24 st X , r25 md5_core_exit: pop_range 4, 17 pop r29 pop r28 ret ;################################################################### /* void md5_nextBlock(md5_ctx_t *state, void* block){ uint32_t a[4]; uint8_t m,n,i=0; a[0]=state->a[0]; a[1]=state->a[1]; a[2]=state->a[2]; a[3]=state->a[3]; / * round 1 * / uint8_t s1t[]={7,12,17,22}; // 1,-1 1,4 2,-1 3,-2 for(m=0;m<4;++m){ for(n=0;n<4;++n){ md5_core(a, &(((uint32_t*)block)[m*4+n]), 4-n, s1t[n],i++,0); } } / * round 2 * / uint8_t s2t[]={5,9,14,20}; // 1,-3 1,1 2,-2 2,4 for(m=0;m<4;++m){ for(n=0;n<4;++n){ md5_core(a, &(((uint32_t*)block)[(1+m*4+n*5)&0xf]), 4-n, s2t[n],i++,1); } } / * round 3 * / uint8_t s3t[]={4,11,16,23}; // 0,4 1,3 2,0 3,-1 for(m=0;m<4;++m){ for(n=0;n<4;++n){ md5_core(a, &(((uint32_t*)block)[(5-m*4+n*3)&0xf]), 4-n, s3t[n],i++,2); } } / * round 4 * / uint8_t s4t[]={6,10,15,21}; // 1,-2 1,2 2,-1 3,-3 for(m=0;m<4;++m){ for(n=0;n<4;++n){ md5_core(a, &(((uint32_t*)block)[(0-m*4+n*7)&0xf]), 4-n, s4t[n],i++,3); } } state->a[0] += a[0]; state->a[1] += a[1]; state->a[2] += a[2]; state->a[3] += a[3]; state->counter++; } */ /* shift_table: .byte 7,12,17,22 .byte 5, 9,14,20 .byte 4,11,16,23 .byte 6,10,15,21 md5_nextBlock: stack_alloc 4*4 stack_free 4*4 */