x86_64/sha1-compress.asm

   1 C x86_64/sha1-compress.asm
   2
   3 ifelse(<
   4    Copyright (C) 2004, 2008, 2013 Niels Möller
   5
   6    This file is part of GNU Nettle.
   7
   8    GNU Nettle is free software: you can redistribute it and/or
   9    modify it under the terms of either:
  10
  11      * the GNU Lesser General Public License as published by the Free
  12        Software Foundation; either version 3 of the License, or (at your
  13        option) any later version.
  14
  15    or
  16
  17      * the GNU General Public License as published by the Free
  18        Software Foundation; either version 2 of the License, or (at your
  19        option) any later version.
  20
  21    or both in parallel, as here.
  22
  23    GNU Nettle is distributed in the hope that it will be useful,
  24    but WITHOUT ANY WARRANTY; without even the implied warranty of
  25    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  26    General Public License for more details.
  27
  28    You should have received copies of the GNU General Public License and
  29    the GNU Lesser General Public License along with this program.  If
  30    not, see http://www.gnu.org/licenses/.
  31 >)
  32
  33 C Register usage. KVALUE and INPUT share a register.
  34 define(<SA>,<%eax>)dnl
  35 define(<SB>,<%r8d>)dnl
  36 define(<SC>,<%ecx>)dnl
  37 define(<SD>,<%edx>)dnl
  38 define(<SE>,<%r9d>)dnl
  39 define(<DATA>,<%rsp>)dnl
  40 define(<T1>,<%r10d>)dnl
  41 define(<T2>,<%r11d>)dnl
  42 define(<KVALUE>, <%esi>)dnl
  43
  44 C Arguments
  45 define(<STATE>,<%rdi>)dnl
  46 define(<INPUT>,<%rsi>)dnl
  47
  48 C Constants
  49 define(<K1VALUE>, <<$>0x5A827999>)dnl           C  Rounds  0-19
  50 define(<K2VALUE>, <<$>0x6ED9EBA1>)dnl           C  Rounds 20-39
  51 define(<K3VALUE>, <<$>0x8F1BBCDC>)dnl           C  Rounds 40-59
  52 define(<K4VALUE>, <<$>0xCA62C1D6>)dnl           C  Rounds 60-79
  53
  54 C Reads the input into register, byteswaps it, and stores it in the DATA array.
  55 C SWAP(index, register)
  56 define(<SWAP>, <
  57         movl    OFFSET($1)(INPUT), $2
  58         bswap   $2
  59         movl    $2, OFFSET($1) (DATA)
  60 >)dnl
  61
  62 C The f functions,
  63 C
  64 C  f1(x,y,z) = z ^ (x & (y ^ z))
  65 C  f2(x,y,z) = x ^ y ^ z
  66 C  f3(x,y,z) = (x & y) | (z & (x | y))
  67 C            = (x & (y ^ z)) + (y & z)
  68 C  f4 = f2
  69
  70 C This form for f3 was suggested by George Spelvin. The terms can be
  71 C added into the result one at a time, saving one temporary.
  72
  73 C expand(i) is the expansion function
  74 C
  75 C   W[i] = (W[i - 16] ^ W[i - 14] ^ W[i - 8] ^ W[i - 3]) <<< 1
  76 C
  77 C where W[i] is stored in DATA[i mod 16].
  78
  79 C The form of one sha1 round is
  80 C
  81 C   a' = e + a <<< 5 + f( b, c, d ) + k + w;
  82 C   b' = a;
  83 C   c' = b <<< 30;
  84 C   d' = c;
  85 C   e' = d;
  86 C
  87 C where <<< denotes rotation. We permute our variables, so that we
  88 C instead get
  89 C
  90 C   e += a <<< 5 + f( b, c, d ) + k + w;
  91 C   b <<<= 30
  92
  93 dnl ROUND_F1(a, b, c, d, e, i)
  94 define(<ROUND_F1>, <
  95         movl    OFFSET(eval($6 % 16)) (DATA), T1
  96         xorl    OFFSET(eval(($6 +  2) % 16)) (DATA), T1
  97         xorl    OFFSET(eval(($6 +  8) % 16)) (DATA), T1
  98         xorl    OFFSET(eval(($6 + 13) % 16)) (DATA), T1
  99         roll    <$>1, T1
 100         movl    T1, OFFSET(eval($6 % 16)) (DATA)
 101         movl    $4, T2
 102         xorl    $3, T2
 103         andl    $2, T2
 104         xorl    $4, T2
 105         roll    <$>30, $2
 106         addl    T1, $5
 107         addl    KVALUE, $5
 108         movl    $1, T1
 109         roll    <$>5, T1
 110         addl    T1, $5
 111         addl    T2, $5
 112 >)
 113
 114 dnl ROUND_F1_NOEXP(a, b, c, d, e, i)
 115 define(<ROUND_F1_NOEXP>, <
 116         movl    $4, T2
 117         xorl    $3, T2
 118         movl    $1, T1
 119         andl    $2, T2
 120         addl    OFFSET($6) (DATA), $5
 121         xorl    $4, T2
 122         addl    T2, $5
 123         roll    <$>30, $2
 124         roll    <$>5, T1
 125         addl    T1, $5
 126         addl    KVALUE, $5
 127 >)
 128
 129 dnl ROUND_F2(a, b, c, d, e, i)
 130 define(<ROUND_F2>, <
 131         movl    OFFSET(eval($6 % 16)) (DATA), T1
 132         xorl    OFFSET(eval(($6 +  2) % 16)) (DATA), T1
 133         xorl    OFFSET(eval(($6 +  8) % 16)) (DATA), T1
 134         xorl    OFFSET(eval(($6 + 13) % 16)) (DATA), T1
 135         roll    <$>1, T1
 136         movl    T1, OFFSET(eval($6 % 16)) (DATA)
 137         movl    $4, T2
 138         xorl    $3, T2
 139         xorl    $2, T2
 140         roll    <$>30, $2
 141         addl    T1, $5
 142         addl    KVALUE, $5
 143         movl    $1, T1
 144         roll    <$>5, T1
 145         addl    T1, $5
 146         addl    T2, $5
 147 >)
 148
 149 dnl ROUND_F3(a, b, c, d, e, i)
 150 define(<ROUND_F3>, <
 151         movl    OFFSET(eval($6 % 16)) (DATA), T1
 152         xorl    OFFSET(eval(($6 +  2) % 16)) (DATA), T1
 153         xorl    OFFSET(eval(($6 +  8) % 16)) (DATA), T1
 154         xorl    OFFSET(eval(($6 + 13) % 16)) (DATA), T1
 155         roll    <$>1, T1
 156         movl    T1, OFFSET(eval($6 % 16)) (DATA)
 157         movl    $4, T2
 158         andl    $3, T2
 159         addl    T1, $5
 160         addl    KVALUE, $5
 161         movl    $4, T1
 162         xorl    $3, T1
 163         andl    $2, T1
 164         addl    T2, $5
 165         roll    <$>30, $2
 166         movl    $1, T2
 167         roll    <$>5, T2
 168         addl    T1, $5
 169         addl    T2, $5
 170 >)
 171
 172         .file "sha1-compress.asm"
 173
 174         C _nettle_sha1_compress(uint32_t *state, uint8_t *input)
 175
 176         .text
 177         ALIGN(16)
 178 PROLOGUE(_nettle_sha1_compress)
 179         C save all registers that need to be saved
 180         W64_ENTRY(2, 0)
 181
 182         sub     $64, %rsp       C  %rsp = W
 183
 184         C Load and byteswap data
 185         SWAP( 0, SA) SWAP( 1, SB) SWAP( 2, SC) SWAP( 3, SD)
 186         SWAP( 4, SA) SWAP( 5, SB) SWAP( 6, SC) SWAP( 7, SD)
 187         SWAP( 8, SA) SWAP( 9, SB) SWAP(10, SC) SWAP(11, SD)
 188         SWAP(12, SA) SWAP(13, SB) SWAP(14, SC) SWAP(15, SD)
 189
 190         C Load the state vector
 191         movl      (STATE), SA
 192         movl     4(STATE), SB
 193         movl     8(STATE), SC
 194         movl    12(STATE), SD
 195         movl    16(STATE), SE
 196
 197         movl    K1VALUE, KVALUE
 198         ROUND_F1_NOEXP(SA, SB, SC, SD, SE,  0)
 199         ROUND_F1_NOEXP(SE, SA, SB, SC, SD,  1)
 200         ROUND_F1_NOEXP(SD, SE, SA, SB, SC,  2)
 201         ROUND_F1_NOEXP(SC, SD, SE, SA, SB,  3)
 202         ROUND_F1_NOEXP(SB, SC, SD, SE, SA,  4)
 203
 204         ROUND_F1_NOEXP(SA, SB, SC, SD, SE,  5)
 205         ROUND_F1_NOEXP(SE, SA, SB, SC, SD,  6)
 206         ROUND_F1_NOEXP(SD, SE, SA, SB, SC,  7)
 207         ROUND_F1_NOEXP(SC, SD, SE, SA, SB,  8)
 208         ROUND_F1_NOEXP(SB, SC, SD, SE, SA,  9)
 209
 210         ROUND_F1_NOEXP(SA, SB, SC, SD, SE, 10)
 211         ROUND_F1_NOEXP(SE, SA, SB, SC, SD, 11)
 212         ROUND_F1_NOEXP(SD, SE, SA, SB, SC, 12)
 213         ROUND_F1_NOEXP(SC, SD, SE, SA, SB, 13)
 214         ROUND_F1_NOEXP(SB, SC, SD, SE, SA, 14)
 215
 216         ROUND_F1_NOEXP(SA, SB, SC, SD, SE, 15)
 217         ROUND_F1(SE, SA, SB, SC, SD, 16)
 218         ROUND_F1(SD, SE, SA, SB, SC, 17)
 219         ROUND_F1(SC, SD, SE, SA, SB, 18)
 220         ROUND_F1(SB, SC, SD, SE, SA, 19)
 221
 222         movl    K2VALUE, KVALUE
 223         ROUND_F2(SA, SB, SC, SD, SE, 20)
 224         ROUND_F2(SE, SA, SB, SC, SD, 21)
 225         ROUND_F2(SD, SE, SA, SB, SC, 22)
 226         ROUND_F2(SC, SD, SE, SA, SB, 23)
 227         ROUND_F2(SB, SC, SD, SE, SA, 24)
 228
 229         ROUND_F2(SA, SB, SC, SD, SE, 25)
 230         ROUND_F2(SE, SA, SB, SC, SD, 26)
 231         ROUND_F2(SD, SE, SA, SB, SC, 27)
 232         ROUND_F2(SC, SD, SE, SA, SB, 28)
 233         ROUND_F2(SB, SC, SD, SE, SA, 29)
 234
 235         ROUND_F2(SA, SB, SC, SD, SE, 30)
 236         ROUND_F2(SE, SA, SB, SC, SD, 31)
 237         ROUND_F2(SD, SE, SA, SB, SC, 32)
 238         ROUND_F2(SC, SD, SE, SA, SB, 33)
 239         ROUND_F2(SB, SC, SD, SE, SA, 34)
 240
 241         ROUND_F2(SA, SB, SC, SD, SE, 35)
 242         ROUND_F2(SE, SA, SB, SC, SD, 36)
 243         ROUND_F2(SD, SE, SA, SB, SC, 37)
 244         ROUND_F2(SC, SD, SE, SA, SB, 38)
 245         ROUND_F2(SB, SC, SD, SE, SA, 39)
 246
 247         movl    K3VALUE, KVALUE
 248         ROUND_F3(SA, SB, SC, SD, SE, 40)
 249         ROUND_F3(SE, SA, SB, SC, SD, 41)
 250         ROUND_F3(SD, SE, SA, SB, SC, 42)
 251         ROUND_F3(SC, SD, SE, SA, SB, 43)
 252         ROUND_F3(SB, SC, SD, SE, SA, 44)
 253
 254         ROUND_F3(SA, SB, SC, SD, SE, 45)
 255         ROUND_F3(SE, SA, SB, SC, SD, 46)
 256         ROUND_F3(SD, SE, SA, SB, SC, 47)
 257         ROUND_F3(SC, SD, SE, SA, SB, 48)
 258         ROUND_F3(SB, SC, SD, SE, SA, 49)
 259
 260         ROUND_F3(SA, SB, SC, SD, SE, 50)
 261         ROUND_F3(SE, SA, SB, SC, SD, 51)
 262         ROUND_F3(SD, SE, SA, SB, SC, 52)
 263         ROUND_F3(SC, SD, SE, SA, SB, 53)
 264         ROUND_F3(SB, SC, SD, SE, SA, 54)
 265
 266         ROUND_F3(SA, SB, SC, SD, SE, 55)
 267         ROUND_F3(SE, SA, SB, SC, SD, 56)
 268         ROUND_F3(SD, SE, SA, SB, SC, 57)
 269         ROUND_F3(SC, SD, SE, SA, SB, 58)
 270         ROUND_F3(SB, SC, SD, SE, SA, 59)
 271
 272         movl    K4VALUE, KVALUE
 273         ROUND_F2(SA, SB, SC, SD, SE, 60)
 274         ROUND_F2(SE, SA, SB, SC, SD, 61)
 275         ROUND_F2(SD, SE, SA, SB, SC, 62)
 276         ROUND_F2(SC, SD, SE, SA, SB, 63)
 277         ROUND_F2(SB, SC, SD, SE, SA, 64)
 278
 279         ROUND_F2(SA, SB, SC, SD, SE, 65)
 280         ROUND_F2(SE, SA, SB, SC, SD, 66)
 281         ROUND_F2(SD, SE, SA, SB, SC, 67)
 282         ROUND_F2(SC, SD, SE, SA, SB, 68)
 283         ROUND_F2(SB, SC, SD, SE, SA, 69)
 284
 285         ROUND_F2(SA, SB, SC, SD, SE, 70)
 286         ROUND_F2(SE, SA, SB, SC, SD, 71)
 287         ROUND_F2(SD, SE, SA, SB, SC, 72)
 288         ROUND_F2(SC, SD, SE, SA, SB, 73)
 289         ROUND_F2(SB, SC, SD, SE, SA, 74)
 290
 291         ROUND_F2(SA, SB, SC, SD, SE, 75)
 292         ROUND_F2(SE, SA, SB, SC, SD, 76)
 293         ROUND_F2(SD, SE, SA, SB, SC, 77)
 294         ROUND_F2(SC, SD, SE, SA, SB, 78)
 295         ROUND_F2(SB, SC, SD, SE, SA, 79)
 296
 297         C Update the state vector
 298         addl    SA,   (STATE)
 299         addl    SB,  4(STATE)
 300         addl    SC,  8(STATE)
 301         addl    SD, 12(STATE)
 302         addl    SE, 16(STATE)
 303
 304         add     $64, %rsp
 305         W64_EXIT(2, 0)
 306         ret
 307 EPILOGUE(_nettle_sha1_compress)