0.5.0-alpha

.github/workflows/test.yml

@@ -7,10 +7,20 @@ on:
 
 jobs:
   test-project:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
+      - run: uname -a
+      - run: lsb_release -a
+
+      - name: Setup
+        uses: actions/setup-go@v4
+        with:
+          go-version: "1.25"
+
+      - run: go version
+
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Test
-        run: make test
+        run: make test

FUTURE.md

@@ -1,20 +1,24 @@
 ## ✈️ 未来版本的新特性 (Features in future versions)
 
-### v0.5.x
+### v0.6.x
 
 * [ ] 增加 cmd 包，提供二进制 cli 使用
 * [ ] 支持 SM3 国标算法
 * [ ] 支持 SM4 国标算法
-* [ ] 支持 ECC key 生成
-* [ ] 支持 ECC 非对称加密算法
 * [ ] 支持更多的散列算法
 
+### v0.5.x
+
+* [ ] 支持 ECDSA 算法
+* [ ] 支持 EdDSA 算法
+* [x] 重构代码，优化使用方式
+* [ ] 提升覆盖率到 90% 以上
+
 ### v0.4.x
 
 * [x] 调整 hash 包使用姿势
 * [x] 大规模重构，优化代码使用
 * [x] 性能优化，尝试减少内存分配
-* [ ] 继续完善单元测试，提升覆盖率到 90%
 
 ### v0.3.x
 

HISTORY.md

@@ -1,5 +1,12 @@
 ## 📜 历史版本的特性介绍 (Features in old versions)
 
+### v0.5.0-alpha
+
+> 此版本发布于 2025-12-05
+
+* 重构版本，目前看着顺眼一些了
+* 周董这么突然就发了个专辑。。
+
 ### v0.4.3
 
 > 此版本发布于 2024-06-02

Makefile

@@ -6,10 +6,9 @@ fmt:
 	go fmt ./...
 
 test:
-	go test -cover -count=1 -test.cpu=1 ./...
+	go test -v -cover ./...
 
 bench:
-	go test -v ./_examples/rand_test.go -bench=. -benchtime=1s
 	go test -v ./_examples/hash_test.go -bench=. -benchtime=1s
 	go test -v ./_examples/hmac_test.go -bench=. -benchtime=1s
 	go test -v ./_examples/des_test.go -bench=. -benchtime=1s

_examples/aes.go

@@ -8,39 +8,32 @@ import (
 	"bytes"
 	"fmt"
 
-	"github.com/FishGoddess/cryptox"
 	"github.com/FishGoddess/cryptox/aes"
 )
 
 func main() {
 	// As you know, key is necessary in aes.
 	// However, not all modes need iv, such as ecb.
 	key := []byte("12345678876543211234567887654321")
-	iv := []byte("8765432112345678")
+	nonce := []byte("123456abcdef")
 
-	msg := []byte("你好，世界")
-	fmt.Printf("msg: %s\n", msg)
+	data := []byte("你好，世界")
+	fmt.Printf("data: %s\n", data)
 
-	// We use ctr mode and no padding to encrypt data.
-	// Of course, you can choose another mode if you want.
-	// Also, you can choose no/zero/pkcs5/pkcs7 to padding data.
-	encrypted, err := aes.EncryptCTR(key, iv, cryptox.PaddingNone, msg)
+	// Use gcm mode to encrypt data with no padding and encoding base64.
+	encrypt, err := aes.EncryptGCM(data, key, nonce, aes.WithBase64())
 	if err != nil {
 		panic(err)
 	}
 
-	fmt.Println("encrypted:", encrypted)
-	fmt.Println("encrypted hex:", encrypted.Hex())
-	fmt.Println("encrypted base64:", encrypted.Base64())
+	fmt.Printf("encrypt: %s\n", encrypt)
 
-	// We use ctr mode and no padding to decrypt data.
-	// Of course, you can choose another mode if you want.
-	// Also, you can choose no/zero/pkcs5/pkcs7 to undo padding data.
-	decrypted, err := aes.DecryptCTR(key, iv, cryptox.PaddingNone, encrypted)
+	// Decrypt data in the same way.
+	decrypt, err := aes.DecryptGCM(encrypt, key, nonce, aes.WithBase64())
 	if err != nil {
 		panic(err)
 	}
 
-	fmt.Printf("decrypted: %s\n", decrypted)
-	fmt.Println("decrypted == msg", bytes.Equal(decrypted, msg))
+	fmt.Printf("decrypt: %s\n", decrypt)
+	fmt.Printf("decrypt is right: %+v\n", bytes.Equal(decrypt, data))
 }

