@reegaviljoen/eldlock 0.1.0

package/eldlock-server/internal/store/store_test.go

@@ -0,0 +1,125 @@
+package store
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestFileStorePutGetList(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "vault.json")
+	store := NewFileStore(path, staticKeyProvider{})
+
+	if initialized, err := store.IsInitialized(); err != nil {
+		t.Fatalf("IsInitialized() error = %v", err)
+	} else if initialized {
+		t.Fatalf("IsInitialized() = true before Init")
+	}
+
+	if err := store.Init(); err != nil {
+		t.Fatalf("Init() error = %v", err)
+	}
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("ReadFile() error = %v", err)
+	}
+	if strings.Contains(string(raw), "secret-value") {
+		t.Fatalf("encrypted vault contains plaintext secret")
+	}
+	if initialized, err := store.IsInitialized(); err != nil {
+		t.Fatalf("IsInitialized() error = %v", err)
+	} else if !initialized {
+		t.Fatalf("IsInitialized() = false after Init")
+	}
+
+	if err := store.Put(Secret{Name: "app/API_KEY", Type: SecretTypeEnv, Value: "secret-value"}); err != nil {
+		t.Fatalf("Put() error = %v", err)
+	}
+	if err := store.Put(Secret{Name: "ssh/personal", Type: SecretTypeSSH, Value: "private-key"}); err != nil {
+		t.Fatalf("Put() error = %v", err)
+	}
+
+	got, err := store.Get("app/API_KEY")
+	if err != nil {
+		t.Fatalf("Get() error = %v", err)
+	}
+	if got.Value != "secret-value" {
+		t.Fatalf("Get().Value = %q, want secret value", got.Value)
+	}
+
+	summaries, err := store.List()
+	if err != nil {
+		t.Fatalf("List() error = %v", err)
+	}
+	if len(summaries) != 2 {
+		t.Fatalf("List() length = %d, want 2", len(summaries))
+	}
+	if summaries[0].Name != "app/API_KEY" || summaries[1].Name != "ssh/personal" {
+		t.Fatalf("List() names = %#v, want sorted names", summaries)
+	}
+
+	if err := store.Delete("app/API_KEY"); err != nil {
+		t.Fatalf("Delete() error = %v", err)
+	}
+	if _, err := store.Get("app/API_KEY"); !errors.Is(err, ErrNotFound) {
+		t.Fatalf("Get() after Delete() error = %v, want ErrNotFound", err)
+	}
+}
+
+func TestFileStoreGetMissing(t *testing.T) {
+	store := NewFileStore(filepath.Join(t.TempDir(), "vault.json"), staticKeyProvider{})
+	if err := store.Init(); err != nil {
+		t.Fatalf("Init() error = %v", err)
+	}
+
+	_, err := store.Get("missing")
+	if !errors.Is(err, ErrNotFound) {
+		t.Fatalf("Get() error = %v, want ErrNotFound", err)
+	}
+}
+
+func TestFileStoreDeleteMissing(t *testing.T) {
+	store := NewFileStore(filepath.Join(t.TempDir(), "vault.json"), staticKeyProvider{})
+	if err := store.Init(); err != nil {
+		t.Fatalf("Init() error = %v", err)
+	}
+
+	if err := store.Delete("missing"); !errors.Is(err, ErrNotFound) {
+		t.Fatalf("Delete() error = %v, want ErrNotFound", err)
+	}
+}
+
+func TestFileStoreRejectsWrongPasskey(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "vault.json")
+	store := NewFileStore(path, staticKeyProvider{secret: "correct passkey material that is long enough"})
+	if err := store.Init(); err != nil {
+		t.Fatalf("Init() error = %v", err)
+	}
+	if err := store.Put(Secret{Name: "app/API_KEY", Type: SecretTypeEnv, Value: "secret-value"}); err != nil {
+		t.Fatalf("Put() error = %v", err)
+	}
+
+	wrong := NewFileStore(path, staticKeyProvider{secret: "wrong passkey material that is also long enough"})
+	if _, err := wrong.Get("app/API_KEY"); err == nil {
+		t.Fatalf("Get() with wrong passkey succeeded")
+	}
+}
+
+type staticKeyProvider struct {
+	secret string
+}
+
+func (p staticKeyProvider) CreateKeyMaterial(operation string, salt []byte) ([]byte, map[string]string, error) {
+	material, err := p.OpenKeyMaterial(operation, salt, nil)
+	return material, map[string]string{"provider": "static"}, err
+}
+
+func (p staticKeyProvider) OpenKeyMaterial(_ string, _ []byte, _ map[string]string) ([]byte, error) {
+	secret := p.secret
+	if secret == "" {
+		secret = "test passkey material that is deliberately longer than thirty two bytes"
+	}
+	return []byte(secret), nil
+}

