| // Copyright 2016 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| #include "textflag.h" | |
| // func cryptBlocks(c code, key, dst, src *byte, length int) | |
| TEXT ·cryptBlocks(SB),NOSPLIT,$0-40 | |
| MOVD key+8(FP), R1 | |
| MOVD dst+16(FP), R2 | |
| MOVD src+24(FP), R4 | |
| MOVD length+32(FP), R5 | |
| MOVD c+0(FP), R0 | |
| loop: | |
| WORD $0xB92E0024 // cipher message (KM) | |
| BVS loop // branch back if interrupted | |
| XOR R0, R0 | |
| RET | |
| // func cryptBlocksChain(c code, iv, key, dst, src *byte, length int) | |
| TEXT ·cryptBlocksChain(SB),NOSPLIT,$48-48 | |
| LA params-48(SP), R1 | |
| MOVD iv+8(FP), R8 | |
| MOVD key+16(FP), R9 | |
| MVC $16, 0(R8), 0(R1) // move iv into params | |
| MVC $32, 0(R9), 16(R1) // move key into params | |
| MOVD dst+24(FP), R2 | |
| MOVD src+32(FP), R4 | |
| MOVD length+40(FP), R5 | |
| MOVD c+0(FP), R0 | |
| loop: | |
| WORD $0xB92F0024 // cipher message with chaining (KMC) | |
| BVS loop // branch back if interrupted | |
| XOR R0, R0 | |
| MVC $16, 0(R1), 0(R8) // update iv | |
| RET | |
| // func xorBytes(dst, a, b []byte) int | |
| TEXT ·xorBytes(SB),NOSPLIT,$0-80 | |
| MOVD dst_base+0(FP), R1 | |
| MOVD a_base+24(FP), R2 | |
| MOVD b_base+48(FP), R3 | |
| MOVD a_len+32(FP), R4 | |
| MOVD b_len+56(FP), R5 | |
| CMPBLE R4, R5, skip | |
| MOVD R5, R4 | |
| skip: | |
| MOVD R4, ret+72(FP) | |
| MOVD $0, R5 | |
| CMPBLT R4, $8, tail | |
| loop: | |
| MOVD 0(R2)(R5*1), R7 | |
| MOVD 0(R3)(R5*1), R8 | |
| XOR R7, R8 | |
| MOVD R8, 0(R1)(R5*1) | |
| LAY 8(R5), R5 | |
| SUB $8, R4 | |
| CMPBGE R4, $8, loop | |
| tail: | |
| CMPBEQ R4, $0, done | |
| MOVB 0(R2)(R5*1), R7 | |
| MOVB 0(R3)(R5*1), R8 | |
| XOR R7, R8 | |
| MOVB R8, 0(R1)(R5*1) | |
| LAY 1(R5), R5 | |
| SUB $1, R4 | |
| BR tail | |
| done: | |
| RET | |
| // func cryptBlocksGCM(fn code, key, dst, src, buf []byte, cnt *[16]byte) | |
| TEXT ·cryptBlocksGCM(SB),NOSPLIT,$0-112 | |
| MOVD src_len+64(FP), R0 | |
| MOVD buf_base+80(FP), R1 | |
| MOVD cnt+104(FP), R12 | |
| LMG (R12), R2, R3 | |
| // Check that the src size is less than or equal to the buffer size. | |
| MOVD buf_len+88(FP), R4 | |
| CMP R0, R4 | |
| BGT crash | |
| // Check that the src size is a multiple of 16-bytes. | |
| MOVD R0, R4 | |
| AND $0xf, R4 | |
| BLT crash // non-zero | |
| // Check that the src size is less than or equal to the dst size. | |
| MOVD dst_len+40(FP), R4 | |
| CMP R0, R4 | |
| BGT crash | |
| MOVD R2, R4 | |
| MOVD R2, R6 | |
| MOVD R2, R8 | |
| MOVD R3, R5 | |
| MOVD R3, R7 | |
| MOVD R3, R9 | |
| ADDW $1, R5 | |
| ADDW $2, R7 | |
| ADDW $3, R9 | |
| incr: | |
| CMP R0, $64 | |
| BLT tail | |
| STMG R2, R9, (R1) | |
| ADDW $4, R3 | |
| ADDW $4, R5 | |
| ADDW $4, R7 | |
| ADDW $4, R9 | |
| MOVD $64(R1), R1 | |
| SUB $64, R0 | |
| BR incr | |
| tail: | |
| CMP R0, $0 | |
| BEQ crypt | |
| STMG R2, R3, (R1) | |
| ADDW $1, R3 | |
| MOVD $16(R1), R1 | |
| SUB $16, R0 | |
| BR tail | |
| crypt: | |
| STMG R2, R3, (R12) // update next counter value | |
| MOVD fn+0(FP), R0 // function code (encryption) | |
| MOVD key_base+8(FP), R1 // key | |
| MOVD buf_base+80(FP), R2 // counter values | |
| MOVD dst_base+32(FP), R4 // dst | |
| MOVD src_base+56(FP), R6 // src | |
| MOVD src_len+64(FP), R7 // len | |
| loop: | |
| WORD $0xB92D2046 // cipher message with counter (KMCTR) | |
| BVS loop // branch back if interrupted | |
| RET | |
| crash: | |
| MOVD $0, (R0) | |
| RET | |
| // func ghash(key *gcmHashKey, hash *[16]byte, data []byte) | |
| TEXT ·ghash(SB),NOSPLIT,$32-40 | |
| MOVD $65, R0 // GHASH function code | |
| MOVD key+0(FP), R2 | |
| LMG (R2), R6, R7 | |
| MOVD hash+8(FP), R8 | |
| LMG (R8), R4, R5 | |
| MOVD $params-32(SP), R1 | |
| STMG R4, R7, (R1) | |
| LMG data+16(FP), R2, R3 // R2=base, R3=len | |
| loop: | |
| WORD $0xB93E0002 // compute intermediate message digest (KIMD) | |
| BVS loop // branch back if interrupted | |
| MVC $16, (R1), (R8) | |
| MOVD $0, R0 | |
| RET | |
| // func kmaGCM(fn code, key, dst, src, aad []byte, tag *[16]byte, cnt *gcmCount) | |
| TEXT ·kmaGCM(SB),NOSPLIT,$112-120 | |
| MOVD fn+0(FP), R0 | |
| MOVD $params-112(SP), R1 | |
| // load ptr/len pairs | |
| LMG dst+32(FP), R2, R3 // R2=base R3=len | |
| LMG src+56(FP), R4, R5 // R4=base R5=len | |
| LMG aad+80(FP), R6, R7 // R6=base R7=len | |
| // setup parameters | |
| MOVD cnt+112(FP), R8 | |
| XC $12, (R1), (R1) // reserved | |
| MVC $4, 12(R8), 12(R1) // set chain value | |
| MVC $16, (R8), 64(R1) // set initial counter value | |
| XC $32, 16(R1), 16(R1) // set hash subkey and tag | |
| SLD $3, R7, R12 | |
| MOVD R12, 48(R1) // set total AAD length | |
| SLD $3, R5, R12 | |
| MOVD R12, 56(R1) // set total plaintext/ciphertext length | |
| LMG key+8(FP), R8, R9 // R8=base R9=len | |
| MVC $16, (R8), 80(R1) // set key | |
| CMPBEQ R9, $16, kma | |
| MVC $8, 16(R8), 96(R1) | |
| CMPBEQ R9, $24, kma | |
| MVC $8, 24(R8), 104(R1) | |
| kma: | |
| WORD $0xb9296024 // kma %r6,%r2,%r4 | |
| BVS kma | |
| MOVD tag+104(FP), R2 | |
| MVC $16, 16(R1), 0(R2) // copy tag to output | |
| MOVD cnt+112(FP), R8 | |
| MVC $4, 12(R1), 12(R8) // update counter value | |
| RET |