-
Notifications
You must be signed in to change notification settings - Fork 2
/
fingerprint.go
100 lines (80 loc) · 2.11 KB
/
fingerprint.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
package mau
import (
"bytes"
"crypto/ecdsa"
"crypto/rsa"
"crypto/x509"
"encoding/hex"
"errors"
"fmt"
"golang.org/x/crypto/openpgp/packet"
)
var (
ErrIncorrectFingerprintLength = errors.New("Provided fingerprint length is not correct")
ErrCantFindFingerprint = errors.New("Can't find fingerprint.")
ErrCantFindAddress = errors.New("Can't find address (DNSName) in certificate.")
)
const FINGERPRINT_LEN = 20
type Fingerprint [FINGERPRINT_LEN]byte
func (f Fingerprint) String() string {
return hex.EncodeToString(f[:])
}
func (f Fingerprint) MarshalJSON() ([]byte, error) {
return []byte(fmt.Sprintf(`"%s"`, f)), nil
}
func (f *Fingerprint) UnmarshalJSON(b []byte) error {
if bytes.Compare(b, []byte("null")) == 0 {
return nil
}
if len(b) != (FINGERPRINT_LEN*2)+2 {
return fmt.Errorf("%w %s", ErrIncorrectFingerprintLength, b)
}
v := string(b[1 : len(b)-1])
pf, err := FingerprintFromString(v)
if err != nil {
return err
}
for i := range pf {
f[i] = pf[i]
}
return nil
}
func FingerprintFromString(s string) (fpr Fingerprint, err error) {
decodeLen := hex.DecodedLen(len(s))
if decodeLen != cap(fpr) {
err = fmt.Errorf("%w : provided: %d", ErrIncorrectFingerprintLength, decodeLen)
return
}
var fprParsed []byte
fprParsed, err = hex.DecodeString(s)
if err != nil {
return
}
copy(fpr[:], fprParsed)
return
}
func FingerprintFromCert(certs []*x509.Certificate) (Fingerprint, error) {
for _, cert := range certs {
switch cert.PublicKeyAlgorithm {
case x509.RSA:
if pubkey, ok := cert.PublicKey.(*rsa.PublicKey); ok {
return packet.NewRSAPublicKey(cert.NotBefore, pubkey).Fingerprint, nil
}
case x509.ECDSA:
if pubkey, ok := cert.PublicKey.(*ecdsa.PublicKey); ok {
return packet.NewECDSAPublicKey(cert.NotBefore, pubkey).Fingerprint, nil
}
default:
return Fingerprint{}, x509.ErrUnsupportedAlgorithm
}
}
return Fingerprint{}, ErrCantFindFingerprint
}
func certToAddress(certs []*x509.Certificate) (string, error) {
for _, cert := range certs {
for _, name := range cert.DNSNames {
return name, nil
}
}
return "", ErrCantFindAddress
}