create Key Pair

internal/selfhosted/keys.go

@@ -5,48 +5,36 @@ import (
 	"crypto/rsa"
 	"crypto/x509"
 	"encoding/pem"
-	"os"
 )
 
-func createKeyPair() error {
+type KeyPair struct {
-	// RSAキーペアの生成
+	PublicKey   []byte
+	PrivateKey []byte
+}
+
+func createKeyPair() (*KeyPair, error) {
 	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	// private keyをPEM形式で保存
+	// convert private key to PEM
 	privPem := pem.Block{
 		Type:  "RSA PRIVATE KEY",
 		Bytes: x509.MarshalPKCS1PrivateKey(privateKey),
 	}
-	privPemFile, err := os.Create("private_key.pem")
+	privPemBytes := pem.EncodeToMemory(&privPem)
-	if err != nil {
-		return err
-	}
-	defer privPemFile.Close()
-	if err := pem.Encode(privPemFile, &privPem); err != nil {
-		return err
-	}
 
-	// 公開鍵をPKIX, ASN.1 DER形式に変換
+	// convert public key to PKIX, ASN.1 DER
 	pubASN1, err := x509.MarshalPKIXPublicKey(&privateKey.PublicKey)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	// 公開鍵をPEM形式で保存
 	pubPem := pem.Block{
 		Type:  "PUBLIC KEY",
 		Bytes: pubASN1,
 	}
-	pubPemFile, err := os.Create("public_key.pem")
+	pubPemBytes := pem.EncodeToMemory(&pubPem)
-	if err != nil {
+	return &KeyPair{pubPemBytes, privPemBytes}, nil
-		return err
-	}
-	defer pubPemFile.Close()
-	if err := pem.Encode(pubPemFile, &pubPem); err != nil {
-		return err
-	}
-	return nil
 }

internal/selfhosted/keys_test.go

@@ -1,43 +1,44 @@
 package selfhosted
 
 import (
-	"os"
+	"crypto"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha256"
+	"crypto/x509"
+	"encoding/pem"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
-const rsaKeyID = "JHJehTTTZlsspKHT-GaJxK7Kd1NQgZJu3fyK6K_QDYU"
-
 
 func TestReadKey(t *testing.T) {
-	tests := []struct {
+	t.Run("key pair check", func(t *testing.T) {
-		name       string
+		keyPair, err := createKeyPair()
-		filename string
+		assert.NoError(t, err)
-		expected   string
+
-		expectErr  bool
+		message := []byte("test message")
-	}{
+		hashed := sha256.Sum256(message)
-		{
+
-			name:       "rsa",
+		block, _ := pem.Decode(keyPair.PrivateKey)
-			filename: "testdata/rsa.pub",
+		assert.NotNil(t, block, "failed to decode private key to PEM")
-			expected:   rsaKeyID,
+
-		},
+		privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
-		{
+		assert.NoError(t, err, "failed to parse private key")
-			name:       "rsa",
+
-			filename: "testdata/ecdsa.pub",
+		signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hashed[:])
-			expectErr:   true,
+
-		},
+		assert.NoError(t, err, "failed to create signature")
-	}
+		block, _ = pem.Decode(keyPair.PublicKey)
-	for _, tt := range tests {
+		assert.NotNil(t, block, "failed to decode public key to PEM")
-		t.Run(tt.name, func(t *testing.T) {
+
-	    content, err := os.ReadFile(tt.filename)
+		pubKey, err := x509.ParsePKIXPublicKey(block.Bytes)
-      assert.NoError(t, err)
+		assert.NoError(t, err, "failed to parse public key")
-      actual, err := NewJWK(content)
+
-			if tt.expectErr {
+		rsaPubKey, ok := pubKey.(*rsa.PublicKey)
-				assert.Error(t, err, "")
+		assert.Truef(t, ok, "public key is not RSA")
-			} else {
+
-				assert.NoError(t, err)
+		err = rsa.VerifyPKCS1v15(rsaPubKey, crypto.SHA256, hashed[:], signature)
-				assert.Equal(t, tt.expected, actual.Keys[0].KeyID)
+		assert.NoError(t, err, "failed to check signature")
-			}
+	})
-		})
-	}
 }