mirror of
https://github.com/hanzoai/pki.git
synced 2026-11-03 18:08:14 +00:00
315 lines
9.5 KiB
Go
315 lines
9.5 KiB
Go
package cryptoprov_test
|
|
|
|
import (
|
|
stderrors "errors"
|
|
"os"
|
|
"path/filepath"
|
|
"sync/atomic"
|
|
"testing"
|
|
|
|
"github.com/cockroachdb/errors"
|
|
"github.com/effective-security/xpki/cryptoprov"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// valueProvider is a provider passed by value whose dynamic type is not
|
|
// comparable, so it can never be the same instance as another one.
|
|
type valueProvider struct {
|
|
*namedProvider
|
|
tags []string
|
|
}
|
|
|
|
// comparableValueProvider is a provider passed by value whose dynamic type is
|
|
// comparable.
|
|
type comparableValueProvider struct {
|
|
*namedProvider
|
|
}
|
|
|
|
// assertIs checks err against target with both stdlib and cockroachdb Is.
|
|
func assertIs(t *testing.T, err, target error) {
|
|
t.Helper()
|
|
assert.True(t, stderrors.Is(err, target), "stdlib errors.Is(%v, %v)", err, target)
|
|
assert.True(t, errors.Is(err, target), "cockroachdb errors.Is(%v, %v)", err, target)
|
|
}
|
|
|
|
func TestNew_Nil(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var typedNil *namedProvider
|
|
for _, tc := range []struct {
|
|
name string
|
|
def cryptoprov.Provider
|
|
}{
|
|
{name: "untyped", def: nil},
|
|
{name: "typed", def: typedNil},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
cp, err := cryptoprov.New(tc.def, nil)
|
|
require.EqualError(t, err, "default provider is required: nil provider")
|
|
assertIs(t, err, cryptoprov.ErrNilProvider)
|
|
assert.Nil(t, cp)
|
|
})
|
|
}
|
|
|
|
t.Run("nil entry", func(t *testing.T) {
|
|
cp, err := cryptoprov.New(newNamedProvider("default", "m"),
|
|
[]cryptoprov.Provider{newNamedProvider("a", "m"), typedNil})
|
|
require.EqualError(t, err, "unable to add provider at index 1: unable to add provider: nil provider")
|
|
assertIs(t, err, cryptoprov.ErrNilProvider)
|
|
assert.Nil(t, cp)
|
|
})
|
|
}
|
|
|
|
func TestNew_DefaultOnly(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
def := newNamedProvider("default", "m")
|
|
cp, err := cryptoprov.New(def, nil)
|
|
require.NoError(t, err)
|
|
assert.Same(t, def, cp.Default())
|
|
|
|
got, err := cp.ByManufacturer("default", "m")
|
|
require.NoError(t, err)
|
|
assert.Same(t, def, got)
|
|
|
|
_, err = cp.ByManufacturer("default", "other")
|
|
assert.EqualError(t, err, `provider for "default" and model "other" not found`)
|
|
}
|
|
|
|
func TestCryptoAdd_Duplicates(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
def := newNamedProvider("default", "m")
|
|
a := newNamedProvider("a", "m")
|
|
cp, err := cryptoprov.New(def, []cryptoprov.Provider{a})
|
|
require.NoError(t, err)
|
|
|
|
t.Run("same instance", func(t *testing.T) {
|
|
require.NoError(t, cp.Add(a))
|
|
require.NoError(t, cp.Add(a))
|
|
require.NoError(t, cp.Add(def))
|
|
require.NoError(t, cp.Add(def))
|
|
})
|
|
|
|
t.Run("other instance", func(t *testing.T) {
|
|
err := cp.Add(newNamedProvider("a", "m"))
|
|
require.EqualError(t, err, `manufacturer "a" and model "m": duplicate provider`)
|
|
assertIs(t, err, cryptoprov.ErrDuplicateProvider)
|
|
})
|
|
|
|
t.Run("other instance of default", func(t *testing.T) {
|
|
err := cp.Add(newNamedProvider("default", "m"))
|
|
require.EqualError(t, err, `manufacturer "default" and model "m": duplicate provider`)
|
|
assertIs(t, err, cryptoprov.ErrDuplicateProvider)
|
|
})
|
|
|
|
t.Run("same manufacturer other model", func(t *testing.T) {
|
|
b := newNamedProvider("a", "other")
|
|
require.NoError(t, cp.Add(b))
|
|
got, err := cp.ByManufacturer("a", "other")
|
|
require.NoError(t, err)
|
|
assert.Same(t, b, got)
|
|
})
|
|
|
|
t.Run("key parts are not concatenated", func(t *testing.T) {
|
|
// both were "x@y@z" in the old manufacturer + "@" + model key
|
|
xy := newNamedProvider("x@y", "z")
|
|
yz := newNamedProvider("x", "y@z")
|
|
require.NoError(t, cp.Add(xy))
|
|
require.NoError(t, cp.Add(yz))
|
|
got, err := cp.ByManufacturer("x@y", "z")
|
|
require.NoError(t, err)
|
|
assert.Same(t, xy, got)
|
|
got, err = cp.ByManufacturer("x", "y@z")
|
|
require.NoError(t, err)
|
|
assert.Same(t, yz, got)
|
|
})
|
|
|
|
t.Run("nil", func(t *testing.T) {
|
|
var typedNil *namedProvider
|
|
assertIs(t, cp.Add(nil), cryptoprov.ErrNilProvider)
|
|
err := cp.Add(typedNil)
|
|
require.EqualError(t, err, "unable to add provider: nil provider")
|
|
assertIs(t, err, cryptoprov.ErrNilProvider)
|
|
})
|
|
|
|
// the originals are kept
|
|
got, err := cp.ByManufacturer("a", "m")
|
|
require.NoError(t, err)
|
|
assert.Same(t, a, got)
|
|
got, err = cp.ByManufacturer("default", "m")
|
|
require.NoError(t, err)
|
|
assert.Same(t, def, got)
|
|
}
|
|
|
|
func TestCryptoAdd_ValueProviders(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cp, err := cryptoprov.New(newNamedProvider("default", "m"), nil)
|
|
require.NoError(t, err)
|
|
|
|
// a comparable value equal to the registered one is the same provider
|
|
cv := comparableValueProvider{namedProvider: newNamedProvider("cv", "m")}
|
|
require.NoError(t, cp.Add(cv))
|
|
require.NoError(t, cp.Add(cv))
|
|
|
|
// a non-comparable value is never the same provider, and must not panic
|
|
vp := valueProvider{namedProvider: newNamedProvider("vp", "m")}
|
|
require.NoError(t, cp.Add(vp))
|
|
assert.NotPanics(t, func() {
|
|
err = cp.Add(vp)
|
|
})
|
|
assertIs(t, err, cryptoprov.ErrDuplicateProvider)
|
|
}
|
|
|
|
func TestCrypto_ZeroValue(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var cp cryptoprov.Crypto
|
|
assert.Nil(t, cp.Default())
|
|
|
|
_, err := cp.ByManufacturer("a", "m")
|
|
assert.EqualError(t, err, `provider for "a" and model "m" not found`)
|
|
|
|
a := newNamedProvider("a", "m")
|
|
require.NoError(t, cp.Add(a))
|
|
got, err := cp.ByManufacturer("a", "m")
|
|
require.NoError(t, err)
|
|
assert.Same(t, a, got)
|
|
}
|
|
|
|
const closerManufacturer = "cryptoprov-test-closer"
|
|
|
|
// closerProvider counts Close calls; Load must close what it loaded when it
|
|
// fails.
|
|
type closerProvider struct {
|
|
*namedProvider
|
|
closed *atomic.Int32
|
|
}
|
|
|
|
func (p *closerProvider) Close() error {
|
|
p.closed.Add(1)
|
|
return errors.New("close failed")
|
|
}
|
|
|
|
// registerCloserLoader registers a loader for closerManufacturer until the
|
|
// end of t and returns the count of closed providers.
|
|
func registerCloserLoader(t *testing.T) *atomic.Int32 {
|
|
t.Helper()
|
|
closed := &atomic.Int32{}
|
|
require.NoError(t, cryptoprov.Register(closerManufacturer, func(tc cryptoprov.TokenConfig) (cryptoprov.Provider, error) {
|
|
return &closerProvider{
|
|
namedProvider: newNamedProvider(tc.Manufacturer(), tc.Model()),
|
|
closed: closed,
|
|
}, nil
|
|
}))
|
|
t.Cleanup(func() {
|
|
_, err := cryptoprov.Unregister(closerManufacturer)
|
|
assert.NoError(t, err)
|
|
})
|
|
return closed
|
|
}
|
|
|
|
// writeTokenConfig writes a YAML token config with manufacturer, model and
|
|
// the optional attributes line.
|
|
func writeTokenConfig(t *testing.T, manufacturer, model string, attributes ...string) string {
|
|
t.Helper()
|
|
cfg := filepath.Join(t.TempDir(), "token.yaml")
|
|
body := "manufacturer: " + manufacturer + "\nmodel: " + model + "\n"
|
|
for _, attr := range attributes {
|
|
body += "attributes: " + attr + "\n"
|
|
}
|
|
require.NoError(t, os.WriteFile(cfg, []byte(body), 0600))
|
|
return cfg
|
|
}
|
|
|
|
// The registry is process-global, so these tests do not run in parallel.
|
|
func TestLoad_ClosesOnError(t *testing.T) {
|
|
closed := registerCloserLoader(t)
|
|
cfgA := writeTokenConfig(t, closerManufacturer, "a")
|
|
cfgB := writeTokenConfig(t, closerManufacturer, "b")
|
|
|
|
t.Run("ok", func(t *testing.T) {
|
|
closed.Store(0)
|
|
cp, err := cryptoprov.Load(cfgA, []string{cfgB})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "a", cp.Default().Model())
|
|
b, err := cp.ByManufacturer(closerManufacturer, "b")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "b", b.Model())
|
|
assert.Zero(t, closed.Load())
|
|
})
|
|
|
|
t.Run("duplicate", func(t *testing.T) {
|
|
closed.Store(0)
|
|
cp, err := cryptoprov.Load(cfgA, []string{cfgB, cfgA})
|
|
require.Error(t, err)
|
|
assert.Equal(t, "unable to add provider from "+cfgA+`: manufacturer "`+closerManufacturer+`" and model "a": duplicate provider`, err.Error())
|
|
assertIs(t, err, cryptoprov.ErrDuplicateProvider)
|
|
assert.Nil(t, cp)
|
|
assert.EqualValues(t, 3, closed.Load())
|
|
})
|
|
|
|
t.Run("missing config", func(t *testing.T) {
|
|
closed.Store(0)
|
|
cp, err := cryptoprov.Load(cfgA, []string{filepath.Join(t.TempDir(), "missing.yaml")})
|
|
require.Error(t, err)
|
|
assert.Nil(t, cp)
|
|
assert.EqualValues(t, 1, closed.Load())
|
|
})
|
|
}
|
|
|
|
const valueManufacturer = "cryptoprov-test-value"
|
|
|
|
// TestLoad_NonComparableDefault loads a default provider whose dynamic value
|
|
// is not comparable; Load must not report it as its own duplicate
|
|
// (XPKI-113).
|
|
func TestLoad_NonComparableDefault(t *testing.T) {
|
|
require.NoError(t, cryptoprov.Register(valueManufacturer, func(tc cryptoprov.TokenConfig) (cryptoprov.Provider, error) {
|
|
return valueProvider{namedProvider: newNamedProvider(tc.Manufacturer(), tc.Model())}, nil
|
|
}))
|
|
t.Cleanup(func() {
|
|
_, err := cryptoprov.Unregister(valueManufacturer)
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
cp, err := cryptoprov.Load(writeTokenConfig(t, valueManufacturer, "a"), []string{
|
|
writeTokenConfig(t, valueManufacturer, "b"),
|
|
})
|
|
require.NoError(t, err)
|
|
assert.IsType(t, valueProvider{}, cp.Default())
|
|
|
|
def, err := cp.ByManufacturer(valueManufacturer, "a")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "a", def.Model())
|
|
b, err := cp.ByManufacturer(valueManufacturer, "b")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "b", b.Model())
|
|
}
|
|
|
|
func TestLoad_InmemDuplicate(t *testing.T) {
|
|
// inmem_testprov.json names the same manufacturer and model as the
|
|
// default "" config, but loads another instance
|
|
cp, err := cryptoprov.Load("", []string{"testdata/inmem_testprov.json"})
|
|
require.Error(t, err)
|
|
assertIs(t, err, cryptoprov.ErrDuplicateProvider)
|
|
assert.Nil(t, cp)
|
|
}
|
|
|
|
func TestLoadProvider_Registry(t *testing.T) {
|
|
cfg := writeTokenConfig(t, closerManufacturer, "a")
|
|
|
|
_, err := cryptoprov.LoadProvider(cfg)
|
|
assert.EqualError(t, err, "provider not registered: "+closerManufacturer)
|
|
|
|
registerCloserLoader(t)
|
|
p, err := cryptoprov.LoadProvider(cfg)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, closerManufacturer, p.Manufacturer())
|
|
assert.Equal(t, "a", p.Model())
|
|
|
|
err = cryptoprov.Register(closerManufacturer, nil)
|
|
assert.EqualError(t, err, "already registered: "+closerManufacturer)
|
|
}
|