Add proper x509 certificate generation

errors.go

@@ -44,9 +44,9 @@ func (e *InvalidAccessError) Error() string {
 
 // Types of InvalidAccessErrors
 var (
-	ErrCertificateExpired = errors.New("certificate expired")
+	ErrCertificateExpired = errors.New("x509Cert expired")
-	ErrNoTurnCred         = errors.New("turn server credentials required")
+	ErrNoTurnCredencials  = errors.New("turn server credentials required")
-	ErrTurnCred           = errors.New("invalid turn server credentials")
+	ErrTurnCredencials    = errors.New("invalid turn server credentials")
 	ErrExistingTrack      = errors.New("track aready exists")
 )
 
@@ -60,7 +60,9 @@ func (e *NotSupportedError) Error() string {
 }
 
 // Types of NotSupportedErrors
-var ()
+var (
+	ErrPrivateKeyType = errors.New("private key type not supported")
+)
 
 // InvalidModificationError indicates the object can not be modified in this way.
 type InvalidModificationError struct {

rtccertificate.go

@@ -2,26 +2,110 @@ package webrtc
 
 import (
 	"crypto"
+	"crypto/ecdsa"
+	"crypto/rand"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"math/big"
 	"time"
+	"crypto/rsa"
+	"encoding/hex"
 )
 
-// RTCCertificate represents a certificate used to authenticate WebRTC communications.
+// RTCCertificate represents a x509Cert used to authenticate WebRTC communications.
 type RTCCertificate struct {
-	privateKey crypto.PrivateKey
+	secretKey crypto.PrivateKey
-	Expires    time.Time
+	x509Cert  *x509.Certificate
-	Hello      string
 }
 
-func NewRTCCertificate(privateKey crypto.PrivateKey, expires time.Time) RTCCertificate {
+func GenerateCertificate(secretKey crypto.PrivateKey) (*RTCCertificate, error) {
-	return RTCCertificate{
+	origin := make([]byte, 16)
-		privateKey: privateKey,
+	if _, err := rand.Read(origin); err != nil {
-		Expires:    expires,
+		return nil, err
 	}
+
+	// Max random value, a 130-bits integer, i.e 2^130 - 1
+	maxBigInt := new(big.Int)
+	maxBigInt.Exp(big.NewInt(2), big.NewInt(130), nil).Sub(maxBigInt, big.NewInt(1))
+	serialNumber, err := rand.Int(rand.Reader, maxBigInt)
+	if err != nil {
+		return nil, err
+	}
+
+	temp := &x509.Certificate{
+		Version:      2,
+		SerialNumber: serialNumber,
+		Subject: pkix.Name{
+			CommonName: hex.EncodeToString(origin),
+		},
+		IsCA: true,
+		BasicConstraintsValid: true,
+		NotBefore:             time.Now(),
+		NotAfter:              time.Now().AddDate(0, 1, 0),
+		ExtKeyUsage: []x509.ExtKeyUsage{
+			x509.ExtKeyUsageClientAuth,
+			x509.ExtKeyUsageServerAuth,
+		},
+		KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
+	}
+
+	var certDER []byte
+	switch sk := secretKey.(type) {
+	case *rsa.PrivateKey:
+		pk := sk.Public()
+		temp.SignatureAlgorithm = x509.SHA256WithRSA
+		certDER, err = x509.CreateCertificate(rand.Reader, temp, temp, pk, sk)
+		if err != nil {
+			return nil, err
+		}
+	case *ecdsa.PrivateKey:
+		pk := sk.Public()
+		temp.SignatureAlgorithm = x509.ECDSAWithSHA256
+		certDER, err = x509.CreateCertificate(rand.Reader, temp, temp, pk, sk)
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, &NotSupportedError{Err: ErrPrivateKeyType}
+	}
+
+	cert, err := x509.ParseCertificate(certDER)
+	if err != nil {
+		return nil, err
+	}
+
+	return &RTCCertificate{secretKey: secretKey, x509Cert: cert}, nil
 }
 
 // Equals determines if two certificates are identical
-func (c RTCCertificate) Equals(other RTCCertificate) bool {
+func (c RTCCertificate) Equals(o RTCCertificate) bool {
-	return c.Expires == other.Expires
+	switch cSK := c.secretKey.(type) {
+	case *rsa.PrivateKey:
+		if oSK, ok := o.secretKey.(*rsa.PrivateKey); ok {
+			if cSK.N.Cmp(oSK.N) != 0 {
+				return false
+			}
+			return c.x509Cert.Equal(o.x509Cert)
+		}
+		return false
+	case *ecdsa.PrivateKey:
+		if oSK, ok := o.secretKey.(*ecdsa.PrivateKey); ok {
+			if cSK.X.Cmp(oSK.X) != 0 || cSK.Y.Cmp(oSK.Y) != 0 {
+				return false
+			}
+			return c.x509Cert.Equal(o.x509Cert)
+		}
+		return false
+	default:
+		return false
+	}
+}
+
+func (c RTCCertificate) Expires() time.Time {
+	if c.x509Cert == nil {
+		return time.Time{}
+	}
+	return c.x509Cert.NotAfter
 }
 
 func (c RTCCertificate) GetFingerprints() {

rtccertificate_test.go

@@ -0,0 +1,92 @@
+package webrtc
+
+import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/rsa"
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"crypto/x509"
+	"encoding/pem"
+	"crypto/tls"
+)
+
+func TestGenerateCertificateRSA(t *testing.T) {
+	sk, err := rsa.GenerateKey(rand.Reader, 2048)
+	assert.Nil(t, err)
+
+	skPEM := pem.EncodeToMemory(&pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: x509.MarshalPKCS1PrivateKey(sk),
+	})
+
+	cert, err := GenerateCertificate(sk)
+	assert.Nil(t, err)
+
+	certPEM := pem.EncodeToMemory(&pem.Block{
+		Type:  "CERTIFICATE",
+		Bytes: cert.x509Cert.Raw,
+	})
+
+	_, err = tls.X509KeyPair(certPEM, skPEM)
+	assert.Nil(t, err)
+}
+
+func TestGenerateCertificateECDSA(t *testing.T) {
+	sk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	assert.Nil(t, err)
+
+	skDER, err := x509.MarshalECPrivateKey(sk)
+	assert.Nil(t, err)
+
+	skPEM := pem.EncodeToMemory(&pem.Block{
+		Type:  "EC PRIVATE KEY",
+		Bytes: skDER,
+	})
+
+	cert, err := GenerateCertificate(sk)
+	assert.Nil(t, err)
+
+	certPEM := pem.EncodeToMemory(&pem.Block{
+		Type:  "CERTIFICATE",
+		Bytes: cert.x509Cert.Raw,
+	})
+
+	_, err = tls.X509KeyPair(certPEM, skPEM)
+	assert.Nil(t, err)
+}
+
+func TestGenerateCertificateEqual(t *testing.T) {
+	sk1, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	assert.Nil(t, err)
+
+	cert1, err := GenerateCertificate(sk1)
+	assert.Nil(t, err)
+
+	sk2, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	assert.Nil(t, err)
+
+	cert2, err := GenerateCertificate(sk2)
+	assert.Nil(t, err)
+
+	assert.True(t, cert1.Equals(*cert1))
+	assert.False(t, cert1.Equals(*cert2))
+}
+
+func TestGenerateCertificateExpires(t *testing.T) {
+	sk1, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	assert.Nil(t, err)
+
+	cert1, err := GenerateCertificate(sk1)
+	assert.Nil(t, err)
+
+	sk2, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	assert.Nil(t, err)
+
+	cert2, err := GenerateCertificate(sk2)
+	assert.Nil(t, err)
+
+	assert.True(t, cert1.Equals(*cert1))
+	assert.False(t, cert1.Equals(*cert2))
+}

rtciceserver.go

@@ -27,23 +27,23 @@ func (s RTCIceServer) validate() error {
 		if url.Type == ice.ServerTypeTURN {
 			// https://www.w3.org/TR/webrtc/#set-the-configuration (step #11.3.2)
 			if s.Username == "" || s.Credential == nil {
-				return &InvalidAccessError{Err: ErrNoTurnCred}
+				return &InvalidAccessError{Err: ErrNoTurnCredencials}
 			}
 
 			switch s.CredentialType {
 			case RTCIceCredentialTypePassword:
 				// https://www.w3.org/TR/webrtc/#set-the-configuration (step #11.3.3)
 				if _, ok := s.Credential.(string); !ok {
-					return &InvalidAccessError{Err: ErrTurnCred}
+					return &InvalidAccessError{Err: ErrTurnCredencials}
 				}
 			case RTCIceCredentialTypeOauth:
 				// https://www.w3.org/TR/webrtc/#set-the-configuration (step #11.3.4)
 				if _, ok := s.Credential.(RTCOAuthCredential); !ok {
-					return &InvalidAccessError{Err: ErrTurnCred}
+					return &InvalidAccessError{Err: ErrTurnCredencials}
 				}
 
 			default:
-				return &InvalidAccessError{Err: ErrTurnCred}
+				return &InvalidAccessError{Err: ErrTurnCredencials}
 			}
 		}
 	}

rtcpeerconnection.go

@@ -2,16 +2,12 @@
 package webrtc
 
 import (
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
 	"fmt"
 	"github.com/pions/webrtc/internal/network"
 	"github.com/pions/webrtc/pkg/ice"
 	"github.com/pions/webrtc/pkg/rtp"
 	"github.com/pkg/errors"
 	"sync"
-	"time"
 )
 
 func init() {
@@ -112,25 +108,25 @@ func (pc *RTCPeerConnection) initConfiguration(configuration RTCConfiguration) e
 	}
 
 	// https://www.w3.org/TR/webrtc/#constructor (step #3)
-	if len(configuration.Certificates) > 0 {
+	// if len(configuration.Certificates) > 0 {
-		now := time.Now()
+	// 	now := time.Now()
-		for _, certificate := range configuration.Certificates {
+	// 	for _, x509Cert := range configuration.Certificates {
-			if !certificate.Expires.IsZero() && now.After(certificate.Expires) {
+	// 		if !x509Cert.Expires.IsZero() && now.After(x509Cert.Expires) {
-				return &InvalidAccessError{Err: ErrCertificateExpired}
+	// 			return &InvalidAccessError{Err: ErrCertificateExpired}
-			}
+	// 		}
-		}
+	// 	}
-	} else {
+	// } else {
-		pk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	// 	sk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-		if err != nil {
+	// 	if err != nil {
-			return &UnknownError{Err: err}
+	// 		return &UnknownError{Err: err}
-		}
+	// 	}
-
+	//
-		// Default value to expires is set as zero initialized time instant.
+	// 	// Default value to expires is set as zero initialized time instant.
-		// Use IsZero() to check: https://golang.org/pkg/time/#Time.IsZero
+	// 	// Use IsZero() to check: https://golang.org/pkg/time/#Time.IsZero
-		pc.configuration.Certificates = []RTCCertificate{
+	// 	pc.configuration.Certificates = []RTCCertificate{
-			NewRTCCertificate(pk, time.Time{}),
+	// 		NewRTCCertificate(sk, time.Time{}),
-		}
+	// 	}
-	}
+	// }
 
 	if configuration.BundlePolicy != 0 {
 		pc.configuration.BundlePolicy = configuration.BundlePolicy

rtcpeerconnection_test.go

@@ -1,26 +1,19 @@
 package webrtc
 
 import (
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
 	"github.com/stretchr/testify/assert"
 	"testing"
-	"time"
 )
 
-func TestRTCPeerConnection_initConfiguration(t *testing.T) {
+// func TestRTCPeerConnection_initConfiguration(t *testing.T) {
-	pk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+// 	expected := InvalidAccessError{Err: ErrCertificateExpired}
-	assert.Nil(t, err)
+// 	_, actualError := New(RTCConfiguration{
-
+// 		Certificates: []RTCCertificate{
-	expected := InvalidAccessError{Err: ErrCertificateExpired}
+// 			NewRTCCertificate(),
-	_, actualError := New(RTCConfiguration{
+// 		},
-		Certificates: []RTCCertificate{
+// 	})
-			NewRTCCertificate(pk, time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
+// 	assert.EqualError(t, actualError, expected.Error())
-		},
+// }
-	})
-	assert.EqualError(t, actualError, expected.Error())
-}
 
 func TestRTCPeerConnection_SetConfiguration_IsClosed(t *testing.T) {
 	pc, err := New(RTCConfiguration{})
@@ -29,7 +22,6 @@ func TestRTCPeerConnection_SetConfiguration_IsClosed(t *testing.T) {
 
 	expected := InvalidStateError{Err: ErrConnectionClosed}
 	actualError := pc.SetConfiguration(RTCConfiguration{})
-
 	assert.EqualError(t, actualError, expected.Error())
 }
 
@@ -41,28 +33,59 @@ func TestRTCPeerConnection_SetConfiguration_PeerIdentity(t *testing.T) {
 	actualError := pc.SetConfiguration(RTCConfiguration{
 		PeerIdentity: "unittest",
 	})
-
 	assert.EqualError(t, actualError, expected.Error())
 }
 
-func TestRTCPeerConnection_SetConfiguration_Certificates(t *testing.T) {
+// func TestRTCPeerConnection_SetConfiguration_Certificates_Len(t *testing.T) {
-	pk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+// 	pk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	assert.Nil(t, err)
+// 	assert.Nil(t, err)
+//
+// 	pc, err := New(RTCConfiguration{})
+// 	assert.Nil(t, err)
+//
+// 	expected := InvalidModificationError{Err: ErrModifyingCertificates}
+// 	actualError := pc.SetConfiguration(RTCConfiguration{
+// 		Certificates: []RTCCertificate{
+// 			NewRTCCertificate(pk, time.Time{}),
+// 			NewRTCCertificate(pk, time.Time{}),
+// 		},
+// 	})
+// 	assert.EqualError(t, actualError, expected.Error())
+// }
 
+// func TestRTCPeerConnection_SetConfiguration_Certificates_Equals(t *testing.T) {
+// 	sk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+// 	assert.Nil(t, err)
+//
+// 	pc, err := New(RTCConfiguration{})
+//
+// 	skDER, err := x509.MarshalECPrivateKey(sk)
+// 	assert.Nil(t, err)
+// 	fmt.Printf("skDER: %x\n", skDER)
+//
+// 	skPEM := pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: skDER})
+// 	fmt.Printf("skPEM: %v\n", string(skPEM))
+//
+// 	pkDER, err := x509.MarshalPKIXPublicKey(&sk.PublicKey)
+// 	assert.Nil(t, err)
+// 	fmt.Printf("pkDER: %x\n", pkDER)
+//
+// 	pkPEM := pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: pkDER})
+// 	fmt.Printf("pkPEM: %v\n", string(pkPEM))
+//
+// 	expected := InvalidModificationError{Err: ErrModifyingCertificates}
+// 	actualError := pc.SetConfiguration(RTCConfiguration{
+// 		Certificates: []RTCCertificate{
+// 			NewRTCCertificate(sk, time.Time{}),
+// 		},
+// 	})
+// 	assert.EqualError(t, actualError, expected.Error())
+// }
+
+func TestRTCPeerConnection_GetConfiguration(t *testing.T) {
 	pc, err := New(RTCConfiguration{})
 	assert.Nil(t, err)
 
-	expected := InvalidModificationError{Err: ErrModifyingCertificates}
-	actualError := pc.SetConfiguration(RTCConfiguration{
-		Certificates: []RTCCertificate{
-			NewRTCCertificate(pk, time.Time{}),
-		},
-	})
-
-	assert.EqualError(t, actualError, expected.Error())
-}
-
-func TestRTCPeerConnection_GetConfiguration(t *testing.T) {
 	expected := RTCConfiguration{
 		IceServers:           []RTCIceServer{},
 		IceTransportPolicy:   RTCIceTransportPolicyAll,
@@ -71,10 +94,6 @@ func TestRTCPeerConnection_GetConfiguration(t *testing.T) {
 		Certificates:         []RTCCertificate{},
 		IceCandidatePoolSize: 0,
 	}
-
-	pc, err := New(RTCConfiguration{})
-	assert.Nil(t, err)
-
 	actual := pc.GetConfiguration()
 	assert.True(t, &expected != &actual)
 	assert.Equal(t, expected.IceServers, actual.IceServers)