mirror of
https://github.com/hanzoai/pki.git
synced 2026-11-03 18:08:14 +00:00
207 lines
6.4 KiB
Go
207 lines
6.4 KiB
Go
package crypto11
|
|
|
|
import (
|
|
"crypto/elliptic"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
pkcs11 "github.com/miekg/pkcs11"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// Methods that take a caller session, and ExportKey, fail with errClosed
|
|
// after Close instead of dereferencing the nil Ctx.
|
|
func TestClose_SessionMethodsReturnErrClosed(t *testing.T) {
|
|
t.Parallel()
|
|
lib, _ := newFakeLib(1)
|
|
// Init always sets the slot; ExportKey and EnumTokens(true) read it
|
|
lib.Slot = &SlotTokenInfo{id: testSlot}
|
|
require.NoError(t, lib.Close())
|
|
const session = pkcs11.SessionHandle(1)
|
|
|
|
calls := map[string]func() error{
|
|
"ListKeys": func() error {
|
|
_, err := lib.ListKeys(session, pkcs11.CKO_PRIVATE_KEY, ^uint(0))
|
|
return err
|
|
},
|
|
"FindKeys": func() error {
|
|
_, err := lib.FindKeys(session, "label", pkcs11.CKO_PRIVATE_KEY, ^uint(0))
|
|
return err
|
|
},
|
|
"FindKeyPairOnSession": func() error {
|
|
_, err := lib.FindKeyPairOnSession(session, testSlot, "id", "")
|
|
return err
|
|
},
|
|
"GenerateRSAKeyPairOnSession": func() error {
|
|
_, err := lib.GenerateRSAKeyPairOnSession(session, testSlot, nil, nil, 2048, Signing)
|
|
return err
|
|
},
|
|
"GenerateECDSAKeyPairOnSession": func() error {
|
|
_, err := lib.GenerateECDSAKeyPairOnSession(session, testSlot, nil, nil, elliptic.P256())
|
|
return err
|
|
},
|
|
"ExportKey": func() error {
|
|
_, _, err := lib.ExportKey("id")
|
|
return err
|
|
},
|
|
"EnumTokens(current)": func() error {
|
|
_, err := lib.EnumTokens(true)
|
|
return err
|
|
},
|
|
}
|
|
for name, call := range calls {
|
|
t.Run(name, func(t *testing.T) {
|
|
var err error
|
|
require.NotPanics(t, func() { err = call() })
|
|
assert.ErrorIs(t, err, errClosed)
|
|
})
|
|
}
|
|
}
|
|
|
|
// A Close that starts once ExportKey is admitted waits for its lookup and
|
|
// token info read. Before the first fix Close finished and GetTokenInfo ran
|
|
// on the nil Ctx; before the second, the nested lookup returned errClosed.
|
|
// Not parallel: it sets the exportKeyAdmitted hook.
|
|
func TestExportKey_CloseWhileAdmitted(t *testing.T) {
|
|
requireP11(t)
|
|
priv, err := p11lib.GenerateECDSAKeyPair(elliptic.P256())
|
|
require.NoError(t, err)
|
|
keyID := string(mustKeyID(t, priv))
|
|
t.Cleanup(func() { _ = p11lib.DestroyKeyPairOnSlot(p11lib.Slot.id, keyID) })
|
|
|
|
lib2, err := Init(loadTestConfig(t))
|
|
require.NoError(t, err)
|
|
|
|
closed := make(chan error, 1)
|
|
exportKeyAdmitted = func() {
|
|
go func() { closed <- lib2.Close() }()
|
|
// give Close time to finish if it does not wait for ExportKey
|
|
assertBlocked(t, closed)
|
|
}
|
|
t.Cleanup(func() { exportKeyAdmitted = func() {} })
|
|
|
|
var uri string
|
|
require.NotPanics(t, func() {
|
|
uri, _, err = lib2.ExportKey(keyID)
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Contains(t, uri, "id="+keyID)
|
|
require.NoError(t, waitErr(t, closed))
|
|
|
|
_, _, err = lib2.ExportKey(keyID)
|
|
assert.ErrorIs(t, err, errClosed)
|
|
}
|
|
|
|
// XPKI-001 review: a concurrent Close waits for the first one, and both
|
|
// report the failure to close a session that was borrowed during Close.
|
|
func TestClose_ConcurrentCallsShareResult(t *testing.T) {
|
|
t.Parallel()
|
|
lib, f := newFakeLib(1)
|
|
release := make(chan struct{})
|
|
_, holder := holdSession(t, lib, testSlot, release)
|
|
|
|
f.mu.Lock()
|
|
f.closeErr = pkcs11.Error(pkcs11.CKR_DEVICE_ERROR)
|
|
f.mu.Unlock()
|
|
|
|
first := make(chan error, 1)
|
|
second := make(chan error, 1)
|
|
go func() { first <- lib.Close() }()
|
|
go func() { second <- lib.Close() }()
|
|
assertBlocked(t, first)
|
|
assertBlocked(t, second)
|
|
|
|
close(release)
|
|
require.NoError(t, waitErr(t, holder))
|
|
err1 := waitErr(t, first)
|
|
err2 := waitErr(t, second)
|
|
require.ErrorIs(t, err1, pkcs11.Error(pkcs11.CKR_DEVICE_ERROR))
|
|
assert.Equal(t, err1, err2)
|
|
assert.Equal(t, err1, lib.Close())
|
|
}
|
|
|
|
// A failure closing a session returned after Close started is reported by
|
|
// Close, as for idle sessions; before the fix it was only logged.
|
|
func TestClose_ReportsReturnedSessionErrors(t *testing.T) {
|
|
t.Parallel()
|
|
lib, f := newFakeLib(1)
|
|
release := make(chan struct{})
|
|
held, holder := holdSession(t, lib, testSlot, release)
|
|
|
|
closed := make(chan error, 1)
|
|
go func() { closed <- lib.Close() }()
|
|
assertBlocked(t, closed)
|
|
|
|
f.mu.Lock()
|
|
f.closeErr = pkcs11.Error(pkcs11.CKR_DEVICE_ERROR)
|
|
f.mu.Unlock()
|
|
close(release)
|
|
require.NoError(t, waitErr(t, holder))
|
|
|
|
err := waitErr(t, closed)
|
|
require.ErrorIs(t, err, pkcs11.Error(pkcs11.CKR_DEVICE_ERROR))
|
|
assert.Contains(t, err.Error(), "close session on slot 7")
|
|
f.mu.Lock()
|
|
_, open := f.live[held]
|
|
f.mu.Unlock()
|
|
assert.False(t, open)
|
|
}
|
|
|
|
func TestModuleID(t *testing.T) {
|
|
dir := t.TempDir()
|
|
lib := filepath.Join(dir, "libtest.so")
|
|
require.NoError(t, os.WriteFile(lib, []byte("lib"), 0o600))
|
|
other := filepath.Join(dir, "libother.so")
|
|
require.NoError(t, os.WriteFile(other, []byte("lib"), 0o600))
|
|
link := filepath.Join(dir, "liblink.so")
|
|
require.NoError(t, os.Symlink(lib, link))
|
|
hard := filepath.Join(dir, "libhard.so")
|
|
require.NoError(t, os.Link(lib, hard))
|
|
missing := filepath.Join(dir, "libmissing.so")
|
|
|
|
id := newModuleID(lib)
|
|
assert.True(t, id.same(newModuleID(lib)))
|
|
assert.True(t, id.same(newModuleID(link)), "symlink")
|
|
assert.True(t, id.same(newModuleID(hard)), "hardlink")
|
|
assert.True(t, id.same(newModuleID(filepath.Join(dir, ".", "libtest.so"))), "unclean path")
|
|
assert.False(t, id.same(newModuleID(other)), "different file")
|
|
assert.True(t, newModuleID(missing).same(newModuleID(missing)))
|
|
assert.False(t, newModuleID(missing).same(id))
|
|
|
|
// a bare name is resolved by the loader, not the working directory
|
|
sub1 := filepath.Join(dir, "a")
|
|
sub2 := filepath.Join(dir, "b")
|
|
require.NoError(t, os.Mkdir(sub1, 0o700))
|
|
require.NoError(t, os.Mkdir(sub2, 0o700))
|
|
require.NoError(t, os.WriteFile(filepath.Join(sub1, "libtest.so"), []byte("a"), 0o600))
|
|
t.Chdir(sub1)
|
|
bare1 := newModuleID("libtest.so")
|
|
t.Chdir(sub2)
|
|
bare2 := newModuleID("libtest.so")
|
|
assert.Nil(t, bare1.info)
|
|
assert.True(t, bare1.same(bare2), "bare name from two directories")
|
|
assert.False(t, bare1.same(id), "bare name is not matched to a path")
|
|
}
|
|
|
|
// A symlink to the loaded library shares its module.
|
|
func TestInit_SymlinkSharesModule(t *testing.T) {
|
|
requireP11(t)
|
|
cfg := loadTestConfig(t)
|
|
link := filepath.Join(t.TempDir(), "libpkcs11.so")
|
|
require.NoError(t, os.Symlink(cfg.Path(), link))
|
|
refs := moduleRefs(cfg.Path())
|
|
|
|
lib2, err := Init(&config{
|
|
Dir: link,
|
|
Label: cfg.TokenLabel(),
|
|
Pwd: cfg.Pin(),
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Same(t, p11lib.Ctx, lib2.Ctx)
|
|
assert.Equal(t, refs+1, moduleRefs(link))
|
|
closeLib(t, lib2)
|
|
assert.Equal(t, refs, moduleRefs(cfg.Path()))
|
|
}
|