mirror of
https://github.com/hanzoai/pki.git
synced 2026-11-03 18:08:14 +00:00
229 lines
9.8 KiB
Go
229 lines
9.8 KiB
Go
package certutil_test
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
"crypto/ed25519"
|
|
"crypto/elliptic"
|
|
"crypto/rand"
|
|
"crypto/x509"
|
|
"crypto/x509/pkix"
|
|
"encoding/pem"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/effective-security/xpki/certutil"
|
|
"github.com/effective-security/xpki/testca"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func bundlerCA(t testing.TB, name string, parent *testca.Entity, opts ...testca.Option) *testca.Entity {
|
|
t.Helper()
|
|
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
|
require.NoError(t, err)
|
|
opts = append(opts, testca.PrivateKey(key), testca.Subject(pkix.Name{CommonName: name}), testca.Authority, testca.KeyUsage(x509.KeyUsageCertSign|x509.KeyUsageCRLSign))
|
|
if parent != nil {
|
|
opts = append(opts, testca.Issuer(parent))
|
|
}
|
|
return testca.NewEntity(opts...)
|
|
}
|
|
|
|
func TestBundlerAIA(t *testing.T) {
|
|
const leafName = "service.example.test"
|
|
for _, format := range []string{"der", "pem", "invalid", "truncated", "disabled"} {
|
|
t.Run(format, func(t *testing.T) {
|
|
var requests atomic.Int32
|
|
var intermediate *testca.Entity
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
requests.Add(1)
|
|
switch format {
|
|
case "invalid":
|
|
_, _ = w.Write([]byte("not a certificate"))
|
|
case "truncated":
|
|
w.Header().Set("Content-Length", "1000")
|
|
_, _ = w.Write([]byte("short"))
|
|
case "pem":
|
|
_, _ = w.Write(pem.EncodeToMemory(&pem.Block{
|
|
Type: "CERTIFICATE",
|
|
Bytes: intermediate.Certificate.Raw,
|
|
}))
|
|
default:
|
|
_, _ = w.Write(intermediate.Certificate.Raw)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
root := bundlerCA(t, "Root", nil)
|
|
intermediate = bundlerCA(t, "Intermediate CA", root, testca.IssuingCertificateURL(server.URL))
|
|
leaf := intermediate.Issue(testca.Subject(pkix.Name{CommonName: leafName}), testca.DNSName(leafName, "www.example.test"), testca.IssuingCertificateURL(server.URL))
|
|
old := certutil.IntermediateStash
|
|
certutil.IntermediateStash = filepath.Join(t.TempDir(), "stash")
|
|
t.Cleanup(func() { certutil.IntermediateStash = old })
|
|
client := server.Client()
|
|
client.Timeout = time.Second
|
|
b, err := certutil.NewBundler([]*x509.Certificate{root.Certificate}, nil, certutil.WithAIA(format != "disabled"), certutil.WithHTTPClient(client))
|
|
require.NoError(t, err)
|
|
chain, err := b.Bundle([]*x509.Certificate{leaf.Certificate}, leaf.PrivateKey)
|
|
if format == "invalid" || format == "truncated" || format == "disabled" {
|
|
require.ErrorContains(t, err, "unable to verify the certificate chain")
|
|
var unknown x509.UnknownAuthorityError
|
|
require.ErrorAs(t, err, &unknown)
|
|
assert.Nil(t, chain)
|
|
if format == "disabled" {
|
|
assert.Zero(t, requests.Load())
|
|
} else {
|
|
assert.Positive(t, requests.Load())
|
|
}
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
assert.Equal(t, []*x509.Certificate{leaf.Certificate, intermediate.Certificate}, chain.Chain)
|
|
assert.Same(t, root.Certificate, chain.Root)
|
|
assert.ElementsMatch(t, []string{leafName, "www.example.test"}, chain.Hostnames)
|
|
assert.True(t, b.KnownIssuers[string(intermediate.Certificate.Signature)])
|
|
files, err := os.ReadDir(certutil.IntermediateStash)
|
|
require.NoError(t, err)
|
|
require.Len(t, files, 1)
|
|
data, err := os.ReadFile(filepath.Join(certutil.IntermediateStash, files[0].Name()))
|
|
require.NoError(t, err)
|
|
saved, err := certutil.ParseFromPEM(data)
|
|
require.NoError(t, err)
|
|
assert.True(t, intermediate.Certificate.Equal(saved))
|
|
before := requests.Load()
|
|
_, err = b.Bundle([]*x509.Certificate{leaf.Certificate}, nil)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, before, requests.Load(), "cached intermediate avoids another fetch")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBundlerFilesAndValidation(t *testing.T) {
|
|
root := bundlerCA(t, "Root", nil)
|
|
intermediate := bundlerCA(t, "Intermediate", root)
|
|
leaf := intermediate.Issue(testca.Subject(pkix.Name{CommonName: "leaf.example"}))
|
|
dir := t.TempDir()
|
|
rootFile, intFile := filepath.Join(dir, "root.pem"), filepath.Join(dir, "intermediate.pem")
|
|
certFile, keyFile := filepath.Join(dir, "leaf.pem"), filepath.Join(dir, "key.pem")
|
|
require.NoError(t, root.SaveCertAndKey(rootFile, "", false))
|
|
require.NoError(t, intermediate.SaveCertAndKey(intFile, "", false))
|
|
require.NoError(t, leaf.SaveCertAndKey(certFile, keyFile, true))
|
|
b, err := certutil.LoadBundler(rootFile, intFile, certutil.WithKeyUsages(x509.ExtKeyUsageAny))
|
|
require.NoError(t, err)
|
|
chain, err := b.ChainFromFile(certFile, keyFile, "")
|
|
require.NoError(t, err)
|
|
assert.Same(t, chain.Cert, chain.Chain[0])
|
|
assert.NotNil(t, chain.Key)
|
|
chain, err = b.ChainFromFile(certFile, "", "")
|
|
require.NoError(t, err)
|
|
assert.Nil(t, chain.Key)
|
|
emptyFile := filepath.Join(dir, "empty.pem")
|
|
require.NoError(t, os.WriteFile(emptyFile, nil, 0600))
|
|
for _, tc := range []struct{ name, cert, key, want string }{
|
|
{"missing certificate", dir + "/missing", "", "failed to load bundle"},
|
|
{"missing key", certFile, dir + "/missing", "failed to load private key"},
|
|
{"empty key", certFile, emptyFile, "empty private key"},
|
|
{"certificate as key", certFile, certFile, "private key"},
|
|
{"empty certificate", emptyFile, "", "failed to parse certificates"},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
got, err := b.ChainFromFile(tc.cert, tc.key, "password")
|
|
require.ErrorContains(t, err, tc.want)
|
|
assert.Nil(t, got)
|
|
})
|
|
}
|
|
badFile := filepath.Join(dir, "bad.pem")
|
|
require.NoError(t, os.WriteFile(badFile, []byte("invalid PEM"), 0600))
|
|
for _, tc := range []struct{ name, root, inter, want string }{
|
|
{"missing roots", dir + "/missing", "", "root bundle failed to load"},
|
|
{"missing intermediates", rootFile, dir + "/missing", "intermediate CA bundle failed to load"},
|
|
{"bad roots", badFile, "", "failed to parse root bundle"},
|
|
{"bad intermediates", rootFile, badFile, "failed to parse intermediate bundle"},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
got, err := certutil.LoadBundler(tc.root, tc.inter)
|
|
require.ErrorContains(t, err, tc.want)
|
|
assert.Nil(t, got)
|
|
})
|
|
}
|
|
_, err = b.ChainFromPEM([]byte("invalid"), nil, "")
|
|
require.Error(t, err)
|
|
bundle, status, err := certutil.LoadAndVerifyBundleFromPEM(certFile, intFile, rootFile)
|
|
require.NoError(t, err)
|
|
assert.False(t, status.IsUntrusted())
|
|
assert.True(t, leaf.Certificate.Equal(bundle.Cert))
|
|
for _, paths := range [][3]string{{dir + "/missing", intFile, rootFile}, {certFile, dir + "/missing", rootFile}, {certFile, intFile, dir + "/missing"}} {
|
|
_, _, err := certutil.LoadAndVerifyBundleFromPEM(paths[0], paths[1], paths[2])
|
|
require.ErrorIs(t, err, os.ErrNotExist)
|
|
}
|
|
}
|
|
|
|
func TestBundlerChainBehavior(t *testing.T) {
|
|
root := bundlerCA(t, "Root", nil)
|
|
intermediate := bundlerCA(t, "Intermediate", root, testca.NotAfter(time.Now().Add(48*time.Hour)))
|
|
leaf := intermediate.Issue(testca.Subject(pkix.Name{CommonName: "leaf"}), testca.NotAfter(time.Now().Add(24*time.Hour)))
|
|
force, err := certutil.NewBundler(nil, nil, certutil.WithBundleFlavor(certutil.Force))
|
|
require.NoError(t, err)
|
|
chain, err := force.Bundle([]*x509.Certificate{root.Certificate, intermediate.Certificate, leaf.Certificate}, leaf.PrivateKey)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, leaf.Chain(), chain.Chain)
|
|
assert.True(t, chain.Status.IsExpiring())
|
|
assert.Nil(t, chain.Root)
|
|
assert.Equal(t, leaf.Certificate.NotAfter, chain.Expires)
|
|
assert.Contains(t, chain.Status.Messages[0], "#1 #2")
|
|
assert.Len(t, chain.Status.ExpiringSKIs, 2)
|
|
// XPKI-036: empty input is an error; see TestBundlerEmptyInput.
|
|
chain, err = force.Bundle(nil, nil)
|
|
require.ErrorIs(t, err, certutil.ErrNoCertificates)
|
|
assert.Nil(t, chain)
|
|
_, err = force.Bundle([]*x509.Certificate{leaf.Certificate, root.Certificate}, nil)
|
|
require.EqualError(t, err, "unable to verify the certificate chain")
|
|
optimal, err := certutil.NewBundler([]*x509.Certificate{root.Certificate}, nil)
|
|
require.NoError(t, err)
|
|
_, err = optimal.Bundle([]*x509.Certificate{root.Certificate}, nil)
|
|
require.EqualError(t, err, "self-signed certificate")
|
|
chain, err = optimal.Bundle([]*x509.Certificate{leaf.Certificate, intermediate.Certificate}, nil)
|
|
require.NoError(t, err)
|
|
assert.Len(t, chain.Chain, 2)
|
|
for _, ocsp := range []bool{false, true} {
|
|
t.Run(fmt.Sprint("direct root OCSP ", ocsp), func(t *testing.T) {
|
|
opts := []testca.Option{testca.Subject(pkix.Name{CommonName: "direct"})}
|
|
if ocsp {
|
|
opts = append(opts, testca.OCSPServer("http://ocsp.example.test"))
|
|
}
|
|
direct := root.Issue(opts...)
|
|
chain, err := optimal.Bundle([]*x509.Certificate{direct.Certificate}, nil)
|
|
require.NoError(t, err)
|
|
if ocsp {
|
|
assert.Len(t, chain.Chain, 2)
|
|
} else {
|
|
assert.Len(t, chain.Chain, 1)
|
|
}
|
|
})
|
|
}
|
|
expired := root.Issue(testca.Subject(pkix.Name{CommonName: "expired"}), testca.NotAfter(time.Now().Add(-time.Hour)))
|
|
_, err = optimal.Bundle([]*x509.Certificate{expired.Certificate}, nil)
|
|
require.ErrorContains(t, err, "expired")
|
|
_, edkey, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
ed := root.Issue(testca.Subject(pkix.Name{CommonName: "ed25519"}), testca.PrivateKey(edkey))
|
|
_, err = force.Bundle([]*x509.Certificate{ed.Certificate}, edkey)
|
|
require.EqualError(t, err, "unsupported key")
|
|
_, err = force.Bundle([]*x509.Certificate{ed.Certificate}, nil)
|
|
require.EqualError(t, err, "unsupported key")
|
|
_, err = force.Bundle([]*x509.Certificate{intermediate.Certificate}, leaf.PrivateKey)
|
|
require.EqualError(t, err, "key mismatch")
|
|
other := bundlerCA(t, "Other", nil)
|
|
_, err = force.Bundle([]*x509.Certificate{intermediate.Certificate}, other.PrivateKey)
|
|
require.EqualError(t, err, "key mismatch")
|
|
chain, err = force.Bundle([]*x509.Certificate{intermediate.Certificate}, intermediate.PrivateKey)
|
|
require.NoError(t, err)
|
|
assert.Same(t, intermediate.PrivateKey, chain.Key)
|
|
assert.True(t, certutil.ExpiryTime(nil).IsZero())
|
|
assert.Equal(t, leaf.Certificate.NotAfter, certutil.ExpiryTime([]*x509.Certificate{root.Certificate, leaf.Certificate}))
|
|
}
|