mirror/gmsm
1
0
Fork 0
mirror of https://github.com/emmansun/gmsm.git synced 2025-04-26 20:26:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

subtle: combine xor_<goarch>.go files #304

Browse Source
This commit is contained in:
Sun Yimin 2025-02-17 08:32:20 +08:00 committed by GitHub
parent a248fea7f9
commit 1aed89febd
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 176 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/sm2.md
View File

@ -186,7 +186,9 @@ func ExampleVerifyASN1WithSM2() {
} }
``` ```
### 如何处理不用UID的签名、验签？ ### 如何处理不用Z的签名、验签？
所谓**Z**，就是用户可识别标识符和用户公钥、SM2椭圆曲线参数的杂凑值。其它签名算法如ECDSA是没有这个**Z**的，这也是SM2签名算法难以融入以ECDSA签名算法为主的体系的主因。
#### 签名 #### 签名
也是使用sm2私钥的`Sign`方法，只是```SignerOpts```传入`nil`或者其它非`SM2SignerOption`即可，那么，你自己负责预先计算杂凑值，当然如何计算杂凑值，由你自己说了算了。 也是使用sm2私钥的`Sign`方法，只是```SignerOpts```传入`nil`或者其它非`SM2SignerOption`即可，那么，你自己负责预先计算杂凑值，当然如何计算杂凑值，由你自己说了算了。

10
internal/subtle/xor_arm64.go
View File

@ -1,10 +0,0 @@
// Copyright 2018 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.
//
//go:build !purego
package subtle
//go:noescape
func xorBytes(dst, a, b *byte, n int)

2
internal/subtle/xor_amd64.go → internal/subtle/xor_asm.go
View File

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
// //
//go:build !purego //go:build !purego && (amd64 || arm64 || ppc64 || ppc64le || riscv64 || s390x)
package subtle package subtle

10
internal/subtle/xor_ppc64x.go
View File

@ -1,10 +0,0 @@
// Copyright 2018 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.
//go:build (ppc64 || ppc64le) && !purego
package subtle
//go:noescape
func xorBytes(dst, a, b *byte, n int)

10
internal/subtle/xor_riscv64.go
View File

@ -1,10 +0,0 @@
// Copyright 2024 Sun Yimin. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
//go:build !purego
package subtle
//go:noescape
func xorBytes(dst, a, b *byte, n int)

196
internal/subtle/xor_riscv64.s
View File

