firmware/sha1-asm.S

   1 /* sha1-asm.S */
   2 /*
   3     This file is part of the AVR-Crypto-Lib.
   4     Copyright (C) 2008  Daniel Otte (daniel.otte@rub.de)
   5
   6     This program is free software: you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation, either version 3 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19 /*
  20  * Author:      Daniel Otte
  21  *
  22  * License: GPLv3 or later
  23 */
  24 ; SHA1 implementation in assembler for AVR
  25 SHA1_BLOCK_BITS = 512
  26 SHA1_HASH_BITS = 160
  27
  28 .macro precall
  29         /* push r18 - r27, r30 - r31*/
  30         push r0
  31         push r1
  32         push r18
  33         push r19
  34         push r20
  35         push r21
  36         push r22
  37         push r23
  38         push r24
  39         push r25
  40         push r26
  41         push r27
  42         push r30
  43         push r31
  44         clr r1
  45 .endm
  46
  47 .macro postcall
  48         pop r31
  49         pop r30
  50         pop r27
  51         pop r26
  52         pop r25
  53         pop r24
  54         pop r23
  55         pop r22
  56         pop r21
  57         pop r20
  58         pop r19
  59         pop r18
  60         pop r1
  61         pop r0
  62 .endm
  63
  64
  65 .macro hexdump length
  66         push r27
  67         push r26
  68         ldi r25, '\r'
  69         mov r24, r25
  70         call uart_putc
  71         ldi r25, '\n'
  72         mov r24, r25
  73         call uart_putc
  74         pop r26
  75         pop r27
  76         movw r24, r26
  77 .if \length > 16
  78         ldi r22, lo8(16)
  79         ldi r23, hi8(16)
  80         push r27
  81         push r26
  82         call uart_hexdump
  83         pop r26
  84         pop r27
  85         adiw r26, 16
  86         hexdump \length-16
  87 .else
  88         ldi r22, lo8(\length)
  89         ldi r23, hi8(\length)
  90         call uart_hexdump
  91 .endif
  92 .endm
  93
  94 .macro delay
  95 /*
  96         push r0
  97         push r1
  98         clr r0
  99 1:      clr r1
 100 2:      dec r1
 101         brne 2b
 102         dec r0
 103         brne 1b
 104         pop r1
 105         pop r0  // */
 106 .endm
 107
 108 /* X points to Block */
 109 .macro dbg_hexdump length
 110 /*
 111         precall
 112         hexdump \length
 113         postcall
 114         // */
 115 .endm
 116
 117
 118
 119 .section .text
 120
 121 SPL = 0x3D
 122 SPH = 0x3E
 123 SREG = 0x3F
 124
 125
 126 ;
 127 ;sha1_ctx_t is:
 128 ;
 129 ; [h0][h1][h2][h3][h4][length]
 130 ; hn is 32 bit large, length is 64 bit large
 131
 132 ;###########################################################
 133
 134 .global sha1_ctx2hash
 135 ; === sha1_ctx2hash ===
 136 ; this function converts a state into a normal hash (bytestring)
 137 ;  param1: the 16-bit destination pointer
 138 ;       given in r25,r24 (r25 is most significant)
 139 ;  param2: the 16-bit pointer to sha1_ctx structure
 140 ;       given in r23,r22
 141 sha1_ctx2hash:
 142         movw r26, r22
 143         movw r30, r24
 144         ldi r21, 5
 145         sbiw r26, 4
 146 1:
 147         ldi r20, 4
 148         adiw r26, 8
 149 2:
 150                 ld r0, -X
 151                 st Z+, r0
 152         dec r20
 153         brne 2b
 154
 155         dec r21
 156         brne 1b
 157
 158         ret
 159
 160 ;###########################################################
 161
 162 .global sha1
 163 ; === sha1 ===
 164 ; this function calculates SHA-1 hashes from messages in RAM
 165 ;  param1: the 16-bit hash destination pointer
 166 ;       given in r25,r24 (r25 is most significant)
 167 ;  param2: the 16-bit pointer to message
 168 ;       given in r23,r22
 169 ;  param3: 32-bit length value (length of message in bits)
 170 ;   given in r21,r20,r19,r18
 171 sha1:
 172 sha1_prolog:
 173         push r8
 174         push r9
 175         push r10
 176         push r11
 177         push r12
 178         push r13
 179         push r16
 180         push r17
 181         in r30, SPL
 182         in r31, SPH
 183         sbiw r30, 5*4+8
 184         in r0, SREG
 185         cli
 186         out SPL, r30
 187         out SREG, r0
 188         out SPH, r31
 189
 190         push r25
 191         push r24
 192         adiw r30, 1
 193         movw r16, r30
 194
 195         movw r8, r18            /* backup of length*/
 196         movw r10, r20
 197
 198         movw r12, r22   /* backup pf msg-ptr */
 199
 200         movw r24, r16
 201         rcall sha1_init
 202         /* if length >= 512 */
 203 1:
 204         tst r11
 205         brne 2f
 206         tst r10
 207         breq 4f
 208 2:
 209         movw r24, r16
 210         movw r22, r12
 211         rcall sha1_nextBlock
 212         ldi r19, 64
 213         add r12, r19
 214         adc r13, r1
 215         /* length -= 512 */
 216         ldi r19, 0x02
 217         sub r9, r19
 218         sbc r10, r1
 219         sbc r11, r1
 220         rjmp 1b
 221
 222 4:
 223         movw r24, r16
 224         movw r22, r12
 225         movw r20, r8
 226         rcall sha1_lastBlock
 227
 228         pop r24
 229         pop r25
 230         movw r22, r16
 231         rcall sha1_ctx2hash
 232
 233 sha1_epilog:
 234         in r30, SPL
 235         in r31, SPH
 236         adiw r30, 5*4+8
 237         in r0, SREG
 238         cli
 239         out SPL, r30
 240         out SREG, r0
 241         out SPH, r31
 242         pop r17
 243         pop r16
 244         pop r13
 245         pop r12
 246         pop r11
 247         pop r10
 248         pop r9
 249         pop r8
 250         ret
 251
 252 ;###########################################################
 253
 254
 255 ; block MUST NOT be larger than 64 bytes
 256
 257 .global sha1_lastBlock
 258 ; === sha1_lastBlock ===
 259 ; this function does padding & Co. for calculating SHA-1 hashes
 260 ;  param1: the 16-bit pointer to sha1_ctx structure
 261 ;       given in r25,r24 (r25 is most significant)
 262 ;  param2: an 16-bit pointer to 64 byte block to hash
 263 ;       given in r23,r22
 264 ;  param3: an 16-bit integer specifing length of block in bits
 265 ;       given in r21,r20
 266 sha1_lastBlock_localSpace = (SHA1_BLOCK_BITS/8+1)
 267
 268
 269 sha1_lastBlock:
 270         cpi r21, 0x02
 271         brlo sha1_lastBlock_prolog
 272         push r25
 273         push r24
 274         push r23
 275         push r22
 276         push r21
 277         push r20
 278         rcall sha1_nextBlock
 279         pop r20
 280         pop r21
 281         pop r22
 282         pop r23
 283         pop r24
 284         pop r25
 285         subi r21, 2
 286         ldi r19, 64
 287         add r22, r19
 288         adc r23, r1
 289         rjmp sha1_lastBlock
 290 sha1_lastBlock_prolog:
 291         /* allocate space on stack */
 292         in r30, SPL
 293         in r31, SPH
 294         in r0, SREG
 295         subi r30, lo8(64)
 296         sbci r31, hi8(64) /* ??? */
 297         cli
 298         out SPL, r30
 299         out SREG, r0
 300         out SPH, r31
 301
 302         adiw r30, 1 /* SP points to next free byte on stack */
 303         mov r18, r20 /* r20 = LSB(length) */
 304         lsr r18
 305         lsr r18
 306         lsr r18
 307         bst r21, 0      /* may be we should explain this ... */
 308         bld r18, 5  /* now: r18 == length/8 (aka. length in bytes) */
 309
 310
 311         movw r26, r22 /* X points to begin of msg */
 312         tst r18
 313         breq sha1_lastBlock_post_copy
 314         mov r1, r18
 315 sha1_lastBlock_copy_loop:
 316         ld r0, X+
 317         st Z+, r0
 318         dec r1
 319         brne sha1_lastBlock_copy_loop
 320 sha1_lastBlock_post_copy:
 321 sha1_lastBlock_insert_stuffing_bit:
 322         ldi r19, 0x80
 323         mov r0,r19
 324         ldi r19, 0x07
 325         and r19, r20 /* if we are in bitmode */
 326         breq 2f /* no bitmode */
 327 1:
 328         lsr r0
 329         dec r19
 330         brne 1b
 331         ld r19, X
 332 /* maybe we should do some ANDing here, just for safety */
 333         or r0, r19
 334 2:
 335         st Z+, r0
 336         inc r18
 337
 338 /* checking stuff here */
 339         cpi r18, 64-8+1
 340         brsh 0f
 341         rjmp sha1_lastBlock_insert_zeros
 342 0:
 343         /* oh shit, we landed here */
 344         /* first we have to fill it up with zeros */
 345         ldi r19, 64
 346         sub r19, r18
 347         breq 2f
 348 1:
 349         st Z+, r1
 350         dec r19
 351         brne 1b
 352 2:
 353         sbiw r30, 63
 354         sbiw r30,  1
 355         movw r22, r30
 356
 357         push r31
 358         push r30
 359         push r25
 360         push r24
 361         push r21
 362         push r20
 363         rcall sha1_nextBlock
 364         pop r20
 365         pop r21
 366         pop r24
 367         pop r25
 368         pop r30
 369         pop r31
 370
 371         /* now we should subtract 512 from length */
 372         movw r26, r24
 373         adiw r26, 4*5+1 /* we can skip the lowest byte */
 374         ld r19, X
 375         subi r19, hi8(512)
 376         st X+, r19
 377         ldi r18, 6
 378 1:
 379         ld r19, X
 380         sbci r19, 0
 381         st X+, r19
 382         dec r18
 383         brne 1b
 384
 385 ;       clr r18 /* not neccessary ;-) */
 386         /* reset Z pointer to begin of block */
 387
 388 sha1_lastBlock_insert_zeros:
 389         ldi r19, 64-8
 390         sub r19, r18
 391         breq sha1_lastBlock_insert_length
 392         clr r1
 393 1:
 394         st Z+, r1       /* r1 is still zero */
 395         dec r19
 396         brne 1b
 397
 398 ;       rjmp sha1_lastBlock_epilog
 399 sha1_lastBlock_insert_length:
 400         movw r26, r24   /* X points to state */
 401         adiw r26, 5*4   /* X points to (state.length) */
 402         adiw r30, 8             /* Z points one after the last byte of block */
 403         ld r0, X+
 404         add r0, r20
 405         st -Z, r0
 406         ld r0, X+
 407         adc r0, r21
 408         st -Z, r0
 409         ldi r19, 6
 410 1:
 411         ld r0, X+
 412         adc r0, r1
 413         st -Z, r0
 414         dec r19
 415         brne 1b
 416
 417         sbiw r30, 64-8
 418         movw r22, r30
 419         rcall sha1_nextBlock
 420
 421 sha1_lastBlock_epilog:
 422         in r30, SPL
 423         in r31, SPH
 424         in r0, SREG
 425         adiw r30, 63 ; lo8(64)
 426         adiw r30,  1  ; hi8(64)
 427         cli
 428         out SPL, r30
 429         out SREG, r0
 430         out SPH, r31
 431         clr r1
 432         ret
 433
 434 /**/
 435 ;###########################################################
 436
 437 .global sha1_nextBlock
 438 ; === sha1_nextBlock ===
 439 ; this is the core function for calculating SHA-1 hashes
 440 ;  param1: the 16-bit pointer to sha1_ctx structure
 441 ;       given in r25,r24 (r25 is most significant)
 442 ;  param2: an 16-bit pointer to 64 byte block to hash
 443 ;       given in r23,r22
 444 sha1_nextBlock_localSpace = (16+5+1)*4 ; 16 32-bit values for w array and 5 32-bit values for a array (total 84 byte)
 445
 446 xtmp = 0
 447 xNULL = 1
 448 W1 = 10
 449 W2 = 11
 450 T1      = 12
 451 T2      = 13
 452 T3      = 14
 453 T4      = 15
 454 LoopC = 16
 455 S         = 17
 456 tmp1 = 18
 457 tmp2 = 19
 458 tmp3 = 20
 459 tmp4 = 21
 460 F1 = 22
 461 F2 = 23
 462 F3 = 24
 463 F4 = 25
 464
 465 /* byteorder: high number <--> high significance */
 466 sha1_nextBlock:
 467  ; initial, let's make some space ready for local vars
 468                          /* replace push & pop by mem ops? */
 469         push r10
 470         push r11
 471         push r12
 472         push r13
 473         push r14
 474         push r15
 475         push r16
 476         push r17
 477         push r28
 478         push r29
 479         in r20, SPL
 480         in r21, SPH
 481         movw r18, r20                   ;backup SP
 482 ;       movw r26, r20                   ; X points to free space on stack /* maybe removeable? */
 483         movw r30, r22                   ; Z points to message
 484         subi r20, lo8(sha1_nextBlock_localSpace) ;sbiw can do only up to 63
 485         sbci r21, hi8(sha1_nextBlock_localSpace)
 486         movw r26, r20                   ; X points to free space on stack
 487         in r0, SREG
 488         cli ; we want to be uninterrupted while updating SP
 489         out SPL, r20
 490         out SREG, r0
 491         out SPH, r21
 492
 493         push r18
 494         push r19 /* push old SP on new stack */
 495         push r24
 496         push r25 /* param1 will be needed later */
 497
 498         /* load a[] with state */
 499         movw 28, r24 /* load pointer to state in Y */
 500         adiw r26, 1 ; X++
 501
 502         ldi LoopC, 5*4
 503 1:      ld tmp1, Y+
 504         st X+, tmp1
 505         dec LoopC
 506         brne 1b
 507
 508         movw W1, r26 /* save pointer to w[0] */
 509         /* load w[] with endian fixed message */
 510                 /* we might also use the changeendian32() function at bottom */
 511         movw r30, r22 /* mv param2 (ponter to msg) to Z */
 512         ldi LoopC, 16
 513 1:
 514         ldd tmp1, Z+3
 515         st X+, tmp1
 516         ldd tmp1, Z+2
 517         st X+, tmp1
 518         ldd tmp1, Z+1
 519         st X+, tmp1
 520         ld tmp1, Z
 521         st X+, tmp1
 522         adiw r30, 4
 523         dec LoopC
 524         brne 1b
 525
 526         ;clr LoopC /* LoopC is named t in FIPS 180-2 */
 527         clr xtmp
 528 sha1_nextBlock_mainloop:
 529         mov S, LoopC
 530         lsl S
 531         lsl S
 532         andi S, 0x3C /* S is a bytepointer so *4 */
 533         /* load w[s] */
 534         movw r26, W1
 535         add r26, S /* X points at w[s] */
 536         adc r27, xNULL
 537         ld T1, X+
 538         ld T2, X+
 539         ld T3, X+
 540         ld T4, X+
 541
 542 /*
 543         push r26
 544         push r27
 545         push T4
 546         push T3
 547         push T2
 548         push T1
 549         in r26, SPL
 550         in r27, SPH
 551         adiw r26, 1
 552         dbg_hexdump 4
 553         pop T1
 554         pop T2
 555         pop T3
 556         pop T4
 557         pop r27
 558         pop r26
 559 */
 560
 561         cpi LoopC, 16
 562         brlt sha1_nextBlock_mainloop_core
 563         /* update w[s] */
 564         ldi tmp1, 2*4
 565         rcall 1f
 566         ldi tmp1, 8*4
 567         rcall 1f
 568         ldi tmp1, 13*4
 569         rcall 1f
 570         rjmp 2f
 571 1:              /* this might be "outsourced" to save the jump above */
 572         add tmp1, S
 573         andi tmp1, 0x3f
 574         movw r26, W1
 575         add r26, tmp1
 576         adc r27, xNULL
 577         ld tmp2, X+
 578         eor T1, tmp2
 579         ld tmp2, X+
 580         eor T2, tmp2
 581         ld tmp2, X+
 582         eor T3, tmp2
 583         ld tmp2, X+
 584         eor T4, tmp2
 585         ret
 586 2:      /* now we just hav to do a ROTL(T) and save T back */
 587         mov tmp2, T4
 588         rol tmp2
 589         rol T1
 590         rol T2
 591         rol T3
 592         rol T4
 593         movw r26, W1
 594         add r26, S
 595         adc r27, xNULL
 596         st X+, T1
 597         st X+, T2
 598         st X+, T3
 599         st X+, T4
 600
 601 sha1_nextBlock_mainloop_core:   /* ther core function; T=ROTL5(a) ....*/
 602                                                                 /* T already contains w[s] */
 603         movw r26, W1
 604         sbiw r26, 4*1           /* X points at a[4] aka e */
 605         ld tmp1, X+
 606         add T1, tmp1
 607         ld tmp1, X+
 608         adc T2, tmp1
 609         ld tmp1, X+
 610         adc T3, tmp1
 611         ld tmp1, X+
 612         adc T4, tmp1            /* T = w[s]+e */
 613         sbiw r26, 4*5           /* X points at a[0] aka a */
 614         ld F1, X+
 615         ld F2, X+
 616         ld F3, X+
 617         ld F4, X+
 618         mov tmp1, F4            /* X points at a[1] aka b */
 619         ldi tmp2, 5
 620 1:
 621         rol tmp1
 622         rol F1
 623         rol F2
 624         rol F3
 625         rol F4
 626         dec tmp2
 627         brne 1b
 628
 629         add T1, F1
 630         adc T2, F2
 631         adc T3, F3
 632         adc T4, F4 /* T = ROTL(a,5) + e + w[s] */
 633
 634         /* now we have to do this fucking conditional stuff */
 635         ldi r30, lo8(sha1_nextBlock_xTable)
 636         ldi r31, hi8(sha1_nextBlock_xTable)
 637         add r30, xtmp
 638         adc r31, xNULL
 639         lpm tmp1, Z
 640         cp tmp1, LoopC
 641         brne 1f
 642         inc xtmp
 643 1:      ldi r30, lo8(sha1_nextBlock_KTable)
 644         ldi r31, hi8(sha1_nextBlock_KTable)
 645         lsl xtmp
 646         lsl xtmp
 647         add r30, xtmp
 648         adc r31, xNULL
 649         lsr xtmp
 650         lsr xtmp
 651
 652         lpm tmp1, Z+
 653         add T1, tmp1
 654         lpm tmp1, Z+
 655         adc T2, tmp1
 656         lpm tmp1, Z+
 657         adc T3, tmp1
 658         lpm tmp1, Z+
 659         adc T4, tmp1
 660                         /* T = ROTL(a,5) + e + kt + w[s] */
 661
 662         /* Z-4 is just pointing to kt ... */
 663         movw r28, r26 /* copy X in Y */
 664         adiw r30, 3*4 /* now Z points to the rigth locatin in our jump-vector-table */
 665         lsr r31
 666         ror r30
 667
 668         icall
 669         mov F1, tmp1
 670         icall
 671         mov F2, tmp1
 672         icall
 673         mov F3, tmp1
 674         icall
 675
 676         add T1, F1
 677         adc T2, F2
 678         adc T3, F3
 679         adc T4, tmp1 /* T = ROTL5(a) + f_t(b,c,d) + e + k_t + w[s] */
 680                                  /* X points still at a[1] aka b, Y points at a[2] aka c */
 681         /* update a[] */
 682 sha1_nextBlock_update_a:
 683         /*first we move all vars in a[] "one up" e=d, d=c, c=b, b=a*/
 684         //adiw r28, 3*4  /* Y should point at a[4] aka e */
 685         movw r28, W1
 686         sbiw r28, 4
 687
 688         ldi tmp2, 4*4
 689 1:
 690         ld tmp1, -Y
 691         std Y+4, tmp1
 692         dec tmp2
 693         brne 1b
 694         /* Y points at a[0] aka a*/
 695
 696         movw r28, W1
 697         sbiw r28, 5*4
 698         /* store T in a[0] aka a */
 699         st Y+, T1
 700         st Y+, T2
 701         st Y+, T3
 702         st Y+, T4
 703         /* Y points at a[1] aka b*/
 704
 705         /* rotate c */
 706         ldd T1, Y+1*4
 707         ldd T2, Y+1*4+1
 708         ldd T3, Y+1*4+2
 709         ldd T4, Y+1*4+3
 710         mov tmp1, T1
 711         ldi tmp2, 2
 712 1:      ror tmp1
 713         ror T4
 714         ror T3
 715         ror T2
 716         ror T1
 717         dec tmp2
 718         brne 1b
 719         std Y+1*4+0, T1
 720         std Y+1*4+1, T2
 721         std Y+1*4+2, T3
 722         std Y+1*4+3, T4
 723 /*
 724         push r27
 725         push r26
 726         movw r26, W1
 727         sbiw r26, 4*5
 728         dbg_hexdump 4*5
 729         pop r26
 730         pop r27
 731 */
 732         inc LoopC
 733         cpi LoopC, 80
 734         brge 1f
 735         rjmp sha1_nextBlock_mainloop
 736 /**************************************/
 737 1:
 738    /* littel patch */
 739         sbiw r28, 4
 740
 741 /* add a[] to state and inc length */
 742         pop r27
 743         pop r26         /* now X points to state (and Y still at a[0]) */
 744         ldi tmp4, 5
 745 1:      clc
 746         ldi tmp3, 4
 747 2:      ld tmp1, X
 748         ld tmp2, Y+
 749         adc tmp1, tmp2
 750         st X+, tmp1
 751         dec tmp3
 752         brne 2b
 753         dec tmp4
 754         brne 1b
 755
 756         /* now length += 512 */
 757         adiw r26, 1 /* we skip the least significant byte */
 758         ld tmp1, X
 759         ldi tmp2, hi8(512) /* 2 */
 760         add tmp1, tmp2
 761         st X+, tmp1
 762         ldi tmp2, 6
 763 1:
 764         ld tmp1, X
 765         adc tmp1, xNULL
 766         st X+, tmp1
 767         dec tmp2
 768         brne 1b
 769
 770 ; EPILOG
 771 sha1_nextBlock_epilog:
 772 /* now we should clean up the stack */
 773         pop r21
 774         pop r20
 775         in r0, SREG
 776         cli ; we want to be uninterrupted while updating SP
 777         out SPL, r20
 778         out SREG, r0
 779         out SPH, r21
 780
 781         clr r1
 782         pop r29
 783         pop r28
 784         pop r17
 785         pop r16
 786         pop r15
 787         pop r14
 788         pop r13
 789         pop r12
 790         pop r11
 791         pop r10
 792         ret
 793
 794 sha1_nextBlock_xTable:
 795 .byte 20,40,60,0
 796 sha1_nextBlock_KTable:
 797 .int    0x5a827999
 798 .int    0x6ed9eba1
 799 .int    0x8f1bbcdc
 800 .int    0xca62c1d6
 801 sha1_nextBlock_JumpTable:
 802 rjmp sha1_nextBlock_Ch
 803         nop
 804 rjmp sha1_nextBlock_Parity
 805         nop
 806 rjmp sha1_nextBlock_Maj
 807         nop
 808 rjmp sha1_nextBlock_Parity
 809
 810          /* X and Y still point at a[1] aka b ; return value in tmp1 */
 811 sha1_nextBlock_Ch:
 812         ld tmp1, Y+
 813         mov tmp2, tmp1
 814         com tmp2
 815         ldd tmp3, Y+3   /* load from c */
 816         and tmp1, tmp3
 817         ldd tmp3, Y+7   /* load from d */
 818         and tmp2, tmp3
 819         eor tmp1, tmp2
 820         ret
 821
 822 sha1_nextBlock_Maj:
 823         ld tmp1, Y+
 824         mov tmp2, tmp1
 825         ldd tmp3, Y+3   /* load from c */
 826         and tmp1, tmp3
 827         ldd tmp4, Y+7   /* load from d */
 828         and tmp2, tmp4
 829         eor tmp1, tmp2
 830         and tmp3, tmp4
 831         eor tmp1, tmp3
 832         ret
 833
 834 sha1_nextBlock_Parity:
 835         ld tmp1, Y+
 836         ldd tmp2, Y+3   /* load from c */
 837         eor tmp1, tmp2
 838         ldd tmp2, Y+7   /* load from d */
 839         eor tmp1, tmp2
 840         ret
 841 /*
 842 ch_str:                 .asciz "\r\nCh"
 843 maj_str:                .asciz "\r\nMaj"
 844 parity_str:     .asciz "\r\nParity"
 845 */
 846 ;###########################################################
 847
 848 .global sha1_init
 849 ;void sha1_init(sha1_ctx_t *state){
 850 ;       DEBUG_S("\r\nSHA1_INIT");
 851 ;       state->h[0] = 0x67452301;
 852 ;       state->h[1] = 0xefcdab89;
 853 ;       state->h[2] = 0x98badcfe;
 854 ;       state->h[3] = 0x10325476;
 855 ;       state->h[4] = 0xc3d2e1f0;
 856 ;       state->length = 0;
 857 ;}
 858 ; param1: (Func3,r24) 16-bit pointer to sha1_ctx_t struct in ram
 859 ; modifys: Z(r30,r31), Func1, r22
 860 sha1_init:
 861         movw r26, r24 ; (24,25) --> (26,27) load X with param1
 862         ldi r30, lo8((sha1_init_vector))
 863         ldi r31, hi8((sha1_init_vector))
 864         ldi r22, 5*4 /* bytes to copy */
 865 sha1_init_vloop:
 866         lpm r23, Z+
 867         st X+, r23
 868         dec r22
 869         brne sha1_init_vloop
 870         ldi r22, 8
 871 sha1_init_lloop:
 872         st X+, r1
 873         dec r22
 874         brne sha1_init_lloop
 875         ret
 876
 877 sha1_init_vector:
 878 .int 0x67452301;
 879 .int 0xefcdab89;
 880 .int 0x98badcfe;
 881 .int 0x10325476;
 882 .int 0xc3d2e1f0;
 883