package/eldlock-server/internal/yubikey/README.md

@@ -0,0 +1,25 @@
+# YubiKey
+
+YubiKey-backed unlock or wrapping provider.
+
+The YubiKey should participate in unwrapping key material. It should not be only a cosmetic approval check.
+
+Current implementation note: automated tests use the stub provider (`ELDLOCK_STUB_PASSKEY`). Manual YubiKey Bio tests can use the build-tagged FIDO2 hmac-secret provider:
+
+```bash
+brew install libfido2
+export GOFLAGS="-tags=fido2"
+export ELDLOCK_FIDO2_UV=true
+```
+
+Optional settings:
+
+- `ELDLOCK_FIDO2_DEVICE` to pin a specific authenticator path.
+- `ELDLOCK_FIDO2_RP_ID` to override the relying party ID, default `eldlock.local`.
+- `ELDLOCK_FIDO2_UV=true` to require biometric/PIN user verification, default true.
+- `ELDLOCK_FIDO2_UP=true` to require touch/user presence, default true.
+- `ELDLOCK_FIDO2_PIN` if your authenticator requires PIN auth.
+- `ELDLOCK_FIDO2_RK=true` to request a resident credential, default false.
+- `ELDLOCK_FIDO2_CRED_PROTECT=true` to request UV-required credential protection, default false.
+
+The fallback command provider remains available with `ELDLOCK_PASSKEY_COMMAND`; it should print key material as `hex:<value>`, `base64:<value>`, or `raw:<value>`.

package/eldlock-server/internal/yubikey/default_fido2.go

@@ -0,0 +1,7 @@
+//go:build fido2
+
+package yubikey
+
+func defaultPasskeyProvider() string {
+	return "fido"
+}

package/eldlock-server/internal/yubikey/default_stub.go

@@ -0,0 +1,7 @@
+//go:build !fido2
+
+package yubikey
+
+func defaultPasskeyProvider() string {
+	return "stub"
+}

package/eldlock-server/internal/yubikey/fido2_disabled.go

@@ -0,0 +1,9 @@
+//go:build !fido2
+
+package yubikey
+
+import "errors"
+
+func newFIDO2ProviderFromEnv() (Provider, error) {
+	return nil, errors.New("FIDO2 provider requires building with GOFLAGS=-tags=fido2 and local libfido2 development libraries")
+}

package/eldlock-server/internal/yubikey/fido2_libfido2.go