_examples/aes_test.go

@@ -7,98 +7,97 @@ package main
 import (
 	"testing"
 
-	"github.com/FishGoddess/cryptox"
 	"github.com/FishGoddess/cryptox/aes"
 )
 
 var (
 	aesBenchKey   = []byte("12345678876543211234567887654321")
 	aesBenchIV    = []byte("8765432112345678")
 	aesBenchNonce = []byte("123456abcdef")
-	aesBenchMsg   = cryptox.GenerateBytes(128)
+	aesBenchMsg   = make([]byte, 128)
 )
 
-// go test -v -bench=^BenchmarkAESEncryptECB$ -benchtime=1s aes_test.go
-func BenchmarkAESEncryptECB(b *testing.B) {
+// go test -v -bench=^BenchmarkAES_EncryptECB$ -benchtime=1s des_test.go
+func BenchmarkAES_EncryptECB(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.EncryptECB(aesBenchKey, cryptox.PaddingPKCS7, aesBenchMsg)
+		_, err := aes.EncryptECB(aesBenchMsg, aesBenchKey, aes.WithPKCS7())
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESEncryptCBC$ -benchtime=1s aes_test.go
-func BenchmarkAESEncryptCBC(b *testing.B) {
+// go test -v -bench=^BenchmarkAES_EncryptCBC$ -benchtime=1s des_test.go
+func BenchmarkAES_EncryptCBC(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.EncryptCBC(aesBenchKey, aesBenchIV, cryptox.PaddingPKCS7, aesBenchMsg)
+		_, err := aes.EncryptCBC(aesBenchMsg, aesBenchKey, aesBenchIV, aes.WithPKCS7())
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESEncryptCFB$ -benchtime=1s aes_test.go
-func BenchmarkAESEncryptCFB(b *testing.B) {
+// go test -v -bench=^BenchmarkAES_EncryptCFB$ -benchtime=1s des_test.go
+func BenchmarkAES_EncryptCFB(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.EncryptCFB(aesBenchKey, aesBenchIV, cryptox.PaddingNone, aesBenchMsg)
+		_, err := aes.EncryptCFB(aesBenchMsg, aesBenchKey, aesBenchIV)
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESEncryptOFB$ -benchtime=1s aes_test.go
-func BenchmarkAESEncryptOFB(b *testing.B) {
+// go test -v -bench=^BenchmarkAES_EncryptOFB$ -benchtime=1s des_test.go
+func BenchmarkAES_EncryptOFB(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.EncryptOFB(aesBenchKey, aesBenchIV, cryptox.PaddingNone, aesBenchMsg)
+		_, err := aes.EncryptOFB(aesBenchMsg, aesBenchKey, aesBenchIV)
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESEncryptCTR$ -benchtime=1s aes_test.go
-func BenchmarkAESEncryptCTR(b *testing.B) {
+// go test -v -bench=^BenchmarkAES_EncryptCTR$ -benchtime=1s des_test.go
+func BenchmarkAES_EncryptCTR(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.EncryptCTR(aesBenchKey, aesBenchIV, cryptox.PaddingNone, aesBenchMsg)
+		_, err := aes.EncryptCTR(aesBenchMsg, aesBenchKey, aesBenchIV)
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESEncryptGCM$ -benchtime=1s aes_test.go
-func BenchmarkAESEncryptGCM(b *testing.B) {
+// go test -v -bench=^BenchmarkAES_EncryptGCM$ -benchtime=1s aes_test.go
+func BenchmarkAES_EncryptGCM(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.EncryptGCM(aesBenchKey, aesBenchNonce, nil, aesBenchMsg)
+		_, err := aes.EncryptGCM(aesBenchMsg, aesBenchKey, aesBenchNonce)
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESDecryptECB$ -benchtime=1s aes_test.go
-func BenchmarkAESDecryptECB(b *testing.B) {
-	encrypted, err := aes.EncryptECB(aesBenchKey, cryptox.PaddingPKCS7, aesBenchMsg)
+// go test -v -bench=^BenchmarkAES_DecryptECB$ -benchtime=1s des_test.go
+func BenchmarkAES_DecryptECB(b *testing.B) {
+	encrypt, err := aes.EncryptECB(aesBenchMsg, aesBenchKey, aes.WithPKCS7())
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -107,16 +106,16 @@ func BenchmarkAESDecryptECB(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.DecryptECB(aesBenchKey, cryptox.PaddingPKCS7, encrypted)
+		_, err := aes.DecryptECB(encrypt, aesBenchKey, aes.WithPKCS7())
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESDecryptCBC$ -benchtime=1s aes_test.go
-func BenchmarkAESDecryptCBC(b *testing.B) {
-	encrypted, err := aes.EncryptCBC(aesBenchKey, aesBenchIV, cryptox.PaddingPKCS7, aesBenchMsg)
+// go test -v -bench=^BenchmarkAES_DecryptCBC$ -benchtime=1s des_test.go
+func BenchmarkAES_DecryptCBC(b *testing.B) {
+	encrypt, err := aes.EncryptCBC(aesBenchMsg, aesBenchKey, aesBenchIV, aes.WithPKCS7())
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -125,16 +124,16 @@ func BenchmarkAESDecryptCBC(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.DecryptCBC(aesBenchKey, aesBenchIV, cryptox.PaddingPKCS7, encrypted)
+		_, err := aes.DecryptCBC(encrypt, aesBenchKey, aesBenchIV, aes.WithPKCS7())
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESDecryptCFB$ -benchtime=1s aes_test.go
-func BenchmarkAESDecryptCFB(b *testing.B) {
-	encrypted, err := aes.EncryptCFB(aesBenchKey, aesBenchIV, cryptox.PaddingNone, aesBenchMsg)
+// go test -v -bench=^BenchmarkAES_DecryptCFB$ -benchtime=1s des_test.go
+func BenchmarkAES_DecryptCFB(b *testing.B) {
+	encrypt, err := aes.EncryptCFB(aesBenchMsg, aesBenchKey, aesBenchIV)
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -143,16 +142,16 @@ func BenchmarkAESDecryptCFB(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.DecryptCFB(aesBenchKey, aesBenchIV, cryptox.PaddingNone, encrypted)
+		_, err := aes.DecryptCFB(encrypt, aesBenchKey, aesBenchIV)
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESDecryptOFB$ -benchtime=1s aes_test.go
-func BenchmarkAESDecryptOFB(b *testing.B) {
-	encrypted, err := aes.EncryptOFB(aesBenchKey, aesBenchIV, cryptox.PaddingNone, aesBenchMsg)
+// go test -v -bench=^BenchmarkAES_DecryptOFB$ -benchtime=1s des_test.go
+func BenchmarkAES_DecryptOFB(b *testing.B) {
+	encrypt, err := aes.EncryptOFB(aesBenchMsg, aesBenchKey, aesBenchIV)
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -161,16 +160,16 @@ func BenchmarkAESDecryptOFB(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.DecryptOFB(aesBenchKey, aesBenchIV, cryptox.PaddingNone, encrypted)
+		_, err := aes.DecryptOFB(encrypt, aesBenchKey, aesBenchIV)
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESDecryptCTR$ -benchtime=1s aes_test.go
-func BenchmarkAESDecryptCTR(b *testing.B) {
-	encrypted, err := aes.EncryptCTR(aesBenchKey, aesBenchIV, cryptox.PaddingNone, aesBenchMsg)
+// go test -v -bench=^BenchmarkAES_DecryptCTR$ -benchtime=1s des_test.go
+func BenchmarkAES_DecryptCTR(b *testing.B) {
+	encrypt, err := aes.EncryptCTR(aesBenchMsg, aesBenchKey, aesBenchIV)
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -179,16 +178,16 @@ func BenchmarkAESDecryptCTR(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.DecryptCTR(aesBenchKey, aesBenchIV, cryptox.PaddingNone, encrypted)
+		_, err := aes.DecryptCTR(encrypt, aesBenchKey, aesBenchIV)
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
-// go test -v -bench=^BenchmarkAESDecryptGCM$ -benchtime=1s aes_test.go
-func BenchmarkAESDecryptGCM(b *testing.B) {
-	encrypted, err := aes.EncryptGCM(aesBenchKey, aesBenchNonce, nil, aesBenchMsg)
+// go test -v -bench=^BenchmarkAES_DecryptGCM$ -benchtime=1s aes_test.go
+func BenchmarkAES_DecryptGCM(b *testing.B) {
+	encrypt, err := aes.EncryptGCM(aesBenchMsg, aesBenchKey, aesBenchNonce)
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -197,7 +196,7 @@ func BenchmarkAESDecryptGCM(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := aes.DecryptGCM(aesBenchKey, aesBenchNonce, nil, encrypted)
+		_, err := aes.DecryptGCM(encrypt, aesBenchKey, aesBenchNonce)
 		if err != nil {
 			b.Fatal(err)
 		}