mirror of
https://github.com/hanzoai/pki.git
synced 2026-11-03 18:08:14 +00:00
297 lines
7.3 KiB
Go
297 lines
7.3 KiB
Go
package testca
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
"crypto/elliptic"
|
|
"crypto/rand"
|
|
"crypto/rsa"
|
|
"crypto/x509"
|
|
"crypto/x509/pkix"
|
|
"encoding/asn1"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/effective-security/xpki/certutil"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
pkcs12 "software.sslmate.com/src/go-pkcs12"
|
|
)
|
|
|
|
func TestDefaults(t *testing.T) {
|
|
assert.NotPanics(t, func() {
|
|
root := NewEntity(
|
|
Authority,
|
|
NotBefore(time.Now()),
|
|
NotAfter(time.Now().Add(100*time.Hour)),
|
|
ExtKeyUsage(x509.ExtKeyUsageOCSPSigning),
|
|
)
|
|
|
|
err := root.Certificate.CheckSignatureFrom(root.Certificate)
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
|
|
func TestIntermediate(t *testing.T) {
|
|
assert.NotPanics(t, func() {
|
|
NewEntity(
|
|
CrlDpURL("http://localhost/crl"),
|
|
DNSName("localhost"),
|
|
).Issue()
|
|
})
|
|
}
|
|
|
|
func TestSubject(t *testing.T) {
|
|
assert.NotPanics(t, func() {
|
|
var (
|
|
expected = "foobar"
|
|
root = NewEntity(Subject(pkix.Name{CommonName: expected}))
|
|
actual = root.Certificate.Subject.CommonName
|
|
)
|
|
|
|
assert.Equal(t, expected, actual, "bad subject")
|
|
})
|
|
}
|
|
|
|
func TestNextSerialNumber(t *testing.T) {
|
|
assert.NotPanics(t, func() {
|
|
var (
|
|
expected = int64(123)
|
|
ca = NewEntity(NextSerialNumber(expected)).Issue()
|
|
actual = ca.Certificate.SerialNumber.Int64()
|
|
)
|
|
assert.Equal(t, expected, actual, "bad SN")
|
|
})
|
|
}
|
|
|
|
func TestPrivateKey(t *testing.T) {
|
|
assert.NotPanics(t, func() {
|
|
var (
|
|
expected, _ = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
|
ca = NewEntity(PrivateKey(expected))
|
|
actual = ca.PrivateKey.(*ecdsa.PrivateKey)
|
|
)
|
|
|
|
assert.True(t, expected.Equal(actual), "private key mismatch")
|
|
})
|
|
}
|
|
|
|
func TestIssuer(t *testing.T) {
|
|
assert.NotPanics(t, func() {
|
|
var (
|
|
root = NewEntity(Authority)
|
|
inter = NewEntity(Issuer(root))
|
|
|
|
expected = root.Certificate.RawSubject
|
|
actual = inter.Certificate.RawIssuer
|
|
)
|
|
|
|
require.Equal(t, expected, actual, "bad issuer. expected %q, got %q", string(expected), string(actual))
|
|
|
|
err := inter.Certificate.CheckSignatureFrom(root.Certificate)
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
|
|
func TestIsCA(t *testing.T) {
|
|
var (
|
|
normal = NewEntity()
|
|
ca = NewEntity(Authority)
|
|
)
|
|
|
|
assert.True(t, ca.Certificate.IsCA, "expected CA cert to be CA")
|
|
assert.False(t, normal.Certificate.IsCA, "expected normal cert not to be CA")
|
|
}
|
|
|
|
func TestChain(t *testing.T) {
|
|
var (
|
|
ca = NewEntity(Authority)
|
|
inter = ca.Issue(Authority)
|
|
leaf = inter.Issue()
|
|
)
|
|
|
|
ch := leaf.Chain()
|
|
require.Equal(t, 3, len(ch))
|
|
assert.True(t, ch[0].Equal(leaf.Certificate))
|
|
assert.True(t, ch[1].Equal(inter.Certificate))
|
|
assert.True(t, ch[2].Equal(ca.Certificate))
|
|
|
|
kc := leaf.KeyAndCertChain()
|
|
assert.Equal(t, leaf.Certificate.Raw, kc.Certificate.Raw)
|
|
assert.Equal(t, ca.Certificate.Raw, kc.Root.Raw)
|
|
assert.Equal(t, 1, len(kc.Chain))
|
|
assert.Equal(t, inter.Certificate.Raw, kc.Chain[0].Raw)
|
|
}
|
|
|
|
func TestMakeTSA(t *testing.T) {
|
|
oids := []asn1.ObjectIdentifier{oidExtKeyUsageTimeStamping}
|
|
eku, err := asn1.Marshal(oids)
|
|
require.NoError(t, err)
|
|
|
|
var (
|
|
ca = NewEntity(
|
|
Authority,
|
|
Subject(pkix.Name{
|
|
CommonName: "[TEST] Timestamp Root CA",
|
|
}),
|
|
KeyUsage(x509.KeyUsageCertSign|x509.KeyUsageCRLSign|x509.KeyUsageDigitalSignature),
|
|
)
|
|
inter1 = ca.Issue(
|
|
Authority,
|
|
Subject(pkix.Name{
|
|
CommonName: "[TEST] Timestamp Issuing CA Level 1",
|
|
}),
|
|
KeyUsage(x509.KeyUsageCertSign|x509.KeyUsageCRLSign|x509.KeyUsageDigitalSignature),
|
|
)
|
|
inter2 = inter1.Issue(
|
|
Authority,
|
|
Subject(pkix.Name{
|
|
CommonName: "[TEST] Timestamp Issuing CA Level 2",
|
|
}),
|
|
KeyUsage(x509.KeyUsageCertSign|x509.KeyUsageCRLSign|x509.KeyUsageDigitalSignature),
|
|
)
|
|
leaf = inter2.Issue(
|
|
Subject(pkix.Name{
|
|
CommonName: "[TEST] TSA",
|
|
}),
|
|
KeyUsage(x509.KeyUsageDigitalSignature),
|
|
Extensions([]pkix.Extension{
|
|
{
|
|
Id: oidExtKeyUsage,
|
|
Critical: true,
|
|
Value: eku,
|
|
},
|
|
}),
|
|
)
|
|
)
|
|
ch := leaf.Chain()
|
|
require.Equal(t, 4, len(ch))
|
|
|
|
assert.True(t, ch[0].Equal(leaf.Certificate))
|
|
assert.True(t, ch[1].Equal(inter2.Certificate))
|
|
assert.True(t, ch[2].Equal(inter1.Certificate))
|
|
assert.True(t, ch[3].Equal(ca.Certificate))
|
|
|
|
kc := leaf.KeyAndCertChain()
|
|
assert.Equal(t, leaf.Certificate.Raw, kc.Certificate.Raw)
|
|
assert.Equal(t, ca.Certificate.Raw, kc.Root.Raw)
|
|
assert.Equal(t, 2, len(kc.Chain))
|
|
assert.Equal(t, inter2.Certificate.Raw, kc.Chain[0].Raw)
|
|
assert.Equal(t, inter1.Certificate.Raw, kc.Chain[1].Raw)
|
|
}
|
|
|
|
func TestChainPool(t *testing.T) {
|
|
var (
|
|
ca = NewEntity(Authority)
|
|
inter = ca.Issue(Authority)
|
|
leaf = inter.Issue()
|
|
)
|
|
|
|
_, err := leaf.Certificate.Verify(x509.VerifyOptions{
|
|
Roots: ca.ChainPool(),
|
|
Intermediates: leaf.ChainPool(),
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// TestPFX decodes the PKCS#12 packet instead of only checking for a panic
|
|
// (XPKI-063).
|
|
func TestPFX(t *testing.T) {
|
|
ent := NewEntity()
|
|
var data []byte
|
|
assert.NotPanics(t, func() {
|
|
data = ent.PFX("as df!")
|
|
})
|
|
|
|
key, cert, err := pkcs12.Decode(data, "as df!")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, ent.Certificate.Raw, cert.Raw)
|
|
rsaKey, ok := key.(*rsa.PrivateKey)
|
|
require.True(t, ok, "default entity key is RSA")
|
|
assert.True(t, ent.PrivateKey.(*rsa.PrivateKey).Equal(rsaKey))
|
|
}
|
|
|
|
func Test_MakeValidCertsChainTSA(t *testing.T) {
|
|
// RSA
|
|
key, crt, chain, end := MakeValidCertsChainTSA(t, 24, false)
|
|
assert.NotNil(t, key)
|
|
assert.NotNil(t, crt)
|
|
assert.NotNil(t, chain)
|
|
assert.NotNil(t, end)
|
|
|
|
// EC
|
|
key, crt, chain, end = MakeValidCertsChainTSA(t, 24, true)
|
|
assert.NotNil(t, key)
|
|
assert.NotNil(t, crt)
|
|
assert.NotNil(t, chain)
|
|
assert.NotNil(t, end)
|
|
}
|
|
|
|
func Test_MakeInvalidCertsChainTSA(t *testing.T) {
|
|
key, crt, chain, end := MakeInvalidCertsChainTSA(t, 24)
|
|
assert.NotNil(t, key)
|
|
assert.NotNil(t, crt)
|
|
assert.NotNil(t, chain)
|
|
assert.NotNil(t, end)
|
|
}
|
|
|
|
func TestAIA(t *testing.T) {
|
|
i := NewEntity(IssuingCertificateURL("a", "b"), OCSPServer("c", "d"))
|
|
|
|
assert.Equal(t, []string{"a", "b"}, i.Certificate.IssuingCertificateURL, "bad IssuingCertificateURL: ", i.Certificate.IssuingCertificateURL)
|
|
assert.Equal(t, []string{"c", "d"}, i.Certificate.OCSPServer, "bad OCSPServer: ", i.Certificate.OCSPServer)
|
|
}
|
|
|
|
func TestSetSAN(t *testing.T) {
|
|
template := new(x509.Certificate)
|
|
assert.NotPanics(t, func() {
|
|
SetSAN(template, []string{
|
|
"localhost",
|
|
"127.0.0.1",
|
|
"[email protected]",
|
|
"https://effective-security.pt",
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestSaveCertAndKey(t *testing.T) {
|
|
ca1 := NewEntity(
|
|
Authority,
|
|
Subject(pkix.Name{
|
|
CommonName: "[TEST] Root CA One",
|
|
}),
|
|
KeyUsage(x509.KeyUsageCertSign|x509.KeyUsageCRLSign|x509.KeyUsageDigitalSignature),
|
|
)
|
|
inter1 := ca1.Issue(
|
|
Authority,
|
|
Subject(pkix.Name{
|
|
CommonName: "[TEST] Issuing CA One Level 1",
|
|
}),
|
|
KeyUsage(x509.KeyUsageCertSign|x509.KeyUsageCRLSign|x509.KeyUsageDigitalSignature),
|
|
)
|
|
srv := inter1.Issue(
|
|
Subject(pkix.Name{
|
|
CommonName: "localhost",
|
|
}),
|
|
ExtKeyUsage(x509.ExtKeyUsageServerAuth),
|
|
DNSName("localhost", "127.0.0.1"),
|
|
)
|
|
|
|
tmpDir := filepath.Join(os.TempDir(), "testca")
|
|
_ = os.MkdirAll(tmpDir, os.ModePerm)
|
|
defer func() {
|
|
_ = os.RemoveAll(tmpDir)
|
|
}()
|
|
|
|
serverCertFile := filepath.Join(tmpDir, "test-server.pem")
|
|
serverKeyFile := filepath.Join(tmpDir, "test-server-key.pem")
|
|
|
|
err := srv.SaveCertAndKey(serverCertFile, serverKeyFile, true)
|
|
require.NoError(t, err)
|
|
|
|
chain, err := certutil.LoadChainFromPEM(serverCertFile)
|
|
require.NoError(t, err)
|
|
assert.Len(t, chain, 2)
|
|
}
|