Add sign PKCS1v15

Author: quixote-liu

rsa.go

@@ -2,6 +2,7 @@ package codealg
 
 import (
 	"bytes"
+	"crypto"
 	"crypto/rand"
 	"crypto/rsa"
 	"crypto/sha256"
@@ -46,6 +47,30 @@ func DecryptPKCS1v15(ciphertext []byte, privateKey []byte) ([]byte, error) {
 	return rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext)
 }
 
+// ---------------- sign PKCS1v15 --------------------------
+
+func SignPKCS1v15(message, privateKey []byte) ([]byte, error) {
+	priv, err := parsePrivateKey(privateKey)
+	if err != nil {
+		return nil, err
+	}
+	hashed := sha256.Sum256(message)
+	signature, err := rsa.SignPKCS1v15(rand.Reader, priv, crypto.SHA256, hashed[:])
+	if err != nil {
+		return nil, err
+	}
+	return signature, nil
+}
+
+func VerifyPKCS1v15(signature, message, publicKey []byte) error {
+	pub, err := parsePublicKey(publicKey)
+	if err != nil {
+		return err
+	}
+	hashed := sha256.Sum256(message)
+	return rsa.VerifyPKCS1v15(pub, crypto.SHA256, hashed[:], signature)
+}
+
 // ----------------- common --------------------------------
 
 const (

rsa_test.go

@@ -96,6 +96,64 @@ func TestDecryptOAEP(t *testing.T) {
 	}
 }
 
+func TestSignPKCS1v15(t *testing.T) {
+	privateKey, publicKey, err := GenRSAKey(RsaKeyBits2048)
+	assert.Nil(t, err)
+	tests := []struct {
+		name    string
+		message []byte
+		privKey []byte
+		wantErr bool
+	}{
+		{"should pass with correct private key", []byte("hello, world"), privateKey, false},
+		{"should return err with incorrect private key", []byte("hello, world"), []byte("error_privateKey"), true},
+		{"should pass with empty message", []byte("hello, world"), privateKey, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sig, err := SignPKCS1v15(tt.message, tt.privKey)
+			if tt.wantErr {
+				assert.NotNil(t, err)
+				return
+			} else {
+				assert.Nil(t, err)
+			}
+			err = VerifyPKCS1v15(sig, tt.message, publicKey)
+			assert.Nil(t, err)
+		})
+	}
+}
+
+func TestVerifyPKCS1v15(t *testing.T) {
+	privateKey, publicKey, err := GenRSAKey(RsaKeyBits2048)
+	assert.Nil(t, err)
+	message := []byte("hello, world")
+	sig, err := SignPKCS1v15(message, privateKey)
+	assert.Nil(t, err)
+	tests := []struct {
+		name      string
+		signature []byte
+		message   []byte
+		pubKey    []byte
+		wantErr   bool
+	}{
+		{"should pass with correct message and signature", sig, message, publicKey, false},
+		{"should return error with incorrect signature", []byte("error_signature"), message, publicKey, true},
+		{"should return error with incorrect message", sig, []byte("error_message"), publicKey, true},
+		{"should return error with incorrect public key", sig, message, []byte("error_public_key"), true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err = VerifyPKCS1v15(tt.signature, tt.message, tt.pubKey)
+			if tt.wantErr {
+				assert.NotNil(t, err)
+				return
+			}
+			assert.Nil(t, err)
+		})
+	}
+}
+
 func TestEncryptPKCS1v15(t *testing.T) {
 	privKey, pubKey, err := GenRSAKey(1024)
 	assert.Nil(t, err)