soft-serve - middleware

  1package ssh
  2
  3import (
  4	"context"
  5	"net"
  6	"testing"
  7
  8	"github.com/charmbracelet/keygen"
  9	"github.com/charmbracelet/soft-serve/pkg/backend"
 10	"github.com/charmbracelet/soft-serve/pkg/config"
 11	"github.com/charmbracelet/soft-serve/pkg/db"
 12	"github.com/charmbracelet/soft-serve/pkg/db/migrate"
 13	"github.com/charmbracelet/soft-serve/pkg/proto"
 14	"github.com/charmbracelet/soft-serve/pkg/store"
 15	"github.com/charmbracelet/soft-serve/pkg/store/database"
 16	"github.com/charmbracelet/ssh"
 17	"github.com/matryer/is"
 18	gossh "golang.org/x/crypto/ssh"
 19	_ "modernc.org/sqlite"
 20)
 21
 22// TestAuthenticationBypass tests for CVE-TBD: Authentication Bypass Vulnerability
 23//
 24// VULNERABILITY:
 25// A critical authentication bypass allows an attacker to impersonate any user
 26// (including Admin) by "offering" the victim's public key during the SSH handshake
 27// before authenticating with their own valid key. This occurs because the user
 28// identity is stored in the session context during the "offer" phase in
 29// PublicKeyHandler and is not properly cleared/validated in AuthenticationMiddleware.
 30//
 31// This test verifies that:
 32// 1. User context is properly set based on the AUTHENTICATED key, not offered keys
 33// 2. User context from failed authentication attempts is not preserved
 34// 3. Non-admin users cannot gain admin privileges through this attack
 35func TestAuthenticationBypass(t *testing.T) {
 36	is := is.New(t)
 37	ctx := context.Background()
 38
 39	// Setup temporary database
 40	dp := t.TempDir()
 41	cfg := config.DefaultConfig()
 42	cfg.DataPath = dp
 43	cfg.DB.Driver = "sqlite"
 44	cfg.DB.DataSource = dp + "/test.db"
 45
 46	ctx = config.WithContext(ctx, cfg)
 47	dbx, err := db.Open(ctx, cfg.DB.Driver, cfg.DB.DataSource)
 48	is.NoErr(err)
 49	defer dbx.Close()
 50
 51	is.NoErr(migrate.Migrate(ctx, dbx))
 52	dbstore := database.New(ctx, dbx)
 53	ctx = store.WithContext(ctx, dbstore)
 54	be := backend.New(ctx, cfg, dbx, dbstore)
 55	ctx = backend.WithContext(ctx, be)
 56
 57	// Generate keys for admin and attacker
 58	adminKeyPath := dp + "/admin_key"
 59	adminPair, err := keygen.New(adminKeyPath, keygen.WithKeyType(keygen.Ed25519), keygen.WithWrite())
 60	is.NoErr(err)
 61
 62	attackerKeyPath := dp + "/attacker_key"
 63	attackerPair, err := keygen.New(attackerKeyPath, keygen.WithKeyType(keygen.Ed25519), keygen.WithWrite())
 64	is.NoErr(err)
 65
 66	// Parse public keys
 67	adminPubKey, _, _, _, err := gossh.ParseAuthorizedKey([]byte(adminPair.AuthorizedKey()))
 68	is.NoErr(err)
 69
 70	attackerPubKey, _, _, _, err := gossh.ParseAuthorizedKey([]byte(attackerPair.AuthorizedKey()))
 71	is.NoErr(err)
 72
 73	// Create admin user
 74	adminUser, err := be.CreateUser(ctx, "testadmin", proto.UserOptions{
 75		Admin:      true,
 76		PublicKeys: []gossh.PublicKey{adminPubKey},
 77	})
 78	is.NoErr(err)
 79	is.True(adminUser != nil)
 80
 81	// Create attacker (non-admin) user
 82	attackerUser, err := be.CreateUser(ctx, "testattacker", proto.UserOptions{
 83		Admin:      false,
 84		PublicKeys: []gossh.PublicKey{attackerPubKey},
 85	})
 86	is.NoErr(err)
 87	is.True(attackerUser != nil)
 88	is.True(!attackerUser.IsAdmin()) // Verify attacker is NOT admin
 89
 90	// Test: Verify that looking up user by key gives correct user
 91	t.Run("user_lookup_by_key", func(t *testing.T) {
 92		is := is.New(t)
 93
 94		// Looking up admin key should return admin user
 95		user, err := be.UserByPublicKey(ctx, adminPubKey)
 96		is.NoErr(err)
 97		is.Equal(user.Username(), "testadmin")
 98		is.True(user.IsAdmin())
 99
100		// Looking up attacker key should return attacker user
101		user, err = be.UserByPublicKey(ctx, attackerPubKey)
102		is.NoErr(err)
103		is.Equal(user.Username(), "testattacker")
104		is.True(!user.IsAdmin())
105	})
106
107	// Test: Simulate the authentication bypass vulnerability
108	// This test documents the EXPECTED behavior to prevent regression
109	t.Run("authentication_bypass_simulation", func(t *testing.T) {
110		is := is.New(t)
111
112		// Create a mock context
113		mockCtx := &mockSSHContext{
114			Context:     ctx,
115			values:      make(map[any]any),
116			permissions: &ssh.Permissions{Permissions: &gossh.Permissions{Extensions: make(map[string]string)}},
117		}
118
119		// ATTACK SIMULATION:
120		// Step 1: SSH client offers admin's public key
121		// PublicKeyHandler is called and sets admin user in context
122		mockCtx.SetValue(proto.ContextKeyUser, adminUser)
123		mockCtx.permissions.Extensions["pubkey-fp"] = gossh.FingerprintSHA256(adminPubKey)
124
125		// Step 2: Signature verification FAILS (attacker doesn't have admin's private key)
126		// SSH protocol continues to next key...
127
128		// Step 3: SSH client offers attacker's key (which SUCCEEDS)
129		// PublicKeyHandler is called again, fingerprint is updated
130		mockCtx.permissions.Extensions["pubkey-fp"] = gossh.FingerprintSHA256(attackerPubKey)
131		// BUG: Admin user is STILL in context from step 1!
132
133		// Step 4: AuthenticationMiddleware should re-lookup user based on authenticated key
134		// The middleware MUST NOT trust the user already in context
135		authenticatedUser, err := be.UserByPublicKey(mockCtx, attackerPubKey)
136		is.NoErr(err)
137
138		// EXPECTED: User should be "attacker", NOT "admin"
139		is.Equal(authenticatedUser.Username(), "testattacker")
140		is.True(!authenticatedUser.IsAdmin())
141
142		// If the vulnerability exists, the context would still have admin user
143		contextUser := proto.UserFromContext(mockCtx)
144		if contextUser != nil && contextUser.Username() == "testadmin" {
145			t.Logf("WARNING: Context still contains admin user! This indicates the vulnerability exists.")
146			t.Logf("The authenticated key is attacker's, but context has admin user.")
147		}
148	})
149}
150
151// mockSSHContext implements ssh.Context for testing
152type mockSSHContext struct {
153	context.Context
154	values      map[any]any
155	permissions *ssh.Permissions
156}
157
158func (m *mockSSHContext) SetValue(key, value any) {
159	m.values[key] = value
160}
161
162func (m *mockSSHContext) Value(key any) any {
163	if v, ok := m.values[key]; ok {
164		return v
165	}
166	return m.Context.Value(key)
167}
168
169func (m *mockSSHContext) Permissions() *ssh.Permissions {
170	return m.permissions
171}
172
173func (m *mockSSHContext) User() string          { return "" }
174func (m *mockSSHContext) RemoteAddr() net.Addr  { return &net.TCPAddr{} }
175func (m *mockSSHContext) LocalAddr() net.Addr   { return &net.TCPAddr{} }
176func (m *mockSSHContext) ServerVersion() string { return "" }
177func (m *mockSSHContext) ClientVersion() string { return "" }
178func (m *mockSSHContext) SessionID() string     { return "" }
179func (m *mockSSHContext) Lock()                 {}
180func (m *mockSSHContext) Unlock()               {}