@ -8,56 +8,162 @@
// func xorBytes(dst, a, b *byte, n int) // func xorBytes(dst, a, b *byte, n int)
TEXT ·xorBytes(SB), NOSPLIT|NOFRAME, $0 TEXT ·xorBytes(SB), NOSPLIT|NOFRAME, $0
MOV dst+0(FP), X5 MOV dst+0(FP), X10
MOV a+8(FP), X6 MOV a+8(FP), X11
MOV b+16(FP), X7 MOV b+16(FP), X12
MOV n+24(FP), X8 MOV n+24(FP), X13
MOV $8, X9 MOV $32, X15
BLTU X8, X9, tail BLT X13, X15, loop4_check
loop: // Check alignment - if alignment differs we have to do one byte at a time.
MOV (X6), X10 AND $7, X10, X5
MOV (X7), X11 AND $7, X11, X6
XOR X10, X11, X10 AND $7, X12, X7
MOV X10, (X5) BNE X5, X6, loop4_check
ADD $8, X5 BNE X5, X7, loop4_check
ADD $8, X6 BEQZ X5, loop64_check
ADD $8, X7
SUB $8, X8
BGEU X8, X9, loop
tail: // Check one byte at a time until we reach 8 byte alignment.
BEQZ X8, done MOV $8, X8
MOV $4, X9 SUB X5, X8
BLTU X8, X9, less_than4 SUB X8, X13
MOVWU (X6), X10 align:
MOVWU (X7), X11 MOVBU 0(X11), X16
XOR X10, X11, X10 MOVBU 0(X12), X17
MOVW X10, (X5) XOR X16, X17
ADD $4, X5 MOVB X17, 0(X10)
ADD $4, X6 ADD $1, X10
ADD $4, X7 ADD $1, X11
SUB $4, X8 ADD $1, X12
SUB $1, X8
BNEZ X8, align
less_than4: loop64_check:
MOV $2, X9 MOV $64, X15
BLTU X8, X9, less_than2 BLT X13, X15, tail32_check
MOVHU (X6), X10 PCALIGN $16
MOVHU (X7), X11 loop64:
XOR X10, X11, X10 MOV 0(X11), X16
MOVH X10, (X5) MOV 0(X12), X17
ADD $2, X5 MOV 8(X11), X18
ADD $2, X6 MOV 8(X12), X19
ADD $2, X7 XOR X16, X17
SUB $2, X8 XOR X18, X19
MOV X17, 0(X10)
MOV X19, 8(X10)
MOV 16(X11), X20
MOV 16(X12), X21
MOV 24(X11), X22
MOV 24(X12), X23
XOR X20, X21
XOR X22, X23
MOV X21, 16(X10)
MOV X23, 24(X10)
MOV 32(X11), X16
MOV 32(X12), X17
MOV 40(X11), X18
MOV 40(X12), X19
XOR X16, X17
XOR X18, X19
MOV X17, 32(X10)
MOV X19, 40(X10)
MOV 48(X11), X20
MOV 48(X12), X21
MOV 56(X11), X22
MOV 56(X12), X23
XOR X20, X21
XOR X22, X23
MOV X21, 48(X10)
MOV X23, 56(X10)
ADD $64, X10
ADD $64, X11
ADD $64, X12
SUB $64, X13
BGE X13, X15, loop64
BEQZ X13, done
less_than2: tail32_check:
BEQZ X8, done MOV $32, X15
MOVBU (X6), X10 BLT X13, X15, tail16_check
MOVBU (X7), X11 MOV 0(X11), X16
XOR X10, X11, X10 MOV 0(X12), X17
MOVB X10, (X5) MOV 8(X11), X18
MOV 8(X12), X19
XOR X16, X17
XOR X18, X19
MOV X17, 0(X10)
MOV X19, 8(X10)
MOV 16(X11), X20
MOV 16(X12), X21
MOV 24(X11), X22
MOV 24(X12), X23
XOR X20, X21
XOR X22, X23
MOV X21, 16(X10)
MOV X23, 24(X10)
ADD $32, X10
ADD $32, X11
ADD $32, X12
SUB $32, X13
BEQZ X13, done
tail16_check:
MOV $16, X15
BLT X13, X15, loop4_check
MOV 0(X11), X16
MOV 0(X12), X17
MOV 8(X11), X18
MOV 8(X12), X19
XOR X16, X17
XOR X18, X19
MOV X17, 0(X10)
MOV X19, 8(X10)
ADD $16, X10
ADD $16, X11
ADD $16, X12
SUB $16, X13
BEQZ X13, done
loop4_check:
MOV $4, X15
BLT X13, X15, loop1
PCALIGN $16
loop4:
MOVBU 0(X11), X16
MOVBU 0(X12), X17
MOVBU 1(X11), X18
MOVBU 1(X12), X19
XOR X16, X17
XOR X18, X19
MOVB X17, 0(X10)
MOVB X19, 1(X10)
MOVBU 2(X11), X20
MOVBU 2(X12), X21
MOVBU 3(X11), X22
MOVBU 3(X12), X23
XOR X20, X21
XOR X22, X23
MOVB X21, 2(X10)
MOVB X23, 3(X10)
ADD $4, X10
ADD $4, X11
ADD $4, X12
SUB $4, X13
BGE X13, X15, loop4
PCALIGN $16
loop1:
BEQZ X13, done
MOVBU 0(X11), X16
MOVBU 0(X12), X17
XOR X16, X17
MOVB X17, 0(X10)
ADD $1, X10
ADD $1, X11
ADD $1, X12
SUB $1, X13
JMP loop1
done: done:
RET RET

10
internal/subtle/xor_s390x.go
View File

@ -1,10 +0,0 @@
// Copyright 2024 Sun Yimin. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
//go:build !purego
package subtle
//go:noescape
func xorBytes(dst, a, b *byte, n int)

22
internal/subtle/xor_test.go
View File

@ -72,7 +72,7 @@ func BenchmarkXORBytes(b *testing.B) {
dst := make([]byte, 1<<15) dst := make([]byte, 1<<15)
data0 := make([]byte, 1<<15) data0 := make([]byte, 1<<15)
data1 := make([]byte, 1<<15) data1 := make([]byte, 1<<15)
sizes := []int64{1 << 3, 1 << 4, 1 << 5, 1 << 7, 1 << 11, 1 << 15} sizes := []int64{1 << 3, 1 << 4, 1 << 5, 1 << 7, 1 << 11, 1 << 13, 1 << 15}
for _, size := range sizes { for _, size := range sizes {
b.Run(fmt.Sprintf("%dBytes", size), func(b *testing.B) { b.Run(fmt.Sprintf("%dBytes", size), func(b *testing.B) {
s0 := data0[:size] s0 := data0[:size]
@ -85,6 +85,26 @@ func BenchmarkXORBytes(b *testing.B) {
} }
} }
func BenchmarkXORBytesAlignment(b *testing.B) {
dst := make([]byte, 8+1<<11)
data0 := make([]byte, 8+1<<11)
data1 := make([]byte, 8+1<<11)
sizes := []int64{1 << 3, 1 << 7, 1 << 11}
for _, size := range sizes {
for offset := int64(0); offset < 8; offset++ {
b.Run(fmt.Sprintf("%dBytes%dOffset", size, offset), func(b *testing.B) {
d := dst[offset : offset+size]
s0 := data0[offset : offset+size]
s1 := data1[offset : offset+size]
b.SetBytes(int64(size))
for i := 0; i < b.N; i++ {
subtle.XORBytes(d, s0, s1)
}
})
}
}
}
func mustPanic(t *testing.T, expected string, f func()) { func mustPanic(t *testing.T, expected string, f func()) {
t.Helper() t.Helper()
defer func() { defer func() {