fix: add rsa public and private key example file

set : when the key is present, the value of the data map should be set,
not the value of the list

Co-authored-by: congziqi <congziqi@lixiang.com>

.gitignore

@@ -8,7 +8,7 @@ fileutil/*.link
 fileutil/unzip/*
 fileutil/tempdir/*
 slice/testdata/*
-cryptor/*.pem
+# cryptor/*.pem
 test
 docs/node_modules
 docs/.vitepress/cache

cryptor/crypto.go

@@ -8,16 +8,20 @@ package cryptor
 
 import (
 	"bytes"
+	"crypto"
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/des"
 	"crypto/rand"
 	"crypto/rsa"
 	"crypto/sha256"
+	"crypto/sha512"
 	"crypto/x509"
 	"encoding/pem"
+	"errors"
 	"io"
 	"os"
+	"strings"
 )
 
 // AesEcbEncrypt encrypt data with key use AES ECB algorithm
@@ -591,6 +595,7 @@ func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
 	if err != nil {
 		panic(err)
 	}
+
 	return cipherText
 }
 
@@ -624,6 +629,7 @@ func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
 	if err != nil {
 		panic(err)
 	}
+
 	return plainText
 }
 
@@ -655,3 +661,150 @@ func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte
 
 	return decryptedBytes, nil
 }
+
+// RsaSign signs the data with RSA.
+// Play: todo
+func RsaSign(hash crypto.Hash, data []byte, privateKeyFileName string) ([]byte, error) {
+	privateKey, err := loadRasPrivateKey(privateKeyFileName)
+	if err != nil {
+		return nil, err
+	}
+
+	hashed, err := hashData(hash, data)
+	if err != nil {
+		return nil, err
+	}
+
+	return rsa.SignPKCS1v15(rand.Reader, privateKey, hash, hashed)
+}
+
+// RsaVerifySign verifies the signature of the data with RSA.
+// Play: todo
+func RsaVerifySign(hash crypto.Hash, data, signature []byte, pubKeyFileName string) error {
+	publicKey, err := loadRsaPublicKey(pubKeyFileName)
+	if err != nil {
+		return err
+	}
+
+	hashed, err := hashData(hash, data)
+	if err != nil {
+		return err
+	}
+
+	return rsa.VerifyPKCS1v15(publicKey, hash, hashed, signature)
+}
+
+// loadRsaPrivateKey loads and parses a PEM encoded private key file.
+func loadRsaPublicKey(filename string) (*rsa.PublicKey, error) {
+	pubKeyData, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	block, _ := pem.Decode(pubKeyData)
+	if block == nil {
+		return nil, errors.New("failed to decode PEM block containing the public key")
+	}
+
+	var pubKey *rsa.PublicKey
+	blockType := strings.ToUpper(block.Type)
+
+	if blockType == "RSA PUBLIC KEY" {
+		pubKey, err = x509.ParsePKCS1PublicKey(block.Bytes)
+		if err != nil {
+			// todo: here should be a bug, should return nil, err
+			key, err := x509.ParsePKIXPublicKey(block.Bytes)
+			if err != nil {
+				return nil, err
+			}
+
+			var ok bool
+			pubKey, ok = key.(*rsa.PublicKey)
+			if !ok {
+				return nil, errors.New("failed to parse RSA private key")
+			}
+		}
+	} else if blockType == "PUBLIC KEY" {
+		key, err := x509.ParsePKIXPublicKey(block.Bytes)
+		if err != nil {
+			return nil, err
+		}
+
+		var ok bool
+		pubKey, ok = key.(*rsa.PublicKey)
+		if !ok {
+			return nil, errors.New("failed to parse RSA private key")
+		}
+
+	} else {
+		return nil, errors.New("unsupported key type")
+	}
+
+	return pubKey, nil
+}
+
+// loadRsaPrivateKey loads and parses a PEM encoded private key file.
+func loadRasPrivateKey(filename string) (*rsa.PrivateKey, error) {
+	priKeyData, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	block, _ := pem.Decode(priKeyData)
+	if block == nil {
+		return nil, errors.New("failed to decode PEM block containing the private key")
+	}
+
+	var privateKey *rsa.PrivateKey
+	blockType := strings.ToUpper(block.Type)
+
+	// PKCS#1 format
+	if blockType == "RSA PRIVATE KEY" {
+		privateKey, err = x509.ParsePKCS1PrivateKey(block.Bytes)
+		if err != nil {
+			return nil, err
+		}
+	} else if blockType == "PRIVATE KEY" { // PKCS#8 format
+		priKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
+		if err != nil {
+			return nil, err
+		}
+		var ok bool
+		privateKey, ok = priKey.(*rsa.PrivateKey)
+		if !ok {
+			return nil, errors.New("failed to parse RSA private key")
+		}
+	} else {
+		return nil, errors.New("unsupported key type")
+	}
+
+	return privateKey, nil
+}
+
+// hashData returns the hash value of the data, using the specified hash function
+func hashData(hash crypto.Hash, data []byte) ([]byte, error) {
+	if !hash.Available() {
+		return nil, errors.New("unsupported hash algorithm")
+	}
+
+	var hashed []byte
+
+	switch hash {
+	case crypto.SHA224:
+		h := sha256.Sum224(data)
+		hashed = h[:]
+	case crypto.SHA256:
+		h := sha256.Sum256(data)
+		hashed = h[:]
+	case crypto.SHA384:
+		h := sha512.Sum384(data)
+		hashed = h[:]
+	case crypto.SHA512:
+		h := sha512.Sum512(data)
+		hashed = h[:]
+	default:
+		return nil, errors.New("unsupported hash algorithm")
+	}
+
+	return hashed, nil
+}

cryptor/crypto_example_test.go

@@ -1,6 +1,7 @@
 package cryptor
 
 import (
+	"crypto"
 	"fmt"
 )
 
@@ -284,7 +285,7 @@ func ExampleDesOfbDecrypt() {
 
 func ExampleGenerateRsaKey() {
 	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
 	if err != nil {
 		return
 	}
@@ -297,14 +298,14 @@ func ExampleGenerateRsaKey() {
 
 func ExampleRsaEncrypt() {
 	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
 	if err != nil {
 		return
 	}
 
 	data := []byte("hello")
-	encrypted := RsaEncrypt(data, "rsa_public.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+	encrypted := RsaEncrypt(data, "rsa_public_example.pem")
+	decrypted := RsaDecrypt(encrypted, "rsa_private_example.pem")
 
 	fmt.Println(string(decrypted))
 
@@ -314,14 +315,14 @@ func ExampleRsaEncrypt() {
 
 func ExampleRsaDecrypt() {
 	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
 	if err != nil {
 		return
 	}
 
 	data := []byte("hello")
-	encrypted := RsaEncrypt(data, "rsa_public.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+	encrypted := RsaEncrypt(data, "rsa_public_example.pem")
+	decrypted := RsaDecrypt(encrypted, "rsa_private_example.pem")
 
 	fmt.Println(string(decrypted))
 
@@ -536,3 +537,49 @@ func ExampleRsaEncryptOAEP() {
 	// Output:
 	// hello world
 }
+
+func ExampleRsaSign() {
+	data := []byte("This is a test data for RSA signing")
+	hash := crypto.SHA256
+
+	privateKey := "./rsa_private_example.pem"
+	publicKey := "./rsa_public_example.pem"
+
+	signature, err := RsaSign(hash, data, privateKey)
+	if err != nil {
+		return
+	}
+
+	err = RsaVerifySign(hash, data, signature, publicKey)
+	if err != nil {
+		return
+	}
+
+	fmt.Println("ok")
+
+	// Output:
+	// ok
+}
+
+func ExampleRsaVerifySign() {
+	data := []byte("This is a test data for RSA signing")
+	hash := crypto.SHA256
+
+	privateKey := "./rsa_private_example.pem"
+	publicKey := "./rsa_public_example.pem"
+
+	signature, err := RsaSign(hash, data, privateKey)
+	if err != nil {
+		return
+	}
+
+	err = RsaVerifySign(hash, data, signature, publicKey)
+	if err != nil {
+		return
+	}
+
+	fmt.Println("ok")
+
+	// Output:
+	// ok
+}

cryptor/crypto_test.go

@@ -1,6 +1,7 @@
 package cryptor
 
 import (
+	"crypto"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
@@ -139,13 +140,13 @@ func TestDesOfbEncrypt(t *testing.T) {
 func TestRsaEncrypt(t *testing.T) {
 	t.Parallel()
 
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	err := GenerateRsaKey(4096, "./rsa_private_example.pem", "./rsa_public_example.pem")
 	if err != nil {
 		t.FailNow()
 	}
 	data := []byte("hello world")
-	encrypted := RsaEncrypt(data, "rsa_public.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+	encrypted := RsaEncrypt(data, "./rsa_public_example.pem")
+	decrypted := RsaDecrypt(encrypted, "./rsa_private_example.pem")
 
 	assert := internal.NewAssert(t, "TestRsaEncrypt")
 	assert.Equal(string(data), string(decrypted))
@@ -170,7 +171,6 @@ func TestRsaEncryptOAEP(t *testing.T) {
 }
 
 func TestAesGcmEncrypt(t *testing.T) {
-
 	t.Parallel()
 
 	data := "hello world"
@@ -182,3 +182,53 @@ func TestAesGcmEncrypt(t *testing.T) {
 	assert := internal.NewAssert(t, "TestAesGcmEncrypt")
 	assert.Equal(data, string(decrypted))
 }
+
+func TestRsaSignAndVerify(t *testing.T) {
+	t.Parallel()
+
+	data := []byte("This is a test data for RSA signing")
+	hash := crypto.SHA256
+
+	t.Run("RSA Sign and Verify", func(t *testing.T) {
+		privateKey := "./rsa_private_example.pem"
+		publicKey := "./rsa_public_example.pem"
+
+		signature, err := RsaSign(hash, data, privateKey)
+		if err != nil {
+			t.Fatalf("RsaSign failed: %v", err)
+		}
+
+		err = RsaVerifySign(hash, data, signature, publicKey)
+		if err != nil {
+			t.Fatalf("RsaVerifySign failed: %v", err)
+		}
+	})
+
+	t.Run("RSA Sign and Verify Invalid Signature", func(t *testing.T) {
+		publicKey := "./rsa_public_example.pem"
+
+		invalidSig := []byte("InvalidSignature")
+
+		err := RsaVerifySign(hash, data, invalidSig, publicKey)
+		if err == nil {
+			t.Fatalf("RsaVerifySign failed: %v", err)
+		}
+	})
+
+	t.Run("RSA Sign and Verify With Different Hash", func(t *testing.T) {
+		publicKey := "./rsa_public_example.pem"
+		privateKey := "./rsa_private_example.pem"
+		hashSign := crypto.SHA256
+		hashVerify := crypto.SHA512
+
+		signature, err := RsaSign(hashSign, data, privateKey)
+		if err != nil {
+			t.Fatalf("RsaSign failed: %v", err)
+		}
+
+		err = RsaVerifySign(hashVerify, data, signature, publicKey)
+		if err == nil {
+			t.Fatalf("RsaVerifySign failed: %v", err)
+		}
+	})
+}

cryptor/rsa_private_example.pem

@@ -0,0 +1,51 @@
+-----BEGIN rsa private key-----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+-----END rsa private key-----

cryptor/rsa_public_example.pem

@@ -0,0 +1,14 @@
+-----BEGIN rsa public key-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAs+rfCwwvBb9JplwDAaNt
+pEPCm1DoS8PkqzwSSxfA7JHSMYdYUMq92vbSqEKomNgyksaGIiqDHop+9pHjYI1A
+ftd6mbZJwRtQxo+5eYGh88FzPqemmNubZk7SxGq0MEz1XmZ9viQyp3GxAJjeSdAG
+9GRdstNcczSy9Ij9YGJ8ehLhL/png4ZsLUtwDbYsilJDx28qDX/jJ/nbopaHWk2X
+TSu8KK3zXBjppTU4uKKicOswaJ6kfk9J6ItkQ15uS+z2eHsxpa8K++gIt2swJkiE
+RlqUzwiC75w92JH1nQPXqEqaaEx0izdHUmFF33cgGb6gw5tJePzOmYs8KLJcOhfJ
+QcqjW4MjCfnaw4tB/cpi3zYKzDoC7mzwitrkBO1MG11luzR1m9uMfWczL2hK2zMH
+I51vayC1d1T0gc56vS/SAdicl5OqcD6oc6Dmym3rguF/pauTIOrvGtipeYk/Mbb4
+qj2CI33QFTZc3G55yHVB6vDWIpMSWF60HHHqv7Ens4MIPIev0WS893vsNscg4Ph3
+QxXDNjOc3kEK17TnDGXmL7C+Ykfq9brm32IrOMZ4KR3NJ+aO83yLewPoQAy8QCC3
+2b1O3c1nAgSY9sIwJV8ikAdNDBhLnkXFrYE2ZFl/Kl5HXd0LCz/BQu3Ey0RsZfXI
+pD7KUcdNq3QRloTATntE9U0CAwEAAQ==
+-----END rsa public key-----

docs/api/packages/cryptor.md

@@ -70,6 +70,9 @@ import (
 -   [GenerateRsaKeyPair](#GenerateRsaKeyPair)
 -   [RsaEncryptOAEP](#RsaEncryptOAEP)
 -   [RsaDecryptOAEP](#RsaDecryptOAEP)
+-   [RsaSign](#RsaSign)
+-   [RsaVerifySign](#RsaVerifySign)
+
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -1607,3 +1610,81 @@ func main() {
     // hello world
 }
 ```
+
+### <span id="RsaSign">RsaSign</span>
+
+<p>应用RSA算法签名数据。</p>
+
+<b>函数签名:</b>
+
+```go
+func RsaSign(hash crypto.Hash, data []byte, privateKeyFileName string) ([]byte, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    data := []byte("This is a test data for RSA signing")
+    hash := crypto.SHA256
+
+    privateKey := "./rsa_private.pem"
+    publicKey := "./rsa_public.pem"
+
+    signature, err := RsaSign(hash, data, privateKey)
+    if err != nil {
+        return
+    }
+
+    err = RsaVerifySign(hash, data, signature, publicKey)
+    if err != nil {
+        return
+    }
+}
+```
+
+### <span id="RsaVerifySign">RsaVerifySign</span>
+
+<p>验证数据的签名是否符合RSA算法。</p>
+
+<b>函数签名:</b>
+
+```go
+func RsaVerifySign(hash crypto.Hash, data, signature []byte, pubKeyFileName string) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    data := []byte("This is a test data for RSA signing")
+    hash := crypto.SHA256
+
+    privateKey := "./rsa_private.pem"
+    publicKey := "./rsa_public.pem"
+
+    signature, err := RsaSign(hash, data, privateKey)
+    if err != nil {
+        return
+    }
+
+    err = RsaVerifySign(hash, data, signature, publicKey)
+    if err != nil {
+        return
+    }
+}
+```

docs/en/api/packages/cryptor.md

@@ -70,6 +70,8 @@ import (
 -   [GenerateRsaKeyPair](#GenerateRsaKeyPair)
 -   [RsaEncryptOAEP](#RsaEncryptOAEP)
 -   [RsaDecryptOAEP](#RsaDecryptOAEP)
+-   [RsaSign](#RsaSign)
+-   [RsaVerifySign](#RsaVerifySign)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -1061,13 +1063,13 @@ import (
 
 func main() {
     str := "hello"
-	key := "12345"
+    key := "12345"
 
-	hms := cryptor.HmacSha512WithBase64(str, key)
-	fmt.Println(hms)
+    hms := cryptor.HmacSha512WithBase64(str, key)
+    fmt.Println(hms)
 
-	// Output:
-	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
+    // Output:
+    // 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
 }
 ```
 
@@ -1124,10 +1126,10 @@ import (
 
 func main() {
     md5Str := cryptor.Md5StringWithBase64("hello")
-	fmt.Println(md5Str)
+    fmt.Println(md5Str)
 
-	// Output:
-	// XUFAKrxLKna5cZ2REBfFkg==
+    // Output:
+    // XUFAKrxLKna5cZ2REBfFkg==
 }
 ```
 
@@ -1153,10 +1155,10 @@ import (
 
 func main() {
     md5Str := cryptor.Md5Byte([]byte{'a'})
-	fmt.Println(md5Str)
+    fmt.Println(md5Str)
 
-	// Output:
-	// 0cc175b9c0f1b6a831c399e269772661
+    // Output:
+    // 0cc175b9c0f1b6a831c399e269772661
 }
 ```
 
@@ -1182,10 +1184,10 @@ import (
 
 func main() {
     md5Str := cryptor.Md5ByteWithBase64([]byte("hello"))
-	fmt.Println(md5Str)
+    fmt.Println(md5Str)
 
-	// Output:
-	// XUFAKrxLKna5cZ2REBfFkg==
+    // Output:
+    // XUFAKrxLKna5cZ2REBfFkg==
 }
 ```
 
@@ -1268,10 +1270,10 @@ import (
 
 func main() {
     result := cryptor.Sha1WithBase64("hello")
-	fmt.Println(result)
+    fmt.Println(result)
 
-	// Output:
-	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
+    // Output:
+    // qvTGHdzF6KLavt4PO0gs2a6pQ00=
 }
 ```
 
@@ -1328,10 +1330,10 @@ import (
 
 func main() {
     result := cryptor.Sha256WithBase64("hello")
-	fmt.Println(result)
+    fmt.Println(result)
 
-	// Output:
-	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
+    // Output:
+    // LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
 }
 ```
 
@@ -1388,10 +1390,10 @@ import (
 
 func main() {
     result := cryptor.Sha512WithBase64("hello")
-	fmt.Println(result)
+    fmt.Println(result)
 
-	// Output:
-	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
+    // Output:
+    // m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
 }
 ```
 
@@ -1607,3 +1609,81 @@ func main() {
     // hello world
 }
 ```
+
+### <span id="RsaSign">RsaSign</span>
+
+<p>Signs the data with RSA algorithm.</p>
+
+<b>Signature:</b>
+
+```go
+func RsaSign(hash crypto.Hash, data []byte, privateKeyFileName string) ([]byte, error)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    data := []byte("This is a test data for RSA signing")
+    hash := crypto.SHA256
+
+    privateKey := "./rsa_private.pem"
+    publicKey := "./rsa_public.pem"
+
+    signature, err := RsaSign(hash, data, privateKey)
+    if err != nil {
+        return
+    }
+
+    err = RsaVerifySign(hash, data, signature, publicKey)
+    if err != nil {
+        return
+    }
+}
+```
+
+### <span id="RsaVerifySign">RsaVerifySign</span>
+
+<p>Verifies the signature of the data with RSA algorithm.</p>
+
+<b>Signature:</b>
+
+```go
+func RsaVerifySign(hash crypto.Hash, data, signature []byte, pubKeyFileName string) error
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    data := []byte("This is a test data for RSA signing")
+    hash := crypto.SHA256
+
+    privateKey := "./rsa_private.pem"
+    publicKey := "./rsa_public.pem"
+
+    signature, err := RsaSign(hash, data, privateKey)
+    if err != nil {
+        return
+    }
+
+    err = RsaVerifySign(hash, data, signature, publicKey)
+    if err != nil {
+        return
+    }
+}
+```

maputil/orderedmap.go

@@ -35,7 +35,7 @@ func (om *OrderedMap[K, V]) Set(key K, value V) {
 	defer om.mu.Unlock()
 
 	if elem, ok := om.index[key]; ok {
-		elem.Value = value
+		om.data[key] = value
 		om.order.MoveToBack(elem)
 
 		return

maputil/orderedmap_test.go

@@ -19,6 +19,10 @@ func TestOrderedMap_Set_Get(t *testing.T) {
 	assert.Equal(1, val)
 	assert.Equal(true, ok)
 
+	om.Set("a", 2)
+	val, _ = om.Get("a")
+	assert.Equal(2, val)
+
 	val, ok = om.Get("d")
 	assert.Equal(false, ok)
 	assert.Equal(0, val)