x86/crypto/aegis128-aesni-asm.S

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * AES-NI + SSE2 implementation of AEGIS-128
   4  *
   5  * Copyright (c) 2017-2018 Ondrej Mosnacek <omosnacek@gmail.com>
   6  * Copyright (C) 2017-2018 Red Hat, Inc. All rights reserved.
   7  */
   8
   9 #include <linux/linkage.h>
  10 #include <linux/cfi_types.h>
  11 #include <asm/frame.h>
  12
  13 #define STATE0  %xmm0
  14 #define STATE1  %xmm1
  15 #define STATE2  %xmm2
  16 #define STATE3  %xmm3
  17 #define STATE4  %xmm4
  18 #define KEY     %xmm5
  19 #define MSG     %xmm5
  20 #define T0      %xmm6
  21 #define T1      %xmm7
  22
  23 #define STATEP  %rdi
  24 #define LEN     %rsi
  25 #define SRC     %rdx
  26 #define DST     %rcx
  27
  28 .section .rodata.cst16.aegis128_const, "aM", @progbits, 32
  29 .align 16
  30 .Laegis128_const_0:
  31         .byte 0x00, 0x01, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d
  32         .byte 0x15, 0x22, 0x37, 0x59, 0x90, 0xe9, 0x79, 0x62
  33 .Laegis128_const_1:
  34         .byte 0xdb, 0x3d, 0x18, 0x55, 0x6d, 0xc2, 0x2f, 0xf1
  35         .byte 0x20, 0x11, 0x31, 0x42, 0x73, 0xb5, 0x28, 0xdd
  36
  37 .section .rodata.cst16.aegis128_counter, "aM", @progbits, 16
  38 .align 16
  39 .Laegis128_counter:
  40         .byte 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
  41         .byte 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
  42
  43 .text
  44
  45 /*
  46  * aegis128_update
  47  * input:
  48  *   STATE[0-4] - input state
  49  * output:
  50  *   STATE[0-4] - output state (shifted positions)
  51  * changed:
  52  *   T0
  53  */
  54 .macro aegis128_update
  55         movdqa STATE4, T0
  56         aesenc STATE0, STATE4
  57         aesenc STATE1, STATE0
  58         aesenc STATE2, STATE1
  59         aesenc STATE3, STATE2
  60         aesenc T0,     STATE3
  61 .endm
  62
  63 /*
  64  * __load_partial: internal ABI
  65  * input:
  66  *   LEN - bytes
  67  *   SRC - src
  68  * output:
  69  *   MSG  - message block
  70  * changed:
  71  *   T0
  72  *   %r8
  73  *   %r9
  74  */
  75 SYM_FUNC_START_LOCAL(__load_partial)
  76         xor %r9d, %r9d
  77         pxor MSG, MSG
  78
  79         mov LEN, %r8
  80         and $0x1, %r8
  81         jz .Lld_partial_1
  82
  83         mov LEN, %r8
  84         and $0x1E, %r8
  85         add SRC, %r8
  86         mov (%r8), %r9b
  87
  88 .Lld_partial_1:
  89         mov LEN, %r8
  90         and $0x2, %r8
  91         jz .Lld_partial_2
  92
  93         mov LEN, %r8
  94         and $0x1C, %r8
  95         add SRC, %r8
  96         shl $0x10, %r9
  97         mov (%r8), %r9w
  98
  99 .Lld_partial_2:
 100         mov LEN, %r8
 101         and $0x4, %r8
 102         jz .Lld_partial_4
 103
 104         mov LEN, %r8
 105         and $0x18, %r8
 106         add SRC, %r8
 107         shl $32, %r9
 108         mov (%r8), %r8d
 109         xor %r8, %r9
 110
 111 .Lld_partial_4:
 112         movq %r9, MSG
 113
 114         mov LEN, %r8
 115         and $0x8, %r8
 116         jz .Lld_partial_8
 117
 118         mov LEN, %r8
 119         and $0x10, %r8
 120         add SRC, %r8
 121         pslldq $8, MSG
 122         movq (%r8), T0
 123         pxor T0, MSG
 124
 125 .Lld_partial_8:
 126         RET
 127 SYM_FUNC_END(__load_partial)
 128
 129 /*
 130  * __store_partial: internal ABI
 131  * input:
 132  *   LEN - bytes
 133  *   DST - dst
 134  * output:
 135  *   T0   - message block
 136  * changed:
 137  *   %r8
 138  *   %r9
 139  *   %r10
 140  */
 141 SYM_FUNC_START_LOCAL(__store_partial)
 142         mov LEN, %r8
 143         mov DST, %r9
 144
 145         movq T0, %r10
 146
 147         cmp $8, %r8
 148         jl .Lst_partial_8
 149
 150         mov %r10, (%r9)
 151         psrldq $8, T0
 152         movq T0, %r10
 153
 154         sub $8, %r8
 155         add $8, %r9
 156
 157 .Lst_partial_8:
 158         cmp $4, %r8
 159         jl .Lst_partial_4
 160
 161         mov %r10d, (%r9)
 162         shr $32, %r10
 163
 164         sub $4, %r8
 165         add $4, %r9
 166
 167 .Lst_partial_4:
 168         cmp $2, %r8
 169         jl .Lst_partial_2
 170
 171         mov %r10w, (%r9)
 172         shr $0x10, %r10
 173
 174         sub $2, %r8
 175         add $2, %r9
 176
 177 .Lst_partial_2:
 178         cmp $1, %r8
 179         jl .Lst_partial_1
 180
 181         mov %r10b, (%r9)
 182
 183 .Lst_partial_1:
 184         RET
 185 SYM_FUNC_END(__store_partial)
 186
 187 /*
 188  * void crypto_aegis128_aesni_init(void *state, const void *key, const void *iv);
 189  */
 190 SYM_FUNC_START(crypto_aegis128_aesni_init)
 191         FRAME_BEGIN
 192
 193         /* load IV: */
 194         movdqu (%rdx), T1
 195
 196         /* load key: */
 197         movdqa (%rsi), KEY
 198         pxor KEY, T1
 199         movdqa T1, STATE0
 200         movdqa KEY, STATE3
 201         movdqa KEY, STATE4
 202
 203         /* load the constants: */
 204         movdqa .Laegis128_const_0, STATE2
 205         movdqa .Laegis128_const_1, STATE1
 206         pxor STATE2, STATE3
 207         pxor STATE1, STATE4
 208
 209         /* update 10 times with KEY / KEY xor IV: */
 210         aegis128_update; pxor KEY, STATE4
 211         aegis128_update; pxor T1,  STATE3
 212         aegis128_update; pxor KEY, STATE2
 213         aegis128_update; pxor T1,  STATE1
 214         aegis128_update; pxor KEY, STATE0
 215         aegis128_update; pxor T1,  STATE4
 216         aegis128_update; pxor KEY, STATE3
 217         aegis128_update; pxor T1,  STATE2
 218         aegis128_update; pxor KEY, STATE1
 219         aegis128_update; pxor T1,  STATE0
 220
 221         /* store the state: */
 222         movdqu STATE0, 0x00(STATEP)
 223         movdqu STATE1, 0x10(STATEP)
 224         movdqu STATE2, 0x20(STATEP)
 225         movdqu STATE3, 0x30(STATEP)
 226         movdqu STATE4, 0x40(STATEP)
 227
 228         FRAME_END
 229         RET
 230 SYM_FUNC_END(crypto_aegis128_aesni_init)
 231
 232 /*
 233  * void crypto_aegis128_aesni_ad(void *state, unsigned int length,
 234  *                               const void *data);
 235  */
 236 SYM_FUNC_START(crypto_aegis128_aesni_ad)
 237         FRAME_BEGIN
 238
 239         cmp $0x10, LEN
 240         jb .Lad_out
 241
 242         /* load the state: */
 243         movdqu 0x00(STATEP), STATE0
 244         movdqu 0x10(STATEP), STATE1
 245         movdqu 0x20(STATEP), STATE2
 246         movdqu 0x30(STATEP), STATE3
 247         movdqu 0x40(STATEP), STATE4
 248
 249         mov SRC, %r8
 250         and $0xF, %r8
 251         jnz .Lad_u_loop
 252
 253 .align 8
 254 .Lad_a_loop:
 255         movdqa 0x00(SRC), MSG
 256         aegis128_update
 257         pxor MSG, STATE4
 258         sub $0x10, LEN
 259         cmp $0x10, LEN
 260         jl .Lad_out_1
 261
 262         movdqa 0x10(SRC), MSG
 263         aegis128_update
 264         pxor MSG, STATE3
 265         sub $0x10, LEN
 266         cmp $0x10, LEN
 267         jl .Lad_out_2
 268
 269         movdqa 0x20(SRC), MSG
 270         aegis128_update
 271         pxor MSG, STATE2
 272         sub $0x10, LEN
 273         cmp $0x10, LEN
 274         jl .Lad_out_3
 275
 276         movdqa 0x30(SRC), MSG
 277         aegis128_update
 278         pxor MSG, STATE1
 279         sub $0x10, LEN
 280         cmp $0x10, LEN
 281         jl .Lad_out_4
 282
 283         movdqa 0x40(SRC), MSG
 284         aegis128_update
 285         pxor MSG, STATE0
 286         sub $0x10, LEN
 287         cmp $0x10, LEN
 288         jl .Lad_out_0
 289
 290         add $0x50, SRC
 291         jmp .Lad_a_loop
 292
 293 .align 8
 294 .Lad_u_loop:
 295         movdqu 0x00(SRC), MSG
 296         aegis128_update
 297         pxor MSG, STATE4
 298         sub $0x10, LEN
 299         cmp $0x10, LEN
 300         jl .Lad_out_1
 301
 302         movdqu 0x10(SRC), MSG
 303         aegis128_update
 304         pxor MSG, STATE3
 305         sub $0x10, LEN
 306         cmp $0x10, LEN
 307         jl .Lad_out_2
 308
 309         movdqu 0x20(SRC), MSG
 310         aegis128_update
 311         pxor MSG, STATE2
 312         sub $0x10, LEN
 313         cmp $0x10, LEN
 314         jl .Lad_out_3
 315
 316         movdqu 0x30(SRC), MSG
 317         aegis128_update
 318         pxor MSG, STATE1
 319         sub $0x10, LEN
 320         cmp $0x10, LEN
 321         jl .Lad_out_4
 322
 323         movdqu 0x40(SRC), MSG
 324         aegis128_update
 325         pxor MSG, STATE0
 326         sub $0x10, LEN
 327         cmp $0x10, LEN
 328         jl .Lad_out_0
 329
 330         add $0x50, SRC
 331         jmp .Lad_u_loop
 332
 333         /* store the state: */
 334 .Lad_out_0:
 335         movdqu STATE0, 0x00(STATEP)
 336         movdqu STATE1, 0x10(STATEP)
 337         movdqu STATE2, 0x20(STATEP)
 338         movdqu STATE3, 0x30(STATEP)
 339         movdqu STATE4, 0x40(STATEP)
 340         FRAME_END
 341         RET
 342
 343 .Lad_out_1:
 344         movdqu STATE4, 0x00(STATEP)
 345         movdqu STATE0, 0x10(STATEP)
 346         movdqu STATE1, 0x20(STATEP)
 347         movdqu STATE2, 0x30(STATEP)
 348         movdqu STATE3, 0x40(STATEP)
 349         FRAME_END
 350         RET
 351
 352 .Lad_out_2:
 353         movdqu STATE3, 0x00(STATEP)
 354         movdqu STATE4, 0x10(STATEP)
 355         movdqu STATE0, 0x20(STATEP)
 356         movdqu STATE1, 0x30(STATEP)
 357         movdqu STATE2, 0x40(STATEP)
 358         FRAME_END
 359         RET
 360
 361 .Lad_out_3:
 362         movdqu STATE2, 0x00(STATEP)
 363         movdqu STATE3, 0x10(STATEP)
 364         movdqu STATE4, 0x20(STATEP)
 365         movdqu STATE0, 0x30(STATEP)
 366         movdqu STATE1, 0x40(STATEP)
 367         FRAME_END
 368         RET
 369
 370 .Lad_out_4:
 371         movdqu STATE1, 0x00(STATEP)
 372         movdqu STATE2, 0x10(STATEP)
 373         movdqu STATE3, 0x20(STATEP)
 374         movdqu STATE4, 0x30(STATEP)
 375         movdqu STATE0, 0x40(STATEP)
 376         FRAME_END
 377         RET
 378
 379 .Lad_out:
 380         FRAME_END
 381         RET
 382 SYM_FUNC_END(crypto_aegis128_aesni_ad)
 383
 384 .macro encrypt_block a s0 s1 s2 s3 s4 i
 385         movdq\a (\i * 0x10)(SRC), MSG
 386         movdqa MSG, T0
 387         pxor \s1, T0
 388         pxor \s4, T0
 389         movdqa \s2, T1
 390         pand \s3, T1
 391         pxor T1, T0
 392         movdq\a T0, (\i * 0x10)(DST)
 393
 394         aegis128_update
 395         pxor MSG, \s4
 396
 397         sub $0x10, LEN
 398         cmp $0x10, LEN
 399         jl .Lenc_out_\i
 400 .endm
 401
 402 /*
 403  * void crypto_aegis128_aesni_enc(void *state, unsigned int length,
 404  *                                const void *src, void *dst);
 405  */
 406 SYM_TYPED_FUNC_START(crypto_aegis128_aesni_enc)
 407         FRAME_BEGIN
 408
 409         cmp $0x10, LEN
 410         jb .Lenc_out
 411
 412         /* load the state: */
 413         movdqu 0x00(STATEP), STATE0
 414         movdqu 0x10(STATEP), STATE1
 415         movdqu 0x20(STATEP), STATE2
 416         movdqu 0x30(STATEP), STATE3
 417         movdqu 0x40(STATEP), STATE4
 418
 419         mov  SRC,  %r8
 420         or   DST,  %r8
 421         and $0xF, %r8
 422         jnz .Lenc_u_loop
 423
 424 .align 8
 425 .Lenc_a_loop:
 426         encrypt_block a STATE0 STATE1 STATE2 STATE3 STATE4 0
 427         encrypt_block a STATE4 STATE0 STATE1 STATE2 STATE3 1
 428         encrypt_block a STATE3 STATE4 STATE0 STATE1 STATE2 2
 429         encrypt_block a STATE2 STATE3 STATE4 STATE0 STATE1 3
 430         encrypt_block a STATE1 STATE2 STATE3 STATE4 STATE0 4
 431
 432         add $0x50, SRC
 433         add $0x50, DST
 434         jmp .Lenc_a_loop
 435
 436 .align 8
 437 .Lenc_u_loop:
 438         encrypt_block u STATE0 STATE1 STATE2 STATE3 STATE4 0
 439         encrypt_block u STATE4 STATE0 STATE1 STATE2 STATE3 1
 440         encrypt_block u STATE3 STATE4 STATE0 STATE1 STATE2 2
 441         encrypt_block u STATE2 STATE3 STATE4 STATE0 STATE1 3
 442         encrypt_block u STATE1 STATE2 STATE3 STATE4 STATE0 4
 443
 444         add $0x50, SRC
 445         add $0x50, DST
 446         jmp .Lenc_u_loop
 447
 448         /* store the state: */
 449 .Lenc_out_0:
 450         movdqu STATE4, 0x00(STATEP)
 451         movdqu STATE0, 0x10(STATEP)
 452         movdqu STATE1, 0x20(STATEP)
 453         movdqu STATE2, 0x30(STATEP)
 454         movdqu STATE3, 0x40(STATEP)
 455         FRAME_END
 456         RET
 457
 458 .Lenc_out_1:
 459         movdqu STATE3, 0x00(STATEP)
 460         movdqu STATE4, 0x10(STATEP)
 461         movdqu STATE0, 0x20(STATEP)
 462         movdqu STATE1, 0x30(STATEP)
 463         movdqu STATE2, 0x40(STATEP)
 464         FRAME_END
 465         RET
 466
 467 .Lenc_out_2:
 468         movdqu STATE2, 0x00(STATEP)
 469         movdqu STATE3, 0x10(STATEP)
 470         movdqu STATE4, 0x20(STATEP)
 471         movdqu STATE0, 0x30(STATEP)
 472         movdqu STATE1, 0x40(STATEP)
 473         FRAME_END
 474         RET
 475
 476 .Lenc_out_3:
 477         movdqu STATE1, 0x00(STATEP)
 478         movdqu STATE2, 0x10(STATEP)
 479         movdqu STATE3, 0x20(STATEP)
 480         movdqu STATE4, 0x30(STATEP)
 481         movdqu STATE0, 0x40(STATEP)
 482         FRAME_END
 483         RET
 484
 485 .Lenc_out_4:
 486         movdqu STATE0, 0x00(STATEP)
 487         movdqu STATE1, 0x10(STATEP)
 488         movdqu STATE2, 0x20(STATEP)
 489         movdqu STATE3, 0x30(STATEP)
 490         movdqu STATE4, 0x40(STATEP)
 491         FRAME_END
 492         RET
 493
 494 .Lenc_out:
 495         FRAME_END
 496         RET
 497 SYM_FUNC_END(crypto_aegis128_aesni_enc)
 498
 499 /*
 500  * void crypto_aegis128_aesni_enc_tail(void *state, unsigned int length,
 501  *                                     const void *src, void *dst);
 502  */
 503 SYM_TYPED_FUNC_START(crypto_aegis128_aesni_enc_tail)
 504         FRAME_BEGIN
 505
 506         /* load the state: */
 507         movdqu 0x00(STATEP), STATE0
 508         movdqu 0x10(STATEP), STATE1
 509         movdqu 0x20(STATEP), STATE2
 510         movdqu 0x30(STATEP), STATE3
 511         movdqu 0x40(STATEP), STATE4
 512
 513         /* encrypt message: */
 514         call __load_partial
 515
 516         movdqa MSG, T0
 517         pxor STATE1, T0
 518         pxor STATE4, T0
 519         movdqa STATE2, T1
 520         pand STATE3, T1
 521         pxor T1, T0
 522
 523         call __store_partial
 524
 525         aegis128_update
 526         pxor MSG, STATE4
 527
 528         /* store the state: */
 529         movdqu STATE4, 0x00(STATEP)
 530         movdqu STATE0, 0x10(STATEP)
 531         movdqu STATE1, 0x20(STATEP)
 532         movdqu STATE2, 0x30(STATEP)
 533         movdqu STATE3, 0x40(STATEP)
 534
 535         FRAME_END
 536         RET
 537 SYM_FUNC_END(crypto_aegis128_aesni_enc_tail)
 538
 539 .macro decrypt_block a s0 s1 s2 s3 s4 i
 540         movdq\a (\i * 0x10)(SRC), MSG
 541         pxor \s1, MSG
 542         pxor \s4, MSG
 543         movdqa \s2, T1
 544         pand \s3, T1
 545         pxor T1, MSG
 546         movdq\a MSG, (\i * 0x10)(DST)
 547
 548         aegis128_update
 549         pxor MSG, \s4
 550
 551         sub $0x10, LEN
 552         cmp $0x10, LEN
 553         jl .Ldec_out_\i
 554 .endm
 555
 556 /*
 557  * void crypto_aegis128_aesni_dec(void *state, unsigned int length,
 558  *                                const void *src, void *dst);
 559  */
 560 SYM_TYPED_FUNC_START(crypto_aegis128_aesni_dec)
 561         FRAME_BEGIN
 562
 563         cmp $0x10, LEN
 564         jb .Ldec_out
 565
 566         /* load the state: */
 567         movdqu 0x00(STATEP), STATE0
 568         movdqu 0x10(STATEP), STATE1
 569         movdqu 0x20(STATEP), STATE2
 570         movdqu 0x30(STATEP), STATE3
 571         movdqu 0x40(STATEP), STATE4
 572
 573         mov  SRC, %r8
 574         or   DST, %r8
 575         and $0xF, %r8
 576         jnz .Ldec_u_loop
 577
 578 .align 8
 579 .Ldec_a_loop:
 580         decrypt_block a STATE0 STATE1 STATE2 STATE3 STATE4 0
 581         decrypt_block a STATE4 STATE0 STATE1 STATE2 STATE3 1
 582         decrypt_block a STATE3 STATE4 STATE0 STATE1 STATE2 2
 583         decrypt_block a STATE2 STATE3 STATE4 STATE0 STATE1 3
 584         decrypt_block a STATE1 STATE2 STATE3 STATE4 STATE0 4
 585
 586         add $0x50, SRC
 587         add $0x50, DST
 588         jmp .Ldec_a_loop
 589
 590 .align 8
 591 .Ldec_u_loop:
 592         decrypt_block u STATE0 STATE1 STATE2 STATE3 STATE4 0
 593         decrypt_block u STATE4 STATE0 STATE1 STATE2 STATE3 1
 594         decrypt_block u STATE3 STATE4 STATE0 STATE1 STATE2 2
 595         decrypt_block u STATE2 STATE3 STATE4 STATE0 STATE1 3
 596         decrypt_block u STATE1 STATE2 STATE3 STATE4 STATE0 4
 597
 598         add $0x50, SRC
 599         add $0x50, DST
 600         jmp .Ldec_u_loop
 601
 602         /* store the state: */
 603 .Ldec_out_0:
 604         movdqu STATE4, 0x00(STATEP)
 605         movdqu STATE0, 0x10(STATEP)
 606         movdqu STATE1, 0x20(STATEP)
 607         movdqu STATE2, 0x30(STATEP)
 608         movdqu STATE3, 0x40(STATEP)
 609         FRAME_END
 610         RET
 611
 612 .Ldec_out_1:
 613         movdqu STATE3, 0x00(STATEP)
 614         movdqu STATE4, 0x10(STATEP)
 615         movdqu STATE0, 0x20(STATEP)
 616         movdqu STATE1, 0x30(STATEP)
 617         movdqu STATE2, 0x40(STATEP)
 618         FRAME_END
 619         RET
 620
 621 .Ldec_out_2:
 622         movdqu STATE2, 0x00(STATEP)
 623         movdqu STATE3, 0x10(STATEP)
 624         movdqu STATE4, 0x20(STATEP)
 625         movdqu STATE0, 0x30(STATEP)
 626         movdqu STATE1, 0x40(STATEP)
 627         FRAME_END
 628         RET
 629
 630 .Ldec_out_3:
 631         movdqu STATE1, 0x00(STATEP)
 632         movdqu STATE2, 0x10(STATEP)
 633         movdqu STATE3, 0x20(STATEP)
 634         movdqu STATE4, 0x30(STATEP)
 635         movdqu STATE0, 0x40(STATEP)
 636         FRAME_END
 637         RET
 638
 639 .Ldec_out_4:
 640         movdqu STATE0, 0x00(STATEP)
 641         movdqu STATE1, 0x10(STATEP)
 642         movdqu STATE2, 0x20(STATEP)
 643         movdqu STATE3, 0x30(STATEP)
 644         movdqu STATE4, 0x40(STATEP)
 645         FRAME_END
 646         RET
 647
 648 .Ldec_out:
 649         FRAME_END
 650         RET
 651 SYM_FUNC_END(crypto_aegis128_aesni_dec)
 652
 653 /*
 654  * void crypto_aegis128_aesni_dec_tail(void *state, unsigned int length,
 655  *                                     const void *src, void *dst);
 656  */
 657 SYM_TYPED_FUNC_START(crypto_aegis128_aesni_dec_tail)
 658         FRAME_BEGIN
 659
 660         /* load the state: */
 661         movdqu 0x00(STATEP), STATE0
 662         movdqu 0x10(STATEP), STATE1
 663         movdqu 0x20(STATEP), STATE2
 664         movdqu 0x30(STATEP), STATE3
 665         movdqu 0x40(STATEP), STATE4
 666
 667         /* decrypt message: */
 668         call __load_partial
 669
 670         pxor STATE1, MSG
 671         pxor STATE4, MSG
 672         movdqa STATE2, T1
 673         pand STATE3, T1
 674         pxor T1, MSG
 675
 676         movdqa MSG, T0
 677         call __store_partial
 678
 679         /* mask with byte count: */
 680         movq LEN, T0
 681         punpcklbw T0, T0
 682         punpcklbw T0, T0
 683         punpcklbw T0, T0
 684         punpcklbw T0, T0
 685         movdqa .Laegis128_counter, T1
 686         pcmpgtb T1, T0
 687         pand T0, MSG
 688
 689         aegis128_update
 690         pxor MSG, STATE4
 691
 692         /* store the state: */
 693         movdqu STATE4, 0x00(STATEP)
 694         movdqu STATE0, 0x10(STATEP)
 695         movdqu STATE1, 0x20(STATEP)
 696         movdqu STATE2, 0x30(STATEP)
 697         movdqu STATE3, 0x40(STATEP)
 698
 699         FRAME_END
 700         RET
 701 SYM_FUNC_END(crypto_aegis128_aesni_dec_tail)
 702
 703 /*
 704  * void crypto_aegis128_aesni_final(void *state, void *tag_xor,
 705  *                                  u64 assoclen, u64 cryptlen);
 706  */
 707 SYM_FUNC_START(crypto_aegis128_aesni_final)
 708         FRAME_BEGIN
 709
 710         /* load the state: */
 711         movdqu 0x00(STATEP), STATE0
 712         movdqu 0x10(STATEP), STATE1
 713         movdqu 0x20(STATEP), STATE2
 714         movdqu 0x30(STATEP), STATE3
 715         movdqu 0x40(STATEP), STATE4
 716
 717         /* prepare length block: */
 718         movq %rdx, MSG
 719         movq %rcx, T0
 720         pslldq $8, T0
 721         pxor T0, MSG
 722         psllq $3, MSG /* multiply by 8 (to get bit count) */
 723
 724         pxor STATE3, MSG
 725
 726         /* update state: */
 727         aegis128_update; pxor MSG, STATE4
 728         aegis128_update; pxor MSG, STATE3
 729         aegis128_update; pxor MSG, STATE2
 730         aegis128_update; pxor MSG, STATE1
 731         aegis128_update; pxor MSG, STATE0
 732         aegis128_update; pxor MSG, STATE4
 733         aegis128_update; pxor MSG, STATE3
 734
 735         /* xor tag: */
 736         movdqu (%rsi), MSG
 737
 738         pxor STATE0, MSG
 739         pxor STATE1, MSG
 740         pxor STATE2, MSG
 741         pxor STATE3, MSG
 742         pxor STATE4, MSG
 743
 744         movdqu MSG, (%rsi)
 745
 746         FRAME_END
 747         RET
 748 SYM_FUNC_END(crypto_aegis128_aesni_final)