@@ -0,0 +1,225 @@
+//go:build fido2
+
+package yubikey
+
+import (
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+
+	libfido2 "github.com/keys-pub/go-libfido2"
+)
+
+const (
+	libfido2ErrUVBlocked = 0x3c
+	libfido2ErrUVInvalid = 0x3f
+)
+
+type FIDO2Provider struct {
+	RPID       string
+	UserName   string
+	DevicePath string
+	PIN        string
+	RequireUV  bool
+	RequireUP  bool
+}
+
+func (p FIDO2Provider) Name() string {
+	return "fido2-hmac-secret"
+}
+
+func (p FIDO2Provider) WithPIN(pin string) Provider {
+	p.PIN = pin
+	return p
+}
+
+func newFIDO2ProviderFromEnv() (Provider, error) {
+	return FIDO2Provider{
+		RPID:       envDefault("ELDLOCK_FIDO2_RP_ID", "eldlock.local"),
+		UserName:   envDefault("ELDLOCK_FIDO2_USER", "eldlock"),
+		DevicePath: os.Getenv("ELDLOCK_FIDO2_DEVICE"),
+		PIN:        os.Getenv("ELDLOCK_FIDO2_PIN"),
+		RequireUV:  envBool("ELDLOCK_FIDO2_UV", true),
+		RequireUP:  envBool("ELDLOCK_FIDO2_UP", true),
+	}, nil
+}
+
+func (p FIDO2Provider) CreateKeyMaterial(operation string, salt []byte) ([]byte, map[string]string, error) {
+	device, path, err := p.openDevice()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	clientDataHash := clientHash(operation, salt)
+	userID, err := randomBytes(32)
+	if err != nil {
+		return nil, nil, fmt.Errorf("generate FIDO2 user ID: %w", err)
+	}
+
+	opts := &libfido2.MakeCredentialOpts{
+		Extensions: []libfido2.Extension{libfido2.HMACSecretExtension},
+	}
+	if envBool("ELDLOCK_FIDO2_RK", false) {
+		opts.RK = libfido2.True
+	}
+	if p.RequireUV {
+		opts.UV = libfido2.True
+	}
+	if envBool("ELDLOCK_FIDO2_CRED_PROTECT", false) {
+		opts.CredProtect = libfido2.CredProtectUVRequired
+	}
+
+	attest, err := device.MakeCredential(
+		clientDataHash,
+		libfido2.RelyingParty{ID: p.RPID, Name: "Eldlock"},
+		libfido2.User{ID: userID, Name: p.UserName},
+		libfido2.ES256,
+		p.PIN,
+		opts,
+	)
+	if err != nil {
+		return nil, nil, fmt.Errorf("create FIDO2 hmac-secret credential: %w", mapFIDO2PINError(err))
+	}
+
+	metadata := map[string]string{
+		"provider":      "fido2-hmac-secret",
+		"rp_id":         p.RPID,
+		"credential_id": base64.RawStdEncoding.EncodeToString(attest.CredentialID),
+		"user_id":       base64.RawStdEncoding.EncodeToString(userID),
+		"device_path":   path,
+		"uv":            boolString(p.RequireUV),
+		"up":            boolString(p.RequireUP),
+	}
+
+	material, err := p.OpenKeyMaterial(operation, salt, metadata)
+	if err != nil {
+		return nil, nil, fmt.Errorf("verify new FIDO2 hmac-secret credential: %w", err)
+	}
+	return material, metadata, nil
+}
+
+func (p FIDO2Provider) OpenKeyMaterial(operation string, salt []byte, metadata map[string]string) ([]byte, error) {
+	if metadata["provider"] != "fido2-hmac-secret" {
+		return nil, fmt.Errorf("vault was created with passkey provider %q, not fido2-hmac-secret", metadata["provider"])
+	}
+	credentialID, err := base64.RawStdEncoding.DecodeString(metadata["credential_id"])
+	if err != nil {
+		return nil, fmt.Errorf("decode FIDO2 credential ID: %w", err)
+	}
+
+	rpID := metadata["rp_id"]
+	if rpID == "" {
+		rpID = p.RPID
+	}
+	device, _, err := p.openDevice()
+	if err != nil {
+		return nil, err
+	}
+
+	opts := &libfido2.AssertionOpts{
+		Extensions: []libfido2.Extension{libfido2.HMACSecretExtension},
+		HMACSalt:   salt,
+	}
+	if metadata["uv"] == "true" || p.RequireUV {
+		opts.UV = libfido2.True
+	}
+	if metadata["up"] == "true" || p.RequireUP {
+		opts.UP = libfido2.True
+	}
+
+	assertion, err := device.Assertion(
+		rpID,
+		clientHash(operation, salt),
+		[][]byte{credentialID},
+		p.PIN,
+		opts,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("assert FIDO2 hmac-secret credential: %w", mapFIDO2PINError(err))
+	}
+	if len(assertion.HMACSecret) < 32 {
+		return nil, errors.New("FIDO2 hmac-secret returned insufficient key material")
+	}
+	return assertion.HMACSecret, nil
+}
+
+func mapFIDO2PINError(err error) error {
+	switch {
+	case errors.Is(err, libfido2.ErrPinRequired), errors.Is(err, libfido2.ErrPinNotSet):
+		return ErrPINRequired
+	case errors.Is(err, libfido2.ErrPinInvalid):
+		return ErrPINInvalid
+	case errors.Is(err, libfido2.ErrPinAuthBlocked):
+		return ErrPINAuthBlocked
+	case isLibfido2ErrorCode(err, libfido2ErrUVBlocked), isLibfido2ErrorCode(err, libfido2ErrUVInvalid):
+		return ErrPINRequired
+	default:
+		return err
+	}
+}
+
+func isLibfido2ErrorCode(err error, code int) bool {
+	var fidoErr libfido2.Error
+	return errors.As(err, &fidoErr) && fidoErr.Code == code
+}
+
+func (p FIDO2Provider) openDevice() (*libfido2.Device, string, error) {
+	path := p.DevicePath
+	if path == "" {
+		locs, err := libfido2.DeviceLocations()
+		if err != nil {
+			return nil, "", fmt.Errorf("list FIDO2 devices: %w", err)
+		}
+		if len(locs) == 0 {
+			return nil, "", errors.New("no FIDO2 devices found")
+		}
+		path = locs[0].Path
+	}
+	device, err := libfido2.NewDevice(path)
+	if err != nil {
+		return nil, "", fmt.Errorf("open FIDO2 device %s: %w", path, err)
+	}
+	return device, path, nil
+}
+
+func clientHash(operation string, salt []byte) []byte {
+	sum := sha256.Sum256([]byte("eldlock:vault:" + operation + ":" + hex.EncodeToString(salt)))
+	return sum[:]
+}
+
+func randomBytes(size int) ([]byte, error) {
+	buf := make([]byte, size)
+	if _, err := rand.Read(buf); err != nil {
+		return nil, err
+	}
+	return buf, nil
+}
+
+func envDefault(key, fallback string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return fallback
+}
+
+func envBool(key string, fallback bool) bool {
+	switch os.Getenv(key) {
+	case "1", "true", "yes", "on":
+		return true
+	case "0", "false", "no", "off":
+		return false
+	default:
+		return fallback
+	}
+}
+
+func boolString(value bool) string {
+	if value {
+		return "true"
+	}
+	return "false"
+}

package/eldlock-server/internal/yubikey/fido2_libfido2_test.go

@@ -0,0 +1,66 @@
+//go:build fido2
+
+package yubikey
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	libfido2 "github.com/keys-pub/go-libfido2"
+)
+
+func TestMapFIDO2PINErrorMapsPINAndBioFallbackErrors(t *testing.T) {
+	tests := []struct {
+		name string
+		err  error
+		want error
+	}{
+		{
+			name: "pin required",
+			err:  libfido2.ErrPinRequired,
+			want: ErrPINRequired,
+		},
+		{
+			name: "pin not set",
+			err:  libfido2.ErrPinNotSet,
+			want: ErrPINRequired,
+		},
+		{
+			name: "uv blocked",
+			err:  fmt.Errorf("wrapped: %w", libfido2.Error{Code: libfido2ErrUVBlocked}),
+			want: ErrPINRequired,
+		},
+		{
+			name: "uv invalid",
+			err:  fmt.Errorf("wrapped: %w", libfido2.Error{Code: libfido2ErrUVInvalid}),
+			want: ErrPINRequired,
+		},
+		{
+			name: "pin invalid",
+			err:  libfido2.ErrPinInvalid,
+			want: ErrPINInvalid,
+		},
+		{
+			name: "pin auth blocked",
+			err:  libfido2.ErrPinAuthBlocked,
+			want: ErrPINAuthBlocked,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := mapFIDO2PINError(tt.err)
+			if !errors.Is(got, tt.want) {
+				t.Fatalf("mapFIDO2PINError() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestMapFIDO2PINErrorLeavesUnrelatedErrorsAlone(t *testing.T) {
+	err := libfido2.ErrNotAllowed
+	if got := mapFIDO2PINError(err); !errors.Is(got, err) {
+		t.Fatalf("mapFIDO2PINError() = %v, want %v", got, err)
+	}
+}

package/eldlock-server/internal/yubikey/passkey.go

@@ -0,0 +1,139 @@
+package yubikey
+
+import (
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+var (
+	ErrPINRequired    = errors.New("pin required")
+	ErrPINInvalid     = errors.New("pin invalid")
+	ErrPINAuthBlocked = errors.New("pin auth blocked")
+)
+
+type Provider interface {
+	CreateKeyMaterial(operation string, salt []byte) ([]byte, map[string]string, error)
+	OpenKeyMaterial(operation string, salt []byte, metadata map[string]string) ([]byte, error)
+	Name() string
+}
+
+type PINProvider interface {
+	WithPIN(pin string) Provider
+}
+
+type StubProvider struct {
+	Secret string
+}
+
+func (p StubProvider) Name() string {
+	return "stub"
+}
+
+func (p StubProvider) CreateKeyMaterial(operation string, salt []byte) ([]byte, map[string]string, error) {
+	material, err := p.OpenKeyMaterial(operation, salt, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	return material, map[string]string{"provider": "stub"}, nil
+}
+
+func (p StubProvider) OpenKeyMaterial(_ string, _ []byte, _ map[string]string) ([]byte, error) {
+	secret := p.Secret
+	if secret == "" {
+		secret = os.Getenv("ELDLOCK_STUB_PASSKEY")
+	}
+	if secret == "" {
+		return nil, errors.New("ELDLOCK_STUB_PASSKEY is required for the stub passkey provider")
+	}
+	sum := sha256.Sum256([]byte(secret))
+	return sum[:], nil
+}
+
+type CommandProvider struct {
+	Command string
+}
+
+func (p CommandProvider) Name() string {
+	return "command"
+}
+
+func (p CommandProvider) CreateKeyMaterial(operation string, salt []byte) ([]byte, map[string]string, error) {
+	material, err := p.OpenKeyMaterial(operation, salt, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	return material, map[string]string{"provider": "command"}, nil
+}
+
+func (p CommandProvider) OpenKeyMaterial(operation string, salt []byte, metadata map[string]string) ([]byte, error) {
+	if strings.TrimSpace(p.Command) == "" {
+		return nil, errors.New("passkey command is empty")
+	}
+	cmd := exec.Command("/bin/sh", "-c", p.Command)
+	cmd.Env = append(os.Environ(),
+		"ELDLOCK_PASSKEY_OPERATION="+operation,
+		"ELDLOCK_PASSKEY_SALT_HEX="+hex.EncodeToString(salt),
+		"ELDLOCK_PASSKEY_METADATA="+encodeMetadata(metadata),
+	)
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("run passkey command: %w", err)
+	}
+
+	return parseCommandOutput(strings.TrimSpace(string(out)))
+}
+
+func NewProviderFromEnv() (Provider, error) {
+	if command := os.Getenv("ELDLOCK_PASSKEY_COMMAND"); command != "" {
+		return CommandProvider{Command: command}, nil
+	}
+
+	provider := os.Getenv("ELDLOCK_PASSKEY_PROVIDER")
+	if provider == "" {
+		provider = defaultPasskeyProvider()
+	}
+
+	switch provider {
+	case "stub":
+		return StubProvider{}, nil
+	case "command":
+		return nil, errors.New("ELDLOCK_PASSKEY_COMMAND is required when ELDLOCK_PASSKEY_PROVIDER=command")
+	case "fido":
+		return newFIDO2ProviderFromEnv()
+	default:
+		return nil, fmt.Errorf("unknown ELDLOCK_PASSKEY_PROVIDER %q", os.Getenv("ELDLOCK_PASSKEY_PROVIDER"))
+	}
+}
+
+func parseCommandOutput(value string) ([]byte, error) {
+	if value == "" {
+		return nil, errors.New("passkey command produced no key material")
+	}
+	if strings.HasPrefix(value, "hex:") {
+		return hex.DecodeString(strings.TrimPrefix(value, "hex:"))
+	}
+	if strings.HasPrefix(value, "base64:") {
+		return base64.StdEncoding.DecodeString(strings.TrimPrefix(value, "base64:"))
+	}
+	if strings.HasPrefix(value, "raw:") {
+		return []byte(strings.TrimPrefix(value, "raw:")), nil
+	}
+	return []byte(value), nil
+}
+
+func encodeMetadata(metadata map[string]string) string {
+	if len(metadata) == 0 {
+		return ""
+	}
+	var pairs []string
+	for key, value := range metadata {
+		pairs = append(pairs, key+"="+value)
+	}
+	return strings.Join(pairs, "\n")
+}

package/eldlock-server/internal/yubikey/passkey_test.go

@@ -0,0 +1,36 @@
+package yubikey
+
+import "testing"
+
+func TestStubProviderReturnsStableHighEntropyMaterial(t *testing.T) {
+	provider := StubProvider{Secret: "test stub passkey secret with enough entropy"}
+
+	first, metadata, err := provider.CreateKeyMaterial("init", []byte("salt"))
+	if err != nil {
+		t.Fatalf("CreateKeyMaterial() error = %v", err)
+	}
+	if metadata["provider"] != "stub" {
+		t.Fatalf("metadata provider = %q, want stub", metadata["provider"])
+	}
+	second, err := provider.OpenKeyMaterial("put", []byte("salt"), metadata)
+	if err != nil {
+		t.Fatalf("OpenKeyMaterial() error = %v", err)
+	}
+
+	if len(first) != 32 {
+		t.Fatalf("len(KeyMaterial()) = %d, want 32", len(first))
+	}
+	if string(first) != string(second) {
+		t.Fatalf("stub material changed across operations")
+	}
+}
+
+func TestParseCommandOutput(t *testing.T) {
+	got, err := parseCommandOutput("hex:414243")
+	if err != nil {
+		t.Fatalf("parseCommandOutput() error = %v", err)
+	}
+	if string(got) != "ABC" {
+		t.Fatalf("parseCommandOutput() = %q, want ABC", got)
+	}
+}

package/eldlock-server/vendor/github.com/keys-pub/go-libfido2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+​
+Copyright (c) 2019 Gabriel Handford
+​
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+​
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+​
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.