129 lines
3.6 KiB
Go
129 lines
3.6 KiB
Go
package pairing
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
"crypto/sha256"
|
|
"crypto/tls"
|
|
"crypto/x509"
|
|
"encoding/asn1"
|
|
"encoding/pem"
|
|
"fmt"
|
|
"math/big"
|
|
"net/url"
|
|
"time"
|
|
|
|
"github.com/status-im/status-go/server"
|
|
"github.com/status-im/status-go/signal"
|
|
)
|
|
|
|
func makeSerialNumberFromKey(pk *ecdsa.PrivateKey) *big.Int {
|
|
h := sha256.New()
|
|
h.Write(append(pk.D.Bytes(), append(pk.Y.Bytes(), pk.X.Bytes()...)...))
|
|
|
|
return new(big.Int).SetBytes(h.Sum(nil))
|
|
}
|
|
|
|
func GenerateCertFromKey(pk *ecdsa.PrivateKey, from time.Time, hostname string) (tls.Certificate, []byte, error) {
|
|
cert := server.GenerateX509Cert(makeSerialNumberFromKey(pk), from, from.Add(time.Hour), hostname)
|
|
certPem, keyPem, err := server.GenerateX509PEMs(cert, pk)
|
|
if err != nil {
|
|
return tls.Certificate{}, nil, err
|
|
}
|
|
|
|
tlsCert, err := tls.X509KeyPair(certPem, keyPem)
|
|
if err != nil {
|
|
return tls.Certificate{}, nil, err
|
|
}
|
|
|
|
block, _ := pem.Decode(certPem)
|
|
if block == nil {
|
|
return tls.Certificate{}, nil, fmt.Errorf("failed to decode certPem")
|
|
}
|
|
leaf, err := x509.ParseCertificate(block.Bytes)
|
|
if err != nil {
|
|
return tls.Certificate{}, nil, err
|
|
}
|
|
tlsCert.Leaf = leaf
|
|
|
|
return tlsCert, certPem, nil
|
|
}
|
|
|
|
// verifyCertPublicKey checks that the ecdsa.PublicKey using in a x509.Certificate matches a known ecdsa.PublicKey
|
|
func verifyCertPublicKey(cert *x509.Certificate, publicKey *ecdsa.PublicKey) error {
|
|
certKey, ok := cert.PublicKey.(*ecdsa.PublicKey)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected public key type, expected ecdsa.PublicKey")
|
|
}
|
|
|
|
if !certKey.Equal(publicKey) {
|
|
return fmt.Errorf("server certificate MUST match the given public key")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// verifyCertSig checks that a x509.Certificate's Signature verifies against x509.Certificate's PublicKey
|
|
// If the x509.Certificate's PublicKey is not an ecdsa.PublicKey an error will be thrown
|
|
func verifyCertSig(cert *x509.Certificate) (bool, error) {
|
|
var esig struct {
|
|
R, S *big.Int
|
|
}
|
|
if _, err := asn1.Unmarshal(cert.Signature, &esig); err != nil {
|
|
return false, err
|
|
}
|
|
|
|
hash := sha256.New()
|
|
hash.Write(cert.RawTBSCertificate)
|
|
|
|
ecKey, ok := cert.PublicKey.(*ecdsa.PublicKey)
|
|
if !ok {
|
|
return false, fmt.Errorf("certificate public is not an ecdsa.PublicKey")
|
|
}
|
|
|
|
verified := ecdsa.Verify(ecKey, hash.Sum(nil), esig.R, esig.S)
|
|
return verified, nil
|
|
}
|
|
|
|
// verifyCert verifies an x509.Certificate against a known ecdsa.PublicKey
|
|
// combining the checks of verifyCertPublicKey and verifyCertSig.
|
|
// If an x509.Certificate fails to verify an error is also thrown
|
|
func verifyCert(cert *x509.Certificate, publicKey *ecdsa.PublicKey) error {
|
|
err := verifyCertPublicKey(cert, publicKey)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
verified, err := verifyCertSig(cert)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !verified {
|
|
return fmt.Errorf("server certificate signature MUST verify")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// getServerCert pings a given tls host, extracts and returns its x509.Certificate
|
|
// the function expects there to be only 1 certificate
|
|
func getServerCert(URL *url.URL) (*x509.Certificate, error) {
|
|
conf := &tls.Config{
|
|
InsecureSkipVerify: true, // nolint: gosec // Only skip verify to get the server's TLS cert. DO NOT skip for any other reason.
|
|
}
|
|
|
|
conn, err := tls.Dial("tcp", URL.Host, conf)
|
|
if err != nil {
|
|
signal.SendLocalPairingEvent(Event{Type: EventConnectionError, Error: err.Error(), Action: ActionConnect})
|
|
return nil, err
|
|
}
|
|
defer conn.Close()
|
|
|
|
// No error on the dial out then the URL.Host is accessible
|
|
signal.SendLocalPairingEvent(Event{Type: EventConnectionSuccess, Action: ActionConnect})
|
|
|
|
certs := conn.ConnectionState().PeerCertificates
|
|
if len(certs) != 1 {
|
|
return nil, fmt.Errorf("expected 1 TLS certificate, received '%d'", len(certs))
|
|
}
|
|
|
|
return certs[0], nil
|
|
}
|