kuma

1
package rsa
2

3
import (
4
	"bytes"
5
	"crypto/rsa"
6
	"crypto/x509"
7
	"encoding/pem"
8

9
	"github.com/pkg/errors"
10
)
11

12
const (
13
	publicBlockType     = "PUBLIC KEY"
14
	rsaPrivateBlockType = "RSA PRIVATE KEY"
15
	rsaPublicBlockType  = "RSA PUBLIC KEY"
16
)
17

18
func FromPrivateKeyToPEMBytes(key *rsa.PrivateKey) ([]byte, error) {
19
	block := pem.Block{
20
		Type:  rsaPrivateBlockType,
21
		Bytes: x509.MarshalPKCS1PrivateKey(key),
22
	}
23
	var keyBuf bytes.Buffer
24
	if err := pem.Encode(&keyBuf, &block); err != nil {
25
		return nil, err
26
	}
27
	return keyBuf.Bytes(), nil
28
}
29

30
func FromPrivateKeyToPublicKeyPEMBytes(key *rsa.PrivateKey) ([]byte, error) {
31
	block := pem.Block{
32
		Type:  rsaPublicBlockType,
33
		Bytes: x509.MarshalPKCS1PublicKey(&key.PublicKey),
34
	}
35
	var keyBuf bytes.Buffer
36
	if err := pem.Encode(&keyBuf, &block); err != nil {
37
		return nil, err
38
	}
39
	return keyBuf.Bytes(), nil
40
}
41

42
func FromPrivateKeyPEMBytesToPublicKeyPEMBytes(b []byte) ([]byte, error) {
43
	privateKey, err := FromPEMBytesToPrivateKey(b)
44
	if err != nil {
45
		return nil, err
46
	}
47

48
	return FromPrivateKeyToPublicKeyPEMBytes(privateKey)
49
}
50

51
func FromPEMBytesToPrivateKey(b []byte) (*rsa.PrivateKey, error) {
52
	block, _ := pem.Decode(b)
53
	if block.Type != rsaPrivateBlockType {
54
		return nil, errors.Errorf("invalid key encoding %q", block.Type)
55
	}
56
	return x509.ParsePKCS1PrivateKey(block.Bytes)
57
}
58

59
func FromPEMBytesToPublicKey(b []byte) (*rsa.PublicKey, error) {
60
	block, _ := pem.Decode(b)
61

62
	switch block.Type {
63
	case rsaPublicBlockType:
64
		return x509.ParsePKCS1PublicKey(block.Bytes)
65
	case publicBlockType:
66
		return rsaKeyFromPKIX(block.Bytes)
67
	default:
68
		return nil, errors.Errorf("invalid key encoding %q", block.Type)
69
	}
70
}
71

72
func IsPrivateKeyPEMBytes(b []byte) bool {
73
	block, _ := pem.Decode(b)
74
	return block != nil && block.Type == rsaPrivateBlockType
75
}
76

77
func IsPublicKeyPEMBytes(b []byte) bool {
78
	block, _ := pem.Decode(b)
79

80
	if block != nil && block.Type == rsaPublicBlockType {
81
		return true
82
	}
83

84
	if block != nil && block.Type == publicBlockType {
85
		_, err := rsaKeyFromPKIX(block.Bytes)
86
		return err == nil
87
	}
88

89
	return false
90
}
91

92
func rsaKeyFromPKIX(bytes []byte) (*rsa.PublicKey, error) {
93
	key, err := x509.ParsePKIXPublicKey(bytes)
94
	if err != nil {
95
		return nil, err
96
	}
97

98
	rsaKey, ok := key.(*rsa.PublicKey)
99
	if !ok {
100
		return nil, errors.Errorf("encoded key is not a RSA key")
101
	}
102

103
	return rsaKey, nil
104
}
105