Skip to content

Agent Mesh

allow to request offline token

Antonio Ojea39138ba0a64e
diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.go
index 9c6f283d..315d57c8 100644
--- a/cmd/sam-node/main.go
+++ b/cmd/sam-node/main.go
@@ -74,6 +74,7 @@ var (
dataDirFlag string
allowLoopbackFlag bool
headlessFlag bool
+ offlineAccessFlag bool
autoRelayMinIntervalFlag time.Duration
autoRelayBootDelayFlag time.Duration
autoRelayBackoffFlag time.Duration
@@ -400,7 +401,7 @@ func main() {
logger.Fatalf("Failed to discover OIDC endpoints: %v", err)
}
- jwtStr, err := dummyNode.InteractiveLogin(ctx, authURL, tokenURL, hubInfo.ClientId, hubInfo.Audience)
+ jwtStr, err := dummyNode.InteractiveLogin(ctx, authURL, tokenURL, hubInfo.ClientId, hubInfo.Audience, offlineAccessFlag)
if err != nil {
logger.Fatalf("Failed to get token: %v", err)
}
@@ -465,6 +466,9 @@ func main() {
if err := store.SaveHubURL(targetHub); err != nil {
logger.Warnf("Failed to save hub URL: %v", err)
}
+ if err := store.SaveOIDCConfig(hubInfo.OidcIssuer, hubInfo.ClientId, hubInfo.Audience); err != nil {
+ logger.Warnf("Failed to save OIDC config: %v", err)
+ }
fmt.Println("Successfully joined the Sovereign Agent Mesh!")
},
@@ -490,6 +494,7 @@ func main() {
runCmd.Flags().DurationVar(&keyGracePeriodFlag, "key-grace-period", 24*time.Hour, "Key grace period for old keys (e.g. 24h)")
runCmd.Flags().BoolVar(&allowLoopbackFlag, "allow-loopback", false, "Allow publishing and connecting to loopback/link-local addresses")
joinCmd.Flags().BoolVar(&allowLoopbackFlag, "allow-loopback", false, "Allow publishing and connecting to loopback/link-local addresses")
+ joinCmd.Flags().BoolVar(&offlineAccessFlag, "offline-access", false, "Request OIDC offline access/refresh token for automatic renewal")
runCmd.Flags().StringVar(&apiTokenFlag, "api-token", "", "Static Bearer token for API authorization")
runCmd.Flags().StringVar(&tlsCertFlag, "tls-cert", "", "Path to TLS certificate for sidecar API")
runCmd.Flags().StringVar(&tlsKeyFlag, "tls-key", "", "Path to TLS key for sidecar API")
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.go
index b976a61d..9427210c 100644
--- a/cmd/sam-node/node.go
+++ b/cmd/sam-node/node.go
@@ -710,7 +710,7 @@ func (n *SamNode) StartRenewalLoop(ctx context.Context, issuerURL, clientID, cli
newJWT = strings.TrimSpace(string(data))
}
} else {
- fetchErr = fmt.Errorf("no credentials available for renewal")
+ newJWT, fetchErr = n.renewWithRefreshToken(ctx, clientSecret)
}
if fetchErr == nil {
@@ -735,6 +735,43 @@ func (n *SamNode) StartRenewalLoop(ctx context.Context, issuerURL, clientID, cli
}()
}
+func (n *SamNode) renewWithRefreshToken(ctx context.Context, clientSecret string) (string, error) {
+ if n.Store == nil {
+ return "", fmt.Errorf("store is not initialized")
+ }
+
+ refreshToken, err := n.Store.LoadRefreshToken()
+ if err != nil {
+ return "", fmt.Errorf("no refresh token available for renewal: %w", err)
+ }
+
+ storedIssuer, storedClientID, _, err := n.Store.LoadOIDCConfig()
+ if err != nil {
+ return "", fmt.Errorf("failed to load OIDC configuration: %w", err)
+ }
+ if storedIssuer == "" || storedClientID == "" {
+ return "", fmt.Errorf("OIDC configuration is incomplete (issuer or client ID is empty)")
+ }
+
+ tokenURL, err := n.DiscoverTokenURL(ctx, storedIssuer)
+ if err != nil {
+ return "", fmt.Errorf("failed to discover OIDC endpoints for renewal: %w", err)
+ }
+
+ newJWT, newRefreshToken, err := n.RefreshJWT(ctx, tokenURL, storedClientID, clientSecret, refreshToken)
+ if err != nil {
+ return "", fmt.Errorf("failed to refresh JWT: %w", err)
+ }
+
+ if newRefreshToken != "" {
+ if err := n.Store.SaveRefreshToken(newRefreshToken); err != nil {
+ logger.Warnf("Failed to save updated refresh token: %v", err)
+ }
+ }
+
+ return newJWT, nil
+}
+
// listenForHubEvents listens to the topic established by the Hub
func (n *SamNode) listenForHubEvents(ctx context.Context) {
topic, err := n.PubSub.Join(api.GossipEvents)
diff --git a/cmd/sam-node/oidc.go b/cmd/sam-node/oidc.go
index a65eec71..ef6c7b10 100644
--- a/cmd/sam-node/oidc.go
+++ b/cmd/sam-node/oidc.go
@@ -61,7 +61,7 @@ func (n *SamNode) FetchJWT(ctx context.Context, tokenURL, clientID, clientSecret
}
// InteractiveLogin prompts the user to go to a URL and enter a code.
-func (n *SamNode) InteractiveLogin(ctx context.Context, authURL, tokenURL, clientID, audience string) (string, error) {
+func (n *SamNode) InteractiveLogin(ctx context.Context, authURL, tokenURL, clientID, audience string, requestRefresh bool) (string, error) {
if authURL == "" {
return "", fmt.Errorf("authorization URL is required")
}
@@ -110,7 +110,13 @@ func (n *SamNode) InteractiveLogin(ctx context.Context, authURL, tokenURL, clien
q.Add("response_type", "code")
q.Add("client_id", clientID)
q.Add("redirect_uri", redirectURI)
- q.Add("scope", "openid email profile")
+ scope := "openid email profile"
+ if requestRefresh {
+ scope += " offline_access"
+ q.Add("access_type", "offline")
+ q.Add("prompt", "consent")
+ }
+ q.Add("scope", scope)
q.Add("state", state)
q.Add("code_challenge", challenge)
q.Add("code_challenge_method", "S256")
@@ -264,13 +270,20 @@ func (n *SamNode) InteractiveLogin(ctx context.Context, authURL, tokenURL, clien
}
var tokenResp struct {
- AccessToken string `json:"access_token"`
- IdToken string `json:"id_token"`
+ AccessToken string `json:"access_token"`
+ IdToken string `json:"id_token"`
+ RefreshToken string `json:"refresh_token"`
}
if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
return "", err
}
+ if tokenResp.RefreshToken != "" && n.Store != nil {
+ if err := n.Store.SaveRefreshToken(tokenResp.RefreshToken); err != nil {
+ logger.Warnf("Failed to save refresh token: %v", err)
+ }
+ }
+
if tokenResp.IdToken != "" {
return tokenResp.IdToken, nil
}
@@ -334,3 +347,55 @@ func openBrowser(targetURL string) {
logger.Debugf("Failed to open browser: %v", cmdErr)
}
}
+
+// RefreshJWT refreshes the OIDC token using the stored refresh token.
+func (n *SamNode) RefreshJWT(ctx context.Context, tokenURL, clientID, clientSecret, refreshToken string) (string, string, error) {
+ tokenData := url.Values{}
+ tokenData.Set("grant_type", "refresh_token")
+ tokenData.Set("client_id", clientID)
+ tokenData.Set("refresh_token", refreshToken)
+ if clientSecret != "" {
+ tokenData.Set("client_secret", clientSecret)
+ }
+
+ req, err := http.NewRequestWithContext(ctx, "POST", tokenURL, strings.NewReader(tokenData.Encode()))
+ if err != nil {
+ return "", "", err
+ }
+ req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+ client := &http.Client{Timeout: 10 * time.Second}
+ resp, err := client.Do(req)
+ if err != nil {
+ return "", "", err
+ }
+ defer func() {
+ if err := resp.Body.Close(); err != nil {
+ logger.Errorf("Failed to close response body: %v", err)
+ }
+ }()
+
+ if resp.StatusCode != http.StatusOK {
+ var errResp struct {
+ Error string `json:"error"`
+ ErrorDescription string `json:"error_description"`
+ }
+ _ = json.NewDecoder(resp.Body).Decode(&errResp)
+ return "", "", fmt.Errorf("refresh token request failed: %s - %s", errResp.Error, errResp.ErrorDescription)
+ }
+
+ var tokenResp struct {
+ AccessToken string `json:"access_token"`
+ IdToken string `json:"id_token"`
+ RefreshToken string `json:"refresh_token"`
+ }
+ if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
+ return "", "", err
+ }
+
+ jwtStr := tokenResp.AccessToken
+ if tokenResp.IdToken != "" {
+ jwtStr = tokenResp.IdToken
+ }
+ return jwtStr, tokenResp.RefreshToken, nil
+}
diff --git a/cmd/sam-node/oidc_test.go b/cmd/sam-node/oidc_test.go
index 857568f6..af0e9a1e 100644
--- a/cmd/sam-node/oidc_test.go
+++ b/cmd/sam-node/oidc_test.go
@@ -6,6 +6,7 @@ import (
"net/http"
"net/http/httptest"
"net/url"
+ "strings"
"testing"
"time"
)
@@ -66,7 +67,7 @@ func TestInteractiveLogin(t *testing.T) {
}
defer func() { openBrowserFunc = originalOpenBrowser }()
- token, err := node.InteractiveLogin(ctx, "http://auth.example.com/auth", server.URL+"/token", "client_id_test", "sam-e2e")
+ token, err := node.InteractiveLogin(ctx, "http://auth.example.com/auth", server.URL+"/token", "client_id_test", "sam-e2e", false)
if err != nil {
t.Fatalf("InteractiveLogin failed: %v", err)
}
@@ -107,3 +108,167 @@ func TestDiscoverEndpoints(t *testing.T) {
t.Errorf("Expected authURL %s, got %s", server.URL+"/auth", authURL)
}
}
+
+func TestInteractiveLoginWithRefresh(t *testing.T) {
+ t.Setenv("SSH_CLIENT", "")
+ t.Setenv("SSH_TTY", "")
+
+ mux := http.NewServeMux()
+ mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
+ if r.Method != "POST" {
+ http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+ return
+ }
+ _ = r.ParseForm()
+ if r.FormValue("grant_type") != "authorization_code" {
+ http.Error(w, "Invalid grant_type", http.StatusBadRequest)
+ return
+ }
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(map[string]string{
+ "access_token": "access_token_xyz",
+ "id_token": "id_token_abc",
+ "refresh_token": "refresh_token_123",
+ })
+ })
+
+ server := httptest.NewServer(mux)
+ defer server.Close()
+
+ // Initialize Store
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+ defer func() {
+ if err := store.Close(); err != nil {
+ t.Errorf("failed to close store: %v", err)
+ }
+ }()
+
+ node := &SamNode{Store: store}
+
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ defer cancel()
+
+ originalOpenBrowser := openBrowserFunc
+ openBrowserFunc = func(urlStr string) {
+ u, _ := url.Parse(urlStr)
+ redirectURI := u.Query().Get("redirect_uri")
+ state := u.Query().Get("state")
+
+ // Verify offline_access scope and prompt are present
+ scope := u.Query().Get("scope")
+ if !strings.Contains(scope, "offline_access") {
+ t.Errorf("Expected scope to contain 'offline_access', got %q", scope)
+ }
+ if u.Query().Get("access_type") != "offline" {
+ t.Errorf("Expected access_type to be 'offline', got %q", u.Query().Get("access_type"))
+ }
+
+ go func() {
+ time.Sleep(100 * time.Millisecond)
+ _, _ = http.Get(redirectURI + "?code=dev_code_123&state=" + state)
+ }()
+ }
+ defer func() { openBrowserFunc = originalOpenBrowser }()
+
+ token, err := node.InteractiveLogin(ctx, "http://auth.example.com/auth", server.URL+"/token", "client_id_test", "sam-e2e", true)
+ if err != nil {
+ t.Fatalf("InteractiveLogin failed: %v", err)
+ }
+
+ if token != "id_token_abc" {
+ t.Errorf("Expected token 'id_token_abc', got '%s'", token)
+ }
+
+ // Verify refresh token is saved in the database
+ savedRefresh, err := store.LoadRefreshToken()
+ if err != nil {
+ t.Fatalf("Failed to load refresh token from store: %v", err)
+ }
+ if savedRefresh != "refresh_token_123" {
+ t.Errorf("Expected saved refresh token 'refresh_token_123', got '%s'", savedRefresh)
+ }
+}
+
+func TestRenewWithRefreshToken(t *testing.T) {
+ mux := http.NewServeMux()
+ mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(map[string]interface{}{
+ "issuer": "http://" + r.Host,
+ "token_endpoint": "http://" + r.Host + "/token",
+ "authorization_endpoint": "http://" + r.Host + "/auth",
+ })
+ })
+ mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
+ if r.Method != "POST" {
+ http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+ return
+ }
+ _ = r.ParseForm()
+ if r.FormValue("grant_type") != "refresh_token" {
+ http.Error(w, "Invalid grant_type: "+r.FormValue("grant_type"), http.StatusBadRequest)
+ return
+ }
+ if r.FormValue("refresh_token") != "old_refresh_123" {
+ http.Error(w, "Invalid refresh token", http.StatusBadRequest)
+ return
+ }
+ if r.FormValue("client_id") != "client_id_test" {
+ http.Error(w, "Invalid client_id", http.StatusBadRequest)
+ return
+ }
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(map[string]string{
+ "access_token": "new_access_token_xyz",
+ "id_token": "new_id_token_abc",
+ "refresh_token": "new_refresh_token_456",
+ })
+ })
+
+ server := httptest.NewServer(mux)
+ defer server.Close()
+
+ // Initialize Store
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+ defer func() {
+ if err := store.Close(); err != nil {
+ t.Errorf("failed to close store: %v", err)
+ }
+ }()
+
+ // Store OIDC Config and old refresh token
+ if err := store.SaveOIDCConfig(server.URL, "client_id_test", "sam-e2e"); err != nil {
+ t.Fatalf("Failed to save OIDC Config: %v", err)
+ }
+ if err := store.SaveRefreshToken("old_refresh_123"); err != nil {
+ t.Fatalf("Failed to save Refresh Token: %v", err)
+ }
+
+ node := &SamNode{Store: store}
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ defer cancel()
+
+ newJWT, err := node.renewWithRefreshToken(ctx, "")
+ if err != nil {
+ t.Fatalf("renewWithRefreshToken failed: %v", err)
+ }
+
+ if newJWT != "new_id_token_abc" {
+ t.Errorf("Expected new JWT 'new_id_token_abc', got '%s'", newJWT)
+ }
+
+ // Verify that the new refresh token is saved
+ newRefresh, err := store.LoadRefreshToken()
+ if err != nil {
+ t.Fatalf("Failed to load new refresh token from store: %v", err)
+ }
+ if newRefresh != "new_refresh_token_456" {
+ t.Errorf("Expected updated refresh token 'new_refresh_token_456', got '%s'", newRefresh)
+ }
+}
diff --git a/cmd/sam-node/store.go b/cmd/sam-node/store.go
index e5b1de41..41a7338e 100644
--- a/cmd/sam-node/store.go
+++ b/cmd/sam-node/store.go
@@ -28,10 +28,14 @@ import (
)
const (
- bucketIdentity = "identity"
- keyBiscuit = "identity_biscuit"
- keyPrivKey = "node_private_key"
- keyIdentityExp = "identity_expiration"
+ bucketIdentity = "identity"
+ keyBiscuit = "identity_biscuit"
+ keyPrivKey = "node_private_key"
+ keyIdentityExp = "identity_expiration"
+ keyRefreshToken = "refresh_token"
+ keyOidcIssuer = "oidc_issuer"
+ keyOidcClientID = "oidc_client_id"
+ keyOidcAudience = "oidc_audience"
)
type Store struct {
@@ -118,6 +122,51 @@ func (s *Store) LoadIdentityExpiration() (int64, error) {
return exp, nil
}
+func (s *Store) SaveRefreshToken(token string) error {
+ return s.db.Update(func(tx *bbolt.Tx) error {
+ b := tx.Bucket([]byte(bucketIdentity))
+ return b.Put([]byte(keyRefreshToken), []byte(token))
+ })
+}
+
+func (s *Store) LoadRefreshToken() (string, error) {
+ var val []byte
+ _ = s.db.View(func(tx *bbolt.Tx) error {
+ b := tx.Bucket([]byte(bucketIdentity))
+ val = b.Get([]byte(keyRefreshToken))
+ return nil
+ })
+ if len(val) == 0 {
+ return "", fmt.Errorf("no refresh token found")
+ }
+ return string(val), nil
+}
+
+func (s *Store) SaveOIDCConfig(issuer, clientID, audience string) error {
+ return s.db.Update(func(tx *bbolt.Tx) error {
+ b := tx.Bucket([]byte(bucketIdentity))
+ if err := b.Put([]byte(keyOidcIssuer), []byte(issuer)); err != nil {
+ return err
+ }
+ if err := b.Put([]byte(keyOidcClientID), []byte(clientID)); err != nil {
+ return err
+ }
+ return b.Put([]byte(keyOidcAudience), []byte(audience))
+ })
+}
+
+func (s *Store) LoadOIDCConfig() (string, string, string, error) {
+ var issuer, clientID, audience []byte
+ err := s.db.View(func(tx *bbolt.Tx) error {
+ b := tx.Bucket([]byte(bucketIdentity))
+ issuer = b.Get([]byte(keyOidcIssuer))
+ clientID = b.Get([]byte(keyOidcClientID))
+ audience = b.Get([]byte(keyOidcAudience))
+ return nil
+ })
+ return string(issuer), string(clientID), string(audience), err
+}
+
func (s *Store) SaveKey(key []byte) error {
return s.db.Update(func(tx *bbolt.Tx) error {
b := tx.Bucket([]byte(bucketIdentity))
diff --git a/cmd/sam-node/store_test.go b/cmd/sam-node/store_test.go
index ba3da2b5..16447c50 100644
--- a/cmd/sam-node/store_test.go
+++ b/cmd/sam-node/store_test.go
@@ -13,3 +13,326 @@
// limitations under the License.
package main
+
+import (
+ "bytes"
+ "fmt"
+ "os"
+ "path/filepath"
+ "reflect"
+ "testing"
+
+ "github.com/libp2p/go-libp2p/core/peer"
+ "go.etcd.io/bbolt"
+)
+
+func TestStore_NewStore_And_Close(t *testing.T) {
+ tempDir := t.TempDir()
+
+ store, err := NewStore(tempDir)
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+
+ dbPath := filepath.Join(tempDir, "agent.db")
+ if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+ t.Errorf("Database file does not exist at %s", dbPath)
+ }
+
+ if err := store.Close(); err != nil {
+ t.Errorf("Failed to close store: %v", err)
+ }
+}
+
+func TestStore_Identity(t *testing.T) {
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+ defer func() {
+ if err := store.Close(); err != nil {
+ t.Errorf("failed to close store: %v", err)
+ }
+ }()
+
+ // Loading identity when not set should fail
+ _, err = store.LoadIdentity()
+ if err == nil {
+ t.Error("Expected error loading identity when none is saved, got nil")
+ }
+
+ biscuit := []byte("dummy-biscuit-data")
+ if err := store.SaveIdentity(biscuit); err != nil {
+ t.Fatalf("SaveIdentity failed: %v", err)
+ }
+
+ loaded, err := store.LoadIdentity()
+ if err != nil {
+ t.Fatalf("LoadIdentity failed: %v", err)
+ }
+
+ if !bytes.Equal(loaded, biscuit) {
+ t.Errorf("Expected loaded identity %s, got %s", string(biscuit), string(loaded))
+ }
+}
+
+func TestStore_IdentityExpiration(t *testing.T) {
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+ defer func() {
+ if err := store.Close(); err != nil {
+ t.Errorf("failed to close store: %v", err)
+ }
+ }()
+
+ // Loading when not set should fail
+ _, err = store.LoadIdentityExpiration()
+ if err == nil {
+ t.Error("Expected error loading identity expiration when none is saved, got nil")
+ }
+
+ exp := int64(1782418067)
+ if err := store.SaveIdentityExpiration(exp); err != nil {
+ t.Fatalf("SaveIdentityExpiration failed: %v", err)
+ }
+
+ loadedExp, err := store.LoadIdentityExpiration()
+ if err != nil {
+ t.Fatalf("LoadIdentityExpiration failed: %v", err)
+ }
+
+ if loadedExp != exp {
+ t.Errorf("Expected loaded expiration %d, got %d", exp, loadedExp)
+ }
+}
+
+func TestStore_RefreshToken(t *testing.T) {
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+ defer func() {
+ if err := store.Close(); err != nil {
+ t.Errorf("failed to close store: %v", err)
+ }
+ }()
+
+ // Loading when not set should fail
+ _, err = store.LoadRefreshToken()
+ if err == nil {
+ t.Error("Expected error loading refresh token when none is saved, got nil")
+ }
+
+ token := "refresh-token-xyz"
+ if err := store.SaveRefreshToken(token); err != nil {
+ t.Fatalf("SaveRefreshToken failed: %v", err)
+ }
+
+ loaded, err := store.LoadRefreshToken()
+ if err != nil {
+ t.Fatalf("LoadRefreshToken failed: %v", err)
+ }
+
+ if loaded != token {
+ t.Errorf("Expected loaded refresh token %q, got %q", token, loaded)
+ }
+}
+
+func TestStore_OIDCConfig(t *testing.T) {
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+ defer func() {
+ if err := store.Close(); err != nil {
+ t.Errorf("failed to close store: %v", err)
+ }
+ }()
+
+ // Loading when not set returns empty strings
+ iss, cid, aud, err := store.LoadOIDCConfig()
+ if err != nil {
+ t.Fatalf("LoadOIDCConfig failed: %v", err)
+ }
+ if iss != "" || cid != "" || aud != "" {
+ t.Errorf("Expected empty OIDC config, got issuer=%q, clientID=%q, audience=%q", iss, cid, aud)
+ }
+
+ issuer := "https://auth.example.com"
+ clientID := "client-123"
+ audience := "sam-mesh"
+
+ if err := store.SaveOIDCConfig(issuer, clientID, audience); err != nil {
+ t.Fatalf("SaveOIDCConfig failed: %v", err)
+ }
+
+ loadedIss, loadedCID, loadedAud, err := store.LoadOIDCConfig()
+ if err != nil {
+ t.Fatalf("LoadOIDCConfig failed: %v", err)
+ }
+
+ if loadedIss != issuer || loadedCID != clientID || loadedAud != audience {
+ t.Errorf("Expected OIDC config (%q, %q, %q), got (%q, %q, %q)", issuer, clientID, audience, loadedIss, loadedCID, loadedAud)
+ }
+}
+
+func TestStore_Key(t *testing.T) {
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+ defer func() {
+ if err := store.Close(); err != nil {
+ t.Errorf("failed to close store: %v", err)
+ }
+ }()
+
+ // Loading when not set should return nil or empty
+ loaded, err := store.LoadKey()
+ if err != nil {
+ t.Fatalf("LoadKey failed: %v", err)
+ }
+ if len(loaded) > 0 {
+ t.Errorf("Expected empty key, got len %d", len(loaded))
+ }
+
+ key := []byte("private-key-bytes")
+ if err := store.SaveKey(key); err != nil {
+ t.Fatalf("SaveKey failed: %v", err)
+ }
+
+ loaded, err = store.LoadKey()
+ if err != nil {
+ t.Fatalf("LoadKey failed: %v", err)
+ }
+
+ if !bytes.Equal(loaded, key) {
+ t.Errorf("Expected loaded key %v, got %v", key, loaded)
+ }
+}
+
+func TestStore_HubConfig(t *testing.T) {
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+ defer func() {
+ if err := store.Close(); err != nil {
+ t.Errorf("failed to close store: %v", err)
+ }
+ }()
+
+ // Loading when not set
+ pubKey, addrs, err := store.LoadHubConfig()
+ if err != nil {
+ t.Fatalf("LoadHubConfig failed: %v", err)
+ }
+ if len(pubKey) > 0 || len(addrs) > 0 {
+ t.Errorf("Expected empty hub config, got pubKey=%v, addrs=%v", pubKey, addrs)
+ }
+
+ hubPubKey := []byte("hub-public-key-bytes")
+ hubAddrs := []string{"/ip4/127.0.0.1/tcp/5001", "/dns4/hub.example.com/tcp/5001"}
+
+ if err := store.SaveHubConfig(hubPubKey, hubAddrs); err != nil {
+ t.Fatalf("SaveHubConfig failed: %v", err)
+ }
+
+ loadedPubKey, loadedAddrs, err := store.LoadHubConfig()
+ if err != nil {
+ t.Fatalf("LoadHubConfig failed: %v", err)
+ }
+
+ if !bytes.Equal(loadedPubKey, hubPubKey) {
+ t.Errorf("Expected loaded hub pubkey %v, got %v", hubPubKey, loadedPubKey)
+ }
+ if !reflect.DeepEqual(loadedAddrs, hubAddrs) {
+ t.Errorf("Expected loaded hub addrs %v, got %v", hubAddrs, loadedAddrs)
+ }
+}
+
+func TestStore_HubURL(t *testing.T) {
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+ defer func() {
+ if err := store.Close(); err != nil {
+ t.Errorf("failed to close store: %v", err)
+ }
+ }()
+
+ // Loading when not set
+ url, err := store.LoadHubURL()
+ if err != nil {
+ t.Fatalf("LoadHubURL failed: %v", err)
+ }
+ if url != "" {
+ t.Errorf("Expected empty Hub URL, got %q", url)
+ }
+
+ hubURL := "https://hub.example.com"
+ if err := store.SaveHubURL(hubURL); err != nil {
+ t.Fatalf("SaveHubURL failed: %v", err)
+ }
+
+ loaded, err := store.LoadHubURL()
+ if err != nil {
+ t.Fatalf("LoadHubURL failed: %v", err)
+ }
+
+ if loaded != hubURL {
+ t.Errorf("Expected loaded hub URL %q, got %q", hubURL, loaded)
+ }
+}
+
+func TestStore_IsBanned(t *testing.T) {
+ store, err := NewStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("Failed to create store: %v", err)
+ }
+ defer func() {
+ if err := store.Close(); err != nil {
+ t.Errorf("failed to close store: %v", err)
+ }
+ }()
+
+ pID, err := peer.Decode("12D3KooWBysiyDVxxj7Lq8KvhFnZVhqKdZHtwRaJu7hvGwSZFMNg")
+ if err != nil {
+ t.Fatalf("Failed to decode peer ID: %v", err)
+ }
+
+ // Verify not banned initially
+ if store.IsBanned(pID) {
+ t.Errorf("Expected peer %s to not be banned", pID)
+ }
+
+ // Manually add peer to banned bucket to test IsBanned
+ err = store.db.Update(func(tx *bbolt.Tx) error {
+ b := tx.Bucket([]byte("banned_peers"))
+ if b == nil {
+ return fmt.Errorf("banned_peers bucket not found")
+ }
+ return b.Put([]byte(pID.String()), []byte("banned"))
+ })
+ if err != nil {
+ t.Fatalf("Failed to manually ban peer: %v", err)
+ }
+
+ // Verify banned now
+ if !store.IsBanned(pID) {
+ t.Errorf("Expected peer %s to be banned", pID)
+ }
+}
+
+func TestGetDefaultDataDir(t *testing.T) {
+ dir, err := GetDefaultDataDir()
+ if err != nil {
+ t.Fatalf("GetDefaultDataDir failed: %v", err)
+ }
+ if dir == "" {
+ t.Error("Expected non-empty directory path")
+ }
+}