Unified · Split
| @@ -35,6 +35,7 @@ auth-dir: "~/.cli-proxy-api" · 34 unmodified lines | ||
| 35 | 35 | api-keys: |
| 36 | 36 | - "your-api-key-1" |
| 37 | 37 | - "your-api-key-2" |
| 38 | + - "your-api-key-3" | |
| 38 | 39 | |
| 39 | 40 | # Enable debug logging |
| 40 | 41 | debug: false |
| @@ -166,6 +167,18 @@ ws-auth: false · 125 unmodified lines | ||
| 166 | 167 | # upstream-url: "https://ampcode.com" |
| 167 | 168 | # # Optional: Override API key for Amp upstream (otherwise uses env or file) |
| 168 | 169 | # upstream-api-key: "" |
| 170 | +# # Per-client upstream API key mapping | |
| 171 | +# # Maps client API keys (from top-level api-keys) to different Amp upstream API keys. | |
| 172 | +# # Useful when different clients need to use different Amp accounts/quotas. | |
| 173 | +# # If a client key isn't mapped, falls back to upstream-api-key (default behavior). | |
| 174 | +# upstream-api-keys: | |
| 175 | +# - upstream-api-key: "amp_key_for_team_a" # Upstream key to use for these clients | |
| 176 | +# api-keys: # Client keys that use this upstream key | |
| 177 | +# - "your-api-key-1" | |
| 178 | +# - "your-api-key-2" | |
| 179 | +# - upstream-api-key: "amp_key_for_team_b" | |
| 180 | +# api-keys: | |
| 181 | +# - "your-api-key-3" | |
| 169 | 182 | # # Restrict Amp management routes (/api/auth, /api/user, etc.) to localhost only (default: false) |
| 170 | 183 | # restrict-management-to-localhost: false |
| 171 | 184 | # # Force model mappings to run before checking local API keys (default: false) |
| @@ -940,3 +940,151 @@ func (h *Handler) GetAmpForceModelMappings(c *gin.Context) { · 939 unmodified lines | ||
| 940 | 940 | func (h *Handler) PutAmpForceModelMappings(c *gin.Context) { |
| 941 | 941 | h.updateBoolField(c, func(v bool) { h.cfg.AmpCode.ForceModelMappings = v }) |
| 942 | 942 | } |
| 943 | + | |
| 944 | +// GetAmpUpstreamAPIKeys returns the ampcode upstream API keys mapping. | |
| 945 | +func (h *Handler) GetAmpUpstreamAPIKeys(c *gin.Context) { | |
| 946 | + if h == nil || h.cfg == nil { | |
| 947 | + c.JSON(200, gin.H{"upstream-api-keys": []config.AmpUpstreamAPIKeyEntry{}}) | |
| 948 | + return | |
| 949 | + } | |
| 950 | + c.JSON(200, gin.H{"upstream-api-keys": h.cfg.AmpCode.UpstreamAPIKeys}) | |
| 951 | +} | |
| 952 | + | |
| 953 | +// PutAmpUpstreamAPIKeys replaces all ampcode upstream API keys mappings. | |
| 954 | +func (h *Handler) PutAmpUpstreamAPIKeys(c *gin.Context) { | |
| 955 | + var body struct { | |
| 956 | + Value []config.AmpUpstreamAPIKeyEntry `json:"value"` | |
| 957 | + } | |
| 958 | + if err := c.ShouldBindJSON(&body); err != nil { | |
| 959 | + c.JSON(400, gin.H{"error": "invalid body"}) | |
| 960 | + return | |
| 961 | + } | |
| 962 | + // Normalize entries: trim whitespace, filter empty | |
| 963 | + normalized := normalizeAmpUpstreamAPIKeyEntries(body.Value) | |
| 964 | + h.cfg.AmpCode.UpstreamAPIKeys = normalized | |
| 965 | + h.persist(c) | |
| 966 | +} | |
| 967 | + | |
| 968 | +// PatchAmpUpstreamAPIKeys adds or updates upstream API keys entries. | |
| 969 | +// Matching is done by upstream-api-key value. | |
| 970 | +func (h *Handler) PatchAmpUpstreamAPIKeys(c *gin.Context) { | |
| 971 | + var body struct { | |
| 972 | + Value []config.AmpUpstreamAPIKeyEntry `json:"value"` | |
| 973 | + } | |
| 974 | + if err := c.ShouldBindJSON(&body); err != nil { | |
| 975 | + c.JSON(400, gin.H{"error": "invalid body"}) | |
| 976 | + return | |
| 977 | + } | |
| 978 | + | |
| 979 | + existing := make(map[string]int) | |
| 980 | + for i, entry := range h.cfg.AmpCode.UpstreamAPIKeys { | |
| 981 | + existing[strings.TrimSpace(entry.UpstreamAPIKey)] = i | |
| 982 | + } | |
| 983 | + | |
| 984 | + for _, newEntry := range body.Value { | |
| 985 | + upstreamKey := strings.TrimSpace(newEntry.UpstreamAPIKey) | |
| 986 | + if upstreamKey == "" { | |
| 987 | + continue | |
| 988 | + } | |
| 989 | + normalizedEntry := config.AmpUpstreamAPIKeyEntry{ | |
| 990 | + UpstreamAPIKey: upstreamKey, | |
| 991 | + APIKeys: normalizeAPIKeysList(newEntry.APIKeys), | |
| 992 | + } | |
| 993 | + if idx, ok := existing[upstreamKey]; ok { | |
| 994 | + h.cfg.AmpCode.UpstreamAPIKeys[idx] = normalizedEntry | |
| 995 | + } else { | |
| 996 | + h.cfg.AmpCode.UpstreamAPIKeys = append(h.cfg.AmpCode.UpstreamAPIKeys, normalizedEntry) | |
| 997 | + existing[upstreamKey] = len(h.cfg.AmpCode.UpstreamAPIKeys) - 1 | |
| 998 | + } | |
| 999 | + } | |
| 1000 | + h.persist(c) | |
| 1001 | +} | |
| 1002 | + | |
| 1003 | +// DeleteAmpUpstreamAPIKeys removes specified upstream API keys entries. | |
| 1004 | +// Body must be JSON: {"value": ["<upstream-api-key>", ...]}. | |
| 1005 | +// If "value" is an empty array, clears all entries. | |
| 1006 | +// If JSON is invalid or "value" is missing/null, returns 400 and does not persist any change. | |
| 1007 | +func (h *Handler) DeleteAmpUpstreamAPIKeys(c *gin.Context) { | |
| 1008 | + var body struct { | |
| 1009 | + Value []string `json:"value"` | |
| 1010 | + } | |
| 1011 | + if err := c.ShouldBindJSON(&body); err != nil { | |
| 1012 | + c.JSON(400, gin.H{"error": "invalid body"}) | |
| 1013 | + return | |
| 1014 | + } | |
| 1015 | + | |
| 1016 | + if body.Value == nil { | |
| 1017 | + c.JSON(400, gin.H{"error": "missing value"}) | |
| 1018 | + return | |
| 1019 | + } | |
| 1020 | + | |
| 1021 | + // Empty array means clear all | |
| 1022 | + if len(body.Value) == 0 { | |
| 1023 | + h.cfg.AmpCode.UpstreamAPIKeys = nil | |
| 1024 | + h.persist(c) | |
| 1025 | + return | |
| 1026 | + } | |
| 1027 | + | |
| 1028 | + toRemove := make(map[string]bool) | |
| 1029 | + for _, key := range body.Value { | |
| 1030 | + trimmed := strings.TrimSpace(key) | |
| 1031 | + if trimmed == "" { | |
| 1032 | + continue | |
| 1033 | + } | |
| 1034 | + toRemove[trimmed] = true | |
| 1035 | + } | |
| 1036 | + if len(toRemove) == 0 { | |
| 1037 | + c.JSON(400, gin.H{"error": "empty value"}) | |
| 1038 | + return | |
| 1039 | + } | |
| 1040 | + | |
| 1041 | + newEntries := make([]config.AmpUpstreamAPIKeyEntry, 0, len(h.cfg.AmpCode.UpstreamAPIKeys)) | |
| 1042 | + for _, entry := range h.cfg.AmpCode.UpstreamAPIKeys { | |
| 1043 | + if !toRemove[strings.TrimSpace(entry.UpstreamAPIKey)] { | |
| 1044 | + newEntries = append(newEntries, entry) | |
| 1045 | + } | |
| 1046 | + } | |
| 1047 | + h.cfg.AmpCode.UpstreamAPIKeys = newEntries | |
| 1048 | + h.persist(c) | |
| 1049 | +} | |
| 1050 | + | |
| 1051 | +// normalizeAmpUpstreamAPIKeyEntries normalizes a list of upstream API key entries. | |
| 1052 | +func normalizeAmpUpstreamAPIKeyEntries(entries []config.AmpUpstreamAPIKeyEntry) []config.AmpUpstreamAPIKeyEntry { | |
| 1053 | + if len(entries) == 0 { | |
| 1054 | + return nil | |
| 1055 | + } | |
| 1056 | + out := make([]config.AmpUpstreamAPIKeyEntry, 0, len(entries)) | |
| 1057 | + for _, entry := range entries { | |
| 1058 | + upstreamKey := strings.TrimSpace(entry.UpstreamAPIKey) | |
| 1059 | + if upstreamKey == "" { | |
| 1060 | + continue | |
| 1061 | + } | |
| 1062 | + apiKeys := normalizeAPIKeysList(entry.APIKeys) | |
| 1063 | + out = append(out, config.AmpUpstreamAPIKeyEntry{ | |
| 1064 | + UpstreamAPIKey: upstreamKey, | |
| 1065 | + APIKeys: apiKeys, | |
| 1066 | + }) | |
| 1067 | + } | |
| 1068 | + if len(out) == 0 { | |
| 1069 | + return nil | |
| 1070 | + } | |
| 1071 | + return out | |
| 1072 | +} | |
| 1073 | + | |
| 1074 | +// normalizeAPIKeysList trims and filters empty strings from a list of API keys. | |
| 1075 | +func normalizeAPIKeysList(keys []string) []string { | |
| 1076 | + if len(keys) == 0 { | |
| 1077 | + return nil | |
| 1078 | + } | |
| 1079 | + out := make([]string, 0, len(keys)) | |
| 1080 | + for _, k := range keys { | |
| 1081 | + trimmed := strings.TrimSpace(k) | |
| 1082 | + if trimmed != "" { | |
| 1083 | + out = append(out, trimmed) | |
| 1084 | + } | |
| 1085 | + } | |
| 1086 | + if len(out) == 0 { | |
| 1087 | + return nil | |
| 1088 | + } | |
| 1089 | + return out | |
| 1090 | +} | |
| @@ -227,11 +227,20 @@ func (m *AmpModule) OnConfigUpdated(cfg *config.Config) error { · 226 unmodified lines | ||
| 227 | 227 | } |
| 228 | 228 | } |
| 229 | 229 | |
| 230 | − // Check API key change | |
| 230 | + // Check API key change (both default and per-client mappings) | |
| 231 | 231 | apiKeyChanged := m.hasAPIKeyChanged(oldSettings, &newSettings) |
| 232 | − if apiKeyChanged { | |
| 232 | + upstreamAPIKeysChanged := m.hasUpstreamAPIKeysChanged(oldSettings, &newSettings) | |
| 233 | + if apiKeyChanged || upstreamAPIKeysChanged { | |
| 233 | 234 | if m.secretSource != nil { |
| 234 | − if ms, ok := m.secretSource.(*MultiSourceSecret); ok { | |
| 235 | + if ms, ok := m.secretSource.(*MappedSecretSource); ok { | |
| 236 | + if apiKeyChanged { | |
| 237 | + ms.UpdateDefaultExplicitKey(newSettings.UpstreamAPIKey) | |
| 238 | + ms.InvalidateCache() | |
| 239 | + } | |
| 240 | + if upstreamAPIKeysChanged { | |
| 241 | + ms.UpdateMappings(newSettings.UpstreamAPIKeys) | |
| 242 | + } | |
| 243 | + } else if ms, ok := m.secretSource.(*MultiSourceSecret); ok { | |
| 235 | 244 | ms.UpdateExplicitKey(newSettings.UpstreamAPIKey) |
| 236 | 245 | ms.InvalidateCache() |
| 237 | 246 | } |
| @@ -251,10 +260,22 @@ func (m *AmpModule) OnConfigUpdated(cfg *config.Config) error { · 13 unmodified lines | ||
| 251 | 260 | |
| 252 | 261 | func (m *AmpModule) enableUpstreamProxy(upstreamURL string, settings *config.AmpCode) error { |
| 253 | 262 | if m.secretSource == nil { |
| 254 | − m.secretSource = NewMultiSourceSecret(settings.UpstreamAPIKey, 0 /* default 5min */) | |
| 263 | + // Create MultiSourceSecret as the default source, then wrap with MappedSecretSource | |
| 264 | + defaultSource := NewMultiSourceSecret(settings.UpstreamAPIKey, 0 /* default 5min */) | |
| 265 | + mappedSource := NewMappedSecretSource(defaultSource) | |
| 266 | + mappedSource.UpdateMappings(settings.UpstreamAPIKeys) | |
| 267 | + m.secretSource = mappedSource | |
| 268 | + } else if ms, ok := m.secretSource.(*MappedSecretSource); ok { | |
| 269 | + ms.UpdateDefaultExplicitKey(settings.UpstreamAPIKey) | |
| 270 | + ms.InvalidateCache() | |
| 271 | + ms.UpdateMappings(settings.UpstreamAPIKeys) | |
| 255 | 272 | } else if ms, ok := m.secretSource.(*MultiSourceSecret); ok { |
| 273 | + // Legacy path: wrap existing MultiSourceSecret with MappedSecretSource | |
| 256 | 274 | ms.UpdateExplicitKey(settings.UpstreamAPIKey) |
| 257 | 275 | ms.InvalidateCache() |
| 276 | + mappedSource := NewMappedSecretSource(ms) | |
| 277 | + mappedSource.UpdateMappings(settings.UpstreamAPIKeys) | |
| 278 | + m.secretSource = mappedSource | |
| 258 | 279 | } |
| 259 | 280 | |
| 260 | 281 | proxy, err := createReverseProxy(upstreamURL, m.secretSource) |
| @@ -313,6 +334,66 @@ func (m *AmpModule) hasAPIKeyChanged(old *config.AmpCode, new *config.AmpCode) b · 52 unmodified lines | ||
| 313 | 334 | return oldKey != newKey |
| 314 | 335 | } |
| 315 | 336 | |
| 337 | +// hasUpstreamAPIKeysChanged compares old and new per-client upstream API key mappings. | |
| 338 | +func (m *AmpModule) hasUpstreamAPIKeysChanged(old *config.AmpCode, new *config.AmpCode) bool { | |
| 339 | + if old == nil { | |
| 340 | + return len(new.UpstreamAPIKeys) > 0 | |
| 341 | + } | |
| 342 | + | |
| 343 | + if len(old.UpstreamAPIKeys) != len(new.UpstreamAPIKeys) { | |
| 344 | + return true | |
| 345 | + } | |
| 346 | + | |
| 347 | + // Build map for comparison: upstreamKey -> set of clientKeys | |
| 348 | + type entryInfo struct { | |
| 349 | + upstreamKey string | |
| 350 | + clientKeys map[string]struct{} | |
| 351 | + } | |
| 352 | + oldEntries := make([]entryInfo, len(old.UpstreamAPIKeys)) | |
| 353 | + for i, entry := range old.UpstreamAPIKeys { | |
| 354 | + clientKeys := make(map[string]struct{}, len(entry.APIKeys)) | |
| 355 | + for _, k := range entry.APIKeys { | |
| 356 | + trimmed := strings.TrimSpace(k) | |
| 357 | + if trimmed == "" { | |
| 358 | + continue | |
| 359 | + } | |
| 360 | + clientKeys[trimmed] = struct{}{} | |
| 361 | + } | |
| 362 | + oldEntries[i] = entryInfo{ | |
| 363 | + upstreamKey: strings.TrimSpace(entry.UpstreamAPIKey), | |
| 364 | + clientKeys: clientKeys, | |
| 365 | + } | |
| 366 | + } | |
| 367 | + | |
| 368 | + for i, newEntry := range new.UpstreamAPIKeys { | |
| 369 | + if i >= len(oldEntries) { | |
| 370 | + return true | |
| 371 | + } | |
| 372 | + oldE := oldEntries[i] | |
| 373 | + if strings.TrimSpace(newEntry.UpstreamAPIKey) != oldE.upstreamKey { | |
| 374 | + return true | |
| 375 | + } | |
| 376 | + newKeys := make(map[string]struct{}, len(newEntry.APIKeys)) | |
| 377 | + for _, k := range newEntry.APIKeys { | |
| 378 | + trimmed := strings.TrimSpace(k) | |
| 379 | + if trimmed == "" { | |
| 380 | + continue | |
| 381 | + } | |
| 382 | + newKeys[trimmed] = struct{}{} | |
| 383 | + } | |
| 384 | + if len(newKeys) != len(oldE.clientKeys) { | |
| 385 | + return true | |
| 386 | + } | |
| 387 | + for k := range newKeys { | |
| 388 | + if _, ok := oldE.clientKeys[k]; !ok { | |
| 389 | + return true | |
| 390 | + } | |
| 391 | + } | |
| 392 | + } | |
| 393 | + | |
| 394 | + return false | |
| 395 | +} | |
| 396 | + | |
| 316 | 397 | // GetModelMapper returns the model mapper instance (for testing/debugging). |
| 317 | 398 | func (m *AmpModule) GetModelMapper() *DefaultModelMapper { |
| 318 | 399 | return m.modelMapper |
| @@ -312,3 +312,41 @@ func TestAmpModule_ProviderAliasesAlwaysRegistered(t *testing.T) { · 311 unmodified lines | ||
| 312 | 312 | }) |
| 313 | 313 | } |
| 314 | 314 | } |
| 315 | + | |
| 316 | +func TestAmpModule_hasUpstreamAPIKeysChanged_DetectsRemovedKeyWithDuplicateInput(t *testing.T) { | |
| 317 | + m := &AmpModule{} | |
| 318 | + | |
| 319 | + oldCfg := &config.AmpCode{ | |
| 320 | + UpstreamAPIKeys: []config.AmpUpstreamAPIKeyEntry{ | |
| 321 | + {UpstreamAPIKey: "u1", APIKeys: []string{"k1", "k2"}}, | |
| 322 | + }, | |
| 323 | + } | |
| 324 | + newCfg := &config.AmpCode{ | |
| 325 | + UpstreamAPIKeys: []config.AmpUpstreamAPIKeyEntry{ | |
| 326 | + {UpstreamAPIKey: "u1", APIKeys: []string{"k1", "k1"}}, | |
| 327 | + }, | |
| 328 | + } | |
| 329 | + | |
| 330 | + if !m.hasUpstreamAPIKeysChanged(oldCfg, newCfg) { | |
| 331 | + t.Fatal("expected change to be detected when k2 is removed but new list contains duplicates") | |
| 332 | + } | |
| 333 | +} | |
| 334 | + | |
| 335 | +func TestAmpModule_hasUpstreamAPIKeysChanged_IgnoresEmptyAndWhitespaceKeys(t *testing.T) { | |
| 336 | + m := &AmpModule{} | |
| 337 | + | |
| 338 | + oldCfg := &config.AmpCode{ | |
| 339 | + UpstreamAPIKeys: []config.AmpUpstreamAPIKeyEntry{ | |
| 340 | + {UpstreamAPIKey: "u1", APIKeys: []string{"k1", "k2"}}, | |
| 341 | + }, | |
| 342 | + } | |
| 343 | + newCfg := &config.AmpCode{ | |
| 344 | + UpstreamAPIKeys: []config.AmpUpstreamAPIKeyEntry{ | |
| 345 | + {UpstreamAPIKey: "u1", APIKeys: []string{" k1 ", "", "k2", " "}}, | |
| 346 | + }, | |
| 347 | + } | |
| 348 | + | |
| 349 | + if m.hasUpstreamAPIKeysChanged(oldCfg, newCfg) { | |
| 350 | + t.Fatal("expected no change when only whitespace/empty entries differ") | |
| 351 | + } | |
| 352 | +} | |
| @@ -15,6 +15,33 @@ import ( · 14 unmodified lines | ||
| 15 | 15 | log "github.com/sirupsen/logrus" |
| 16 | 16 | ) |
| 17 | 17 | |
| 18 | +func removeQueryValuesMatching(req *http.Request, key string, match string) { | |
| 19 | + if req == nil || req.URL == nil || match == "" { | |
| 20 | + return | |
| 21 | + } | |
| 22 | + | |
| 23 | + q := req.URL.Query() | |
| 24 | + values, ok := q[key] | |
| 25 | + if !ok || len(values) == 0 { | |
| 26 | + return | |
| 27 | + } | |
| 28 | + | |
| 29 | + kept := make([]string, 0, len(values)) | |
| 30 | + for _, v := range values { | |
| 31 | + if v == match { | |
| 32 | + continue | |
| 33 | + } | |
| 34 | + kept = append(kept, v) | |
| 35 | + } | |
| 36 | + | |
| 37 | + if len(kept) == 0 { | |
| 38 | + q.Del(key) | |
| 39 | + } else { | |
| 40 | + q[key] = kept | |
| 41 | + } | |
| 42 | + req.URL.RawQuery = q.Encode() | |
| 43 | +} | |
| 44 | + | |
| 18 | 45 | // readCloser wraps a reader and forwards Close to a separate closer. |
| 19 | 46 | // Used to restore peeked bytes while preserving upstream body Close behavior. |
| 20 | 47 | type readCloser struct { |
| @@ -45,6 +72,14 @@ func createReverseProxy(upstreamURL string, secretSource SecretSource) (*httputi · 24 unmodified lines | ||
| 45 | 72 | // We will set our own Authorization using the configured upstream-api-key |
| 46 | 73 | req.Header.Del("Authorization") |
| 47 | 74 | req.Header.Del("X-Api-Key") |
| 75 | + req.Header.Del("X-Goog-Api-Key") | |
| 76 | + | |
| 77 | + // Remove query-based credentials if they match the authenticated client API key. | |
| 78 | + // This prevents leaking client auth material to the Amp upstream while avoiding | |
| 79 | + // breaking unrelated upstream query parameters. | |
| 80 | + clientKey := getClientAPIKeyFromContext(req.Context()) | |
| 81 | + removeQueryValuesMatching(req, "key", clientKey) | |
| 82 | + removeQueryValuesMatching(req, "auth_token", clientKey) | |
| 48 | 83 | |
| 49 | 84 | // Preserve correlation headers for debugging |
| 50 | 85 | if req.Header.Get("X-Request-ID") == "" { |
| @@ -3,11 +3,15 @@ package amp · 2 unmodified lines | ||
| 3 | 3 | import ( |
| 4 | 4 | "bytes" |
| 5 | 5 | "compress/gzip" |
| 6 | + "context" | |
| 6 | 7 | "fmt" |
| 7 | 8 | "io" |
| 8 | 9 | "net/http" |
| 9 | 10 | "net/http/httptest" |
| 11 | + "strings" | |
| 10 | 12 | "testing" |
| 13 | + | |
| 14 | + "github.com/router-for-me/CLIProxyAPI/v6/internal/config" | |
| 11 | 15 | ) |
| 12 | 16 | |
| 13 | 17 | // Helper: compress data with gzip |
| @@ -306,6 +310,159 @@ func TestReverseProxy_EmptySecret(t *testing.T) { · 292 unmodified lines | ||
| 306 | 310 | } |
| 307 | 311 | } |
| 308 | 312 | |
| 313 | +func TestReverseProxy_StripsClientCredentialsFromHeadersAndQuery(t *testing.T) { | |
| 314 | + type captured struct { | |
| 315 | + headers http.Header | |
| 316 | + query string | |
| 317 | + } | |
| 318 | + got := make(chan captured, 1) | |
| 319 | + upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| 320 | + got <- captured{headers: r.Header.Clone(), query: r.URL.RawQuery} | |
| 321 | + w.WriteHeader(200) | |
| 322 | + w.Write([]byte(`ok`)) | |
| 323 | + })) | |
| 324 | + defer upstream.Close() | |
| 325 | + | |
| 326 | + proxy, err := createReverseProxy(upstream.URL, NewStaticSecretSource("upstream")) | |
| 327 | + if err != nil { | |
| 328 | + t.Fatal(err) | |
| 329 | + } | |
| 330 | + | |
| 331 | + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| 332 | + // Simulate clientAPIKeyMiddleware injection (per-request) | |
| 333 | + ctx := context.WithValue(r.Context(), clientAPIKeyContextKey{}, "client-key") | |
| 334 | + proxy.ServeHTTP(w, r.WithContext(ctx)) | |
| 335 | + })) | |
| 336 | + defer srv.Close() | |
| 337 | + | |
| 338 | + req, err := http.NewRequest(http.MethodGet, srv.URL+"/test?key=client-key&key=keep&auth_token=client-key&foo=bar", nil) | |
| 339 | + if err != nil { | |
| 340 | + t.Fatal(err) | |
| 341 | + } | |
| 342 | + req.Header.Set("Authorization", "Bearer client-key") | |
| 343 | + req.Header.Set("X-Api-Key", "client-key") | |
| 344 | + req.Header.Set("X-Goog-Api-Key", "client-key") | |
| 345 | + | |
| 346 | + res, err := http.DefaultClient.Do(req) | |
| 347 | + if err != nil { | |
| 348 | + t.Fatal(err) | |
| 349 | + } | |
| 350 | + res.Body.Close() | |
| 351 | + | |
| 352 | + c := <-got | |
| 353 | + | |
| 354 | + // These are client-provided credentials and must not reach the upstream. | |
| 355 | + if v := c.headers.Get("X-Goog-Api-Key"); v != "" { | |
| 356 | + t.Fatalf("X-Goog-Api-Key should be stripped, got: %q", v) | |
| 357 | + } | |
| 358 | + | |
| 359 | + // We inject upstream Authorization/X-Api-Key, so the client auth must not survive. | |
| 360 | + if v := c.headers.Get("Authorization"); v != "Bearer upstream" { | |
| 361 | + t.Fatalf("Authorization should be upstream-injected, got: %q", v) | |
| 362 | + } | |
| 363 | + if v := c.headers.Get("X-Api-Key"); v != "upstream" { | |
| 364 | + t.Fatalf("X-Api-Key should be upstream-injected, got: %q", v) | |
| 365 | + } | |
| 366 | + | |
| 367 | + // Query-based credentials should be stripped only when they match the authenticated client key. | |
| 368 | + // Should keep unrelated values and parameters. | |
| 369 | + if strings.Contains(c.query, "auth_token=client-key") || strings.Contains(c.query, "key=client-key") { | |
| 370 | + t.Fatalf("query credentials should be stripped, got raw query: %q", c.query) | |
| 371 | + } | |
| 372 | + if !strings.Contains(c.query, "key=keep") || !strings.Contains(c.query, "foo=bar") { | |
| 373 | + t.Fatalf("expected query to keep non-credential params, got raw query: %q", c.query) | |
| 374 | + } | |
| 375 | +} | |
| 376 | + | |
| 377 | +func TestReverseProxy_InjectsMappedSecret_FromRequestContext(t *testing.T) { | |
| 378 | + gotHeaders := make(chan http.Header, 1) | |
| 379 | + upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| 380 | + gotHeaders <- r.Header.Clone() | |
| 381 | + w.WriteHeader(200) | |
| 382 | + w.Write([]byte(`ok`)) | |
| 383 | + })) | |
| 384 | + defer upstream.Close() | |
| 385 | + | |
| 386 | + defaultSource := NewStaticSecretSource("default") | |
| 387 | + mapped := NewMappedSecretSource(defaultSource) | |
| 388 | + mapped.UpdateMappings([]config.AmpUpstreamAPIKeyEntry{ | |
| 389 | + { | |
| 390 | + UpstreamAPIKey: "u1", | |
| 391 | + APIKeys: []string{"k1"}, | |
| 392 | + }, | |
| 393 | + }) | |
| 394 | + | |
| 395 | + proxy, err := createReverseProxy(upstream.URL, mapped) | |
| 396 | + if err != nil { | |
| 397 | + t.Fatal(err) | |
| 398 | + } | |
| 399 | + | |
| 400 | + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| 401 | + // Simulate clientAPIKeyMiddleware injection (per-request) | |
| 402 | + ctx := context.WithValue(r.Context(), clientAPIKeyContextKey{}, "k1") | |
| 403 | + proxy.ServeHTTP(w, r.WithContext(ctx)) | |
| 404 | + })) | |
| 405 | + defer srv.Close() | |
| 406 | + | |
| 407 | + res, err := http.Get(srv.URL + "/test") | |
| 408 | + if err != nil { | |
| 409 | + t.Fatal(err) | |
| 410 | + } | |
| 411 | + res.Body.Close() | |
| 412 | + | |
| 413 | + hdr := <-gotHeaders | |
| 414 | + if hdr.Get("X-Api-Key") != "u1" { | |
| 415 | + t.Fatalf("X-Api-Key missing or wrong, got: %q", hdr.Get("X-Api-Key")) | |
| 416 | + } | |
| 417 | + if hdr.Get("Authorization") != "Bearer u1" { | |
| 418 | + t.Fatalf("Authorization missing or wrong, got: %q", hdr.Get("Authorization")) | |
| 419 | + } | |
| 420 | +} | |
| 421 | + | |
| 422 | +func TestReverseProxy_MappedSecret_FallsBackToDefault(t *testing.T) { | |
| 423 | + gotHeaders := make(chan http.Header, 1) | |
| 424 | + upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| 425 | + gotHeaders <- r.Header.Clone() | |
| 426 | + w.WriteHeader(200) | |
| 427 | + w.Write([]byte(`ok`)) | |
| 428 | + })) | |
| 429 | + defer upstream.Close() | |
| 430 | + | |
| 431 | + defaultSource := NewStaticSecretSource("default") | |
| 432 | + mapped := NewMappedSecretSource(defaultSource) | |
| 433 | + mapped.UpdateMappings([]config.AmpUpstreamAPIKeyEntry{ | |
| 434 | + { | |
| 435 | + UpstreamAPIKey: "u1", | |
| 436 | + APIKeys: []string{"k1"}, | |
| 437 | + }, | |
| 438 | + }) | |
| 439 | + | |
| 440 | + proxy, err := createReverseProxy(upstream.URL, mapped) | |
| 441 | + if err != nil { | |
| 442 | + t.Fatal(err) | |
| 443 | + } | |
| 444 | + | |
| 445 | + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| 446 | + ctx := context.WithValue(r.Context(), clientAPIKeyContextKey{}, "k2") | |
| 447 | + proxy.ServeHTTP(w, r.WithContext(ctx)) | |
| 448 | + })) | |
| 449 | + defer srv.Close() | |
| 450 | + | |
| 451 | + res, err := http.Get(srv.URL + "/test") | |
| 452 | + if err != nil { | |
| 453 | + t.Fatal(err) | |
| 454 | + } | |
| 455 | + res.Body.Close() | |
| 456 | + | |
| 457 | + hdr := <-gotHeaders | |
| 458 | + if hdr.Get("X-Api-Key") != "default" { | |
| 459 | + t.Fatalf("X-Api-Key fallback missing or wrong, got: %q", hdr.Get("X-Api-Key")) | |
| 460 | + } | |
| 461 | + if hdr.Get("Authorization") != "Bearer default" { | |
| 462 | + t.Fatalf("Authorization fallback missing or wrong, got: %q", hdr.Get("Authorization")) | |
| 463 | + } | |
| 464 | +} | |
| 465 | + | |
| 309 | 466 | func TestReverseProxy_ErrorHandler(t *testing.T) { |
| 310 | 467 | // Point proxy to a non-routable address to trigger error |
| 311 | 468 | proxy, err := createReverseProxy("http://127.0.0.1:1", NewStaticSecretSource("")) |
| @@ -1,6 +1,7 @@ | ||
| 1 | 1 | package amp |
| 2 | 2 | |
| 3 | 3 | import ( |
| 4 | + "context" | |
| 4 | 5 | "errors" |
| 5 | 6 | "net" |
| 6 | 7 | "net/http" |
| @@ -16,6 +17,37 @@ import ( · 9 unmodified lines | ||
| 16 | 17 | log "github.com/sirupsen/logrus" |
| 17 | 18 | ) |
| 18 | 19 | |
| 20 | +// clientAPIKeyContextKey is the context key used to pass the client API key | |
| 21 | +// from gin.Context to the request context for SecretSource lookup. | |
| 22 | +type clientAPIKeyContextKey struct{} | |
| 23 | + | |
| 24 | +// clientAPIKeyMiddleware injects the authenticated client API key from gin.Context["apiKey"] | |
| 25 | +// into the request context so that SecretSource can look it up for per-client upstream routing. | |
| 26 | +func clientAPIKeyMiddleware() gin.HandlerFunc { | |
| 27 | + return func(c *gin.Context) { | |
| 28 | + // Extract the client API key from gin context (set by AuthMiddleware) | |
| 29 | + if apiKey, exists := c.Get("apiKey"); exists { | |
| 30 | + if keyStr, ok := apiKey.(string); ok && keyStr != "" { | |
| 31 | + // Inject into request context for SecretSource.Get(ctx) to read | |
| 32 | + ctx := context.WithValue(c.Request.Context(), clientAPIKeyContextKey{}, keyStr) | |
| 33 | + c.Request = c.Request.WithContext(ctx) | |
| 34 | + } | |
| 35 | + } | |
| 36 | + c.Next() | |
| 37 | + } | |
| 38 | +} | |
| 39 | + | |
| 40 | +// getClientAPIKeyFromContext retrieves the client API key from request context. | |
| 41 | +// Returns empty string if not present. | |
| 42 | +func getClientAPIKeyFromContext(ctx context.Context) string { | |
| 43 | + if val := ctx.Value(clientAPIKeyContextKey{}); val != nil { | |
| 44 | + if keyStr, ok := val.(string); ok { | |
| 45 | + return keyStr | |
| 46 | + } | |
| 47 | + } | |
| 48 | + return "" | |
| 49 | +} | |
| 50 | + | |
| 19 | 51 | // localhostOnlyMiddleware returns a middleware that dynamically checks the module's |
| 20 | 52 | // localhost restriction setting. This allows hot-reload of the restriction without restarting. |
| 21 | 53 | func (m *AmpModule) localhostOnlyMiddleware() gin.HandlerFunc { |
| @@ -129,6 +161,9 @@ func (m *AmpModule) registerManagementRoutes(engine *gin.Engine, baseHandler *ha · 107 unmodified lines | ||
| 129 | 161 | authWithBypass = wrapManagementAuth(auth, "/threads", "/auth", "/docs", "/settings") |
| 130 | 162 | } |
| 131 | 163 | |
| 164 | + // Inject client API key into request context for per-client upstream routing | |
| 165 | + ampAPI.Use(clientAPIKeyMiddleware()) | |
| 166 | + | |
| 132 | 167 | // Dynamic proxy handler that uses m.getProxy() for hot-reload support |
| 133 | 168 | proxyHandler := func(c *gin.Context) { |
| 134 | 169 | // Swallow ErrAbortHandler panics from ReverseProxy copyResponse to avoid noisy stack traces |
| @@ -175,6 +210,8 @@ func (m *AmpModule) registerManagementRoutes(engine *gin.Engine, baseHandler *ha · 40 unmodified lines | ||
| 175 | 210 | if authWithBypass != nil { |
| 176 | 211 | rootMiddleware = append(rootMiddleware, authWithBypass) |
| 177 | 212 | } |
| 213 | + // Add clientAPIKeyMiddleware after auth for per-client upstream routing | |
| 214 | + rootMiddleware = append(rootMiddleware, clientAPIKeyMiddleware()) | |
| 178 | 215 | engine.GET("/threads", append(rootMiddleware, proxyHandler)...) |
| 179 | 216 | engine.GET("/threads/*path", append(rootMiddleware, proxyHandler)...) |
| 180 | 217 | engine.GET("/docs", append(rootMiddleware, proxyHandler)...) |
| @@ -244,6 +281,8 @@ func (m *AmpModule) registerProviderAliases(engine *gin.Engine, baseHandler *han · 63 unmodified lines | ||
| 244 | 281 | if auth != nil { |
| 245 | 282 | ampProviders.Use(auth) |
| 246 | 283 | } |
| 284 | + // Inject client API key into request context for per-client upstream routing | |
| 285 | + ampProviders.Use(clientAPIKeyMiddleware()) | |
| 247 | 286 | |
| 248 | 287 | provider := ampProviders.Group("/:provider") |
| 249 | 288 | |
| @@ -9,6 +9,9 @@ import ( · 8 unmodified lines | ||
| 9 | 9 | "strings" |
| 10 | 10 | "sync" |
| 11 | 11 | "time" |
| 12 | + | |
| 13 | + "github.com/router-for-me/CLIProxyAPI/v6/internal/config" | |
| 14 | + log "github.com/sirupsen/logrus" | |
| 12 | 15 | ) |
| 13 | 16 | |
| 14 | 17 | // SecretSource provides Amp API keys with configurable precedence and caching |
| @@ -164,3 +167,82 @@ func NewStaticSecretSource(key string) *StaticSecretSource { · 149 unmodified lines | ||
| 164 | 167 | func (s *StaticSecretSource) Get(ctx context.Context) (string, error) { |
| 165 | 168 | return s.key, nil |
| 166 | 169 | } |
| 170 | + | |
| 171 | +// MappedSecretSource wraps a default SecretSource and adds per-client API key mapping. | |
| 172 | +// When a request context contains a client API key that matches a configured mapping, | |
| 173 | +// the corresponding upstream key is returned. Otherwise, falls back to the default source. | |
| 174 | +type MappedSecretSource struct { | |
| 175 | + defaultSource SecretSource | |
| 176 | + mu sync.RWMutex | |
| 177 | + lookup map[string]string // clientKey -> upstreamKey | |
| 178 | +} | |
| 179 | + | |
| 180 | +// NewMappedSecretSource creates a MappedSecretSource wrapping the given default source. | |
| 181 | +func NewMappedSecretSource(defaultSource SecretSource) *MappedSecretSource { | |
| 182 | + return &MappedSecretSource{ | |
| 183 | + defaultSource: defaultSource, | |
| 184 | + lookup: make(map[string]string), | |
| 185 | + } | |
| 186 | +} | |
| 187 | + | |
| 188 | +// Get retrieves the Amp API key, checking per-client mappings first. | |
| 189 | +// If the request context contains a client API key that matches a configured mapping, | |
| 190 | +// returns the corresponding upstream key. Otherwise, falls back to the default source. | |
| 191 | +func (s *MappedSecretSource) Get(ctx context.Context) (string, error) { | |
| 192 | + // Try to get client API key from request context | |
| 193 | + clientKey := getClientAPIKeyFromContext(ctx) | |
| 194 | + if clientKey != "" { | |
| 195 | + s.mu.RLock() | |
| 196 | + if upstreamKey, ok := s.lookup[clientKey]; ok && upstreamKey != "" { | |
| 197 | + s.mu.RUnlock() | |
| 198 | + return upstreamKey, nil | |
| 199 | + } | |
| 200 | + s.mu.RUnlock() | |
| 201 | + } | |
| 202 | + | |
| 203 | + // Fall back to default source | |
| 204 | + return s.defaultSource.Get(ctx) | |
| 205 | +} | |
| 206 | + | |
| 207 | +// UpdateMappings rebuilds the client-to-upstream key mapping from configuration entries. | |
| 208 | +// If the same client key appears in multiple entries, logs a warning and uses the first one. | |
| 209 | +func (s *MappedSecretSource) UpdateMappings(entries []config.AmpUpstreamAPIKeyEntry) { | |
| 210 | + newLookup := make(map[string]string) | |
| 211 | + | |
| 212 | + for _, entry := range entries { | |
| 213 | + upstreamKey := strings.TrimSpace(entry.UpstreamAPIKey) | |
| 214 | + if upstreamKey == "" { | |
| 215 | + continue | |
| 216 | + } | |
| 217 | + for _, clientKey := range entry.APIKeys { | |
| 218 | + trimmedKey := strings.TrimSpace(clientKey) | |
| 219 | + if trimmedKey == "" { | |
| 220 | + continue | |
| 221 | + } | |
| 222 | + if _, exists := newLookup[trimmedKey]; exists { | |
| 223 | + // Log warning for duplicate client key, first one wins | |
| 224 | + log.Warnf("amp upstream-api-keys: client API key appears in multiple entries; using first mapping.") | |
| 225 | + continue | |
| 226 | + } | |
| 227 | + newLookup[trimmedKey] = upstreamKey | |
| 228 | + } | |
| 229 | + } | |
| 230 | + | |
| 231 | + s.mu.Lock() | |
| 232 | + s.lookup = newLookup | |
| 233 | + s.mu.Unlock() | |
| 234 | +} | |
| 235 | + | |
| 236 | +// UpdateDefaultExplicitKey updates the explicit key on the underlying MultiSourceSecret (if applicable). | |
| 237 | +func (s *MappedSecretSource) UpdateDefaultExplicitKey(key string) { | |
| 238 | + if ms, ok := s.defaultSource.(*MultiSourceSecret); ok { | |
| 239 | + ms.UpdateExplicitKey(key) | |
| 240 | + } | |
| 241 | +} | |
| 242 | + | |
| 243 | +// InvalidateCache invalidates cache on the underlying MultiSourceSecret (if applicable). | |
| 244 | +func (s *MappedSecretSource) InvalidateCache() { | |
| 245 | + if ms, ok := s.defaultSource.(*MultiSourceSecret); ok { | |
| 246 | + ms.InvalidateCache() | |
| 247 | + } | |
| 248 | +} | |
| @@ -8,6 +8,10 @@ import ( · 7 unmodified lines | ||
| 8 | 8 | "sync" |
| 9 | 9 | "testing" |
| 10 | 10 | "time" |
| 11 | + | |
| 12 | + "github.com/router-for-me/CLIProxyAPI/v6/internal/config" | |
| 13 | + log "github.com/sirupsen/logrus" | |
| 14 | + "github.com/sirupsen/logrus/hooks/test" | |
| 11 | 15 | ) |
| 12 | 16 | |
| 13 | 17 | func TestMultiSourceSecret_PrecedenceOrder(t *testing.T) { |
| @@ -278,3 +282,85 @@ func TestMultiSourceSecret_CacheEmptyResult(t *testing.T) { · 264 unmodified lines | ||
| 278 | 282 | t.Fatalf("after cache expiry, expected new-value, got %q", got3) |
| 279 | 283 | } |
| 280 | 284 | } |
| 285 | + | |
| 286 | +func TestMappedSecretSource_UsesMappingFromContext(t *testing.T) { | |
| 287 | + defaultSource := NewStaticSecretSource("default") | |
| 288 | + s := NewMappedSecretSource(defaultSource) | |
| 289 | + s.UpdateMappings([]config.AmpUpstreamAPIKeyEntry{ | |
| 290 | + { | |
| 291 | + UpstreamAPIKey: "u1", | |
| 292 | + APIKeys: []string{"k1"}, | |
| 293 | + }, | |
| 294 | + }) | |
| 295 | + | |
| 296 | + ctx := context.WithValue(context.Background(), clientAPIKeyContextKey{}, "k1") | |
| 297 | + got, err := s.Get(ctx) | |
| 298 | + if err != nil { | |
| 299 | + t.Fatalf("unexpected error: %v", err) | |
| 300 | + } | |
| 301 | + if got != "u1" { | |
| 302 | + t.Fatalf("want u1, got %q", got) | |
| 303 | + } | |
| 304 | + | |
| 305 | + ctx = context.WithValue(context.Background(), clientAPIKeyContextKey{}, "k2") | |
| 306 | + got, err = s.Get(ctx) | |
| 307 | + if err != nil { | |
| 308 | + t.Fatalf("unexpected error: %v", err) | |
| 309 | + } | |
| 310 | + if got != "default" { | |
| 311 | + t.Fatalf("want default fallback, got %q", got) | |
| 312 | + } | |
| 313 | +} | |
| 314 | + | |
| 315 | +func TestMappedSecretSource_DuplicateClientKey_FirstWins(t *testing.T) { | |
| 316 | + defaultSource := NewStaticSecretSource("default") | |
| 317 | + s := NewMappedSecretSource(defaultSource) | |
| 318 | + s.UpdateMappings([]config.AmpUpstreamAPIKeyEntry{ | |
| 319 | + { | |
| 320 | + UpstreamAPIKey: "u1", | |
| 321 | + APIKeys: []string{"k1"}, | |
| 322 | + }, | |
| 323 | + { | |
| 324 | + UpstreamAPIKey: "u2", | |
| 325 | + APIKeys: []string{"k1"}, | |
| 326 | + }, | |
| 327 | + }) | |
| 328 | + | |
| 329 | + ctx := context.WithValue(context.Background(), clientAPIKeyContextKey{}, "k1") | |
| 330 | + got, err := s.Get(ctx) | |
| 331 | + if err != nil { | |
| 332 | + t.Fatalf("unexpected error: %v", err) | |
| 333 | + } | |
| 334 | + if got != "u1" { | |
| 335 | + t.Fatalf("want u1 (first wins), got %q", got) | |
| 336 | + } | |
| 337 | +} | |
| 338 | + | |
| 339 | +func TestMappedSecretSource_DuplicateClientKey_LogsWarning(t *testing.T) { | |
| 340 | + hook := test.NewLocal(log.StandardLogger()) | |
| 341 | + defer hook.Reset() | |
| 342 | + | |
| 343 | + defaultSource := NewStaticSecretSource("default") | |
| 344 | + s := NewMappedSecretSource(defaultSource) | |
| 345 | + s.UpdateMappings([]config.AmpUpstreamAPIKeyEntry{ | |
| 346 | + { | |
| 347 | + UpstreamAPIKey: "u1", | |
| 348 | + APIKeys: []string{"k1"}, | |
| 349 | + }, | |
| 350 | + { | |
| 351 | + UpstreamAPIKey: "u2", | |
| 352 | + APIKeys: []string{"k1"}, | |
| 353 | + }, | |
| 354 | + }) | |
| 355 | + | |
| 356 | + foundWarning := false | |
| 357 | + for _, entry := range hook.AllEntries() { | |
| 358 | + if entry.Level == log.WarnLevel && entry.Message == "amp upstream-api-keys: client API key appears in multiple entries; using first mapping." { | |
| 359 | + foundWarning = true | |
| 360 | + break | |
| 361 | + } | |
| 362 | + } | |
| 363 | + if !foundWarning { | |
| 364 | + t.Fatal("expected warning log for duplicate client key, but none was found") | |
| 365 | + } | |
| 366 | +} | |
| @@ -551,6 +551,10 @@ func (s *Server) registerManagementRoutes() { · 550 unmodified lines | ||
| 551 | 551 | mgmt.GET("/ampcode/force-model-mappings", s.mgmt.GetAmpForceModelMappings) |
| 552 | 552 | mgmt.PUT("/ampcode/force-model-mappings", s.mgmt.PutAmpForceModelMappings) |
| 553 | 553 | mgmt.PATCH("/ampcode/force-model-mappings", s.mgmt.PutAmpForceModelMappings) |
| 554 | + mgmt.GET("/ampcode/upstream-api-keys", s.mgmt.GetAmpUpstreamAPIKeys) | |
| 555 | + mgmt.PUT("/ampcode/upstream-api-keys", s.mgmt.PutAmpUpstreamAPIKeys) | |
| 556 | + mgmt.PATCH("/ampcode/upstream-api-keys", s.mgmt.PatchAmpUpstreamAPIKeys) | |
| 557 | + mgmt.DELETE("/ampcode/upstream-api-keys", s.mgmt.DeleteAmpUpstreamAPIKeys) | |
| 554 | 558 | |
| 555 | 559 | mgmt.GET("/request-retry", s.mgmt.GetRequestRetry) |
| 556 | 560 | mgmt.PUT("/request-retry", s.mgmt.PutRequestRetry) |
| @@ -163,6 +163,11 @@ type AmpCode struct { · 162 unmodified lines | ||
| 163 | 163 | // UpstreamAPIKey optionally overrides the Authorization header when proxying Amp upstream calls. |
| 164 | 164 | UpstreamAPIKey string `yaml:"upstream-api-key" json:"upstream-api-key"` |
| 165 | 165 | |
| 166 | + // UpstreamAPIKeys maps client API keys (from top-level api-keys) to upstream API keys. | |
| 167 | + // When a client authenticates with a key that matches an entry, that upstream key is used. | |
| 168 | + // If no match is found, falls back to UpstreamAPIKey (default behavior). | |
| 169 | + UpstreamAPIKeys []AmpUpstreamAPIKeyEntry `yaml:"upstream-api-keys,omitempty" json:"upstream-api-keys,omitempty"` | |
| 170 | + | |
| 166 | 171 | // RestrictManagementToLocalhost restricts Amp management routes (/api/user, /api/threads, etc.) |
| 167 | 172 | // to only accept connections from localhost (127.0.0.1, ::1). When true, prevents drive-by |
| 168 | 173 | // browser attacks and remote access to management endpoints. Default: false (API key auth is sufficient). |
| @@ -178,6 +183,17 @@ type AmpCode struct { · 9 unmodified lines | ||
| 178 | 183 | ForceModelMappings bool `yaml:"force-model-mappings" json:"force-model-mappings"` |
| 179 | 184 | } |
| 180 | 185 | |
| 186 | +// AmpUpstreamAPIKeyEntry maps a set of client API keys to a specific upstream API key. | |
| 187 | +// When a request is authenticated with one of the APIKeys, the corresponding UpstreamAPIKey | |
| 188 | +// is used for the upstream Amp request. | |
| 189 | +type AmpUpstreamAPIKeyEntry struct { | |
| 190 | + // UpstreamAPIKey is the API key to use when proxying to the Amp upstream. | |
| 191 | + UpstreamAPIKey string `yaml:"upstream-api-key" json:"upstream-api-key"` | |
| 192 | + | |
| 193 | + // APIKeys are the client API keys (from top-level api-keys) that map to this upstream key. | |
| 194 | + APIKeys []string `yaml:"api-keys" json:"api-keys"` | |
| 195 | +} | |
| 196 | + | |
| 181 | 197 | // PayloadConfig defines default and override parameter rules applied to provider payloads. |
| 182 | 198 | type PayloadConfig struct { |
| 183 | 199 | // Default defines rules that only set parameters when they are missing in the payload. |
| @@ -614,71 +614,6 @@ func TestCleanJSONSchemaForAntigravity_MultipleNonNullTypes(t *testing.T) { · 613 unmodified lines | ||
| 614 | 614 | } |
| 615 | 615 | } |
| 616 | 616 | |
| 617 | −func TestCleanJSONSchemaForGemini_PropertyNamesRemoval(t *testing.T) { | |
| 618 | − // propertyNames is used to validate object property names (e.g., must match a pattern) | |
| 619 | − // Gemini doesn't support this keyword and will reject requests containing it | |
| 620 | − input := `{ | |
| 621 | − "type": "object", | |
| 622 | − "properties": { | |
| 623 | − "metadata": { | |
| 624 | − "type": "object", | |
| 625 | − "propertyNames": { | |
| 626 | − "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$" | |
| 627 | − }, | |
| 628 | − "additionalProperties": { | |
| 629 | − "type": "string" | |
| 630 | − } | |
| 631 | − } | |
| 632 | − } | |
| 633 | − }` | |
| 634 | − | |
| 635 | − expected := `{ | |
| 636 | − "type": "object", | |
| 637 | − "properties": { | |
| 638 | − "metadata": { | |
| 639 | − "type": "object" | |
| 640 | − } | |
| 641 | − } | |
| 642 | − }` | |
| 643 | − | |
| 644 | − result := CleanJSONSchemaForGemini(input) | |
| 645 | − compareJSON(t, expected, result) | |
| 646 | − | |
| 647 | − // Verify propertyNames is completely removed | |
| 648 | − if strings.Contains(result, "propertyNames") { | |
| 649 | − t.Errorf("propertyNames keyword should be removed, got: %s", result) | |
| 650 | − } | |
| 651 | −} | |
| 652 | − | |
| 653 | −func TestCleanJSONSchemaForGemini_PropertyNamesRemoval_Nested(t *testing.T) { | |
| 654 | − // Test deeply nested propertyNames (as seen in real Claude tool schemas) | |
| 655 | − input := `{ | |
| 656 | − "type": "object", | |
| 657 | − "properties": { | |
| 658 | − "items": { | |
| 659 | − "type": "array", | |
| 660 | − "items": { | |
| 661 | − "type": "object", | |
| 662 | − "properties": { | |
| 663 | − "config": { | |
| 664 | − "type": "object", | |
| 665 | − "propertyNames": { | |
| 666 | − "type": "string" | |
| 667 | − } | |
| 668 | − } | |
| 669 | − } | |
| 670 | − } | |
| 671 | − } | |
| 672 | − } | |
| 673 | − }` | |
| 674 | − | |
| 675 | − result := CleanJSONSchemaForGemini(input) | |
| 676 | − | |
| 677 | − if strings.Contains(result, "propertyNames") { | |
| 678 | − t.Errorf("Nested propertyNames should be removed, got: %s", result) | |
| 679 | − } | |
| 680 | −} | |
| 681 | − | |
| 682 | 617 | func compareJSON(t *testing.T, expectedJSON, actualJSON string) { |
| 683 | 618 | var expMap, actMap map[string]interface{} |
| 684 | 619 | errExp := json.Unmarshal([]byte(expectedJSON), &expMap) |
| @@ -185,6 +185,11 @@ func BuildConfigChangeDetails(oldCfg, newCfg *config.Config) []string { · 184 unmodified lines | ||
| 185 | 185 | if oldCfg.AmpCode.ForceModelMappings != newCfg.AmpCode.ForceModelMappings { |
| 186 | 186 | changes = append(changes, fmt.Sprintf("ampcode.force-model-mappings: %t -> %t", oldCfg.AmpCode.ForceModelMappings, newCfg.AmpCode.ForceModelMappings)) |
| 187 | 187 | } |
| 188 | + oldUpstreamAPIKeysCount := len(oldCfg.AmpCode.UpstreamAPIKeys) | |
| 189 | + newUpstreamAPIKeysCount := len(newCfg.AmpCode.UpstreamAPIKeys) | |
| 190 | + if !equalUpstreamAPIKeys(oldCfg.AmpCode.UpstreamAPIKeys, newCfg.AmpCode.UpstreamAPIKeys) { | |
| 191 | + changes = append(changes, fmt.Sprintf("ampcode.upstream-api-keys: updated (%d -> %d entries)", oldUpstreamAPIKeysCount, newUpstreamAPIKeysCount)) | |
| 192 | + } | |
| 188 | 193 | |
| 189 | 194 | if entries, _ := DiffOAuthExcludedModelChanges(oldCfg.OAuthExcludedModels, newCfg.OAuthExcludedModels); len(entries) > 0 { |
| 190 | 195 | changes = append(changes, entries...) |
| @@ -301,3 +306,43 @@ func formatProxyURL(raw string) string { · 110 unmodified lines | ||
| 301 | 306 | } |
| 302 | 307 | return scheme + "://" + host |
| 303 | 308 | } |
| 309 | + | |
| 310 | +func equalStringSet(a, b []string) bool { | |
| 311 | + if len(a) == 0 && len(b) == 0 { | |
| 312 | + return true | |
| 313 | + } | |
| 314 | + aSet := make(map[string]struct{}, len(a)) | |
| 315 | + for _, k := range a { | |
| 316 | + aSet[strings.TrimSpace(k)] = struct{}{} | |
| 317 | + } | |
| 318 | + bSet := make(map[string]struct{}, len(b)) | |
| 319 | + for _, k := range b { | |
| 320 | + bSet[strings.TrimSpace(k)] = struct{}{} | |
| 321 | + } | |
| 322 | + if len(aSet) != len(bSet) { | |
| 323 | + return false | |
| 324 | + } | |
| 325 | + for k := range aSet { | |
| 326 | + if _, ok := bSet[k]; !ok { | |
| 327 | + return false | |
| 328 | + } | |
| 329 | + } | |
| 330 | + return true | |
| 331 | +} | |
| 332 | + | |
| 333 | +// equalUpstreamAPIKeys compares two slices of AmpUpstreamAPIKeyEntry for equality. | |
| 334 | +// Comparison is done by count and content (upstream key and client keys). | |
| 335 | +func equalUpstreamAPIKeys(a, b []config.AmpUpstreamAPIKeyEntry) bool { | |
| 336 | + if len(a) != len(b) { | |
| 337 | + return false | |
| 338 | + } | |
| 339 | + for i := range a { | |
| 340 | + if strings.TrimSpace(a[i].UpstreamAPIKey) != strings.TrimSpace(b[i].UpstreamAPIKey) { | |
| 341 | + return false | |
| 342 | + } | |
| 343 | + if !equalStringSet(a[i].APIKeys, b[i].APIKeys) { | |
| 344 | + return false | |
| 345 | + } | |
| 346 | + } | |
| 347 | + return true | |
| 348 | +} | |
| @@ -56,6 +56,10 @@ func setupAmpRouter(h *management.Handler) *gin.Engine { · 55 unmodified lines | ||
| 56 | 56 | mgmt.GET("/ampcode/upstream-api-key", h.GetAmpUpstreamAPIKey) |
| 57 | 57 | mgmt.PUT("/ampcode/upstream-api-key", h.PutAmpUpstreamAPIKey) |
| 58 | 58 | mgmt.DELETE("/ampcode/upstream-api-key", h.DeleteAmpUpstreamAPIKey) |
| 59 | + mgmt.GET("/ampcode/upstream-api-keys", h.GetAmpUpstreamAPIKeys) | |
| 60 | + mgmt.PUT("/ampcode/upstream-api-keys", h.PutAmpUpstreamAPIKeys) | |
| 61 | + mgmt.PATCH("/ampcode/upstream-api-keys", h.PatchAmpUpstreamAPIKeys) | |
| 62 | + mgmt.DELETE("/ampcode/upstream-api-keys", h.DeleteAmpUpstreamAPIKeys) | |
| 59 | 63 | mgmt.GET("/ampcode/restrict-management-to-localhost", h.GetAmpRestrictManagementToLocalhost) |
| 60 | 64 | mgmt.PUT("/ampcode/restrict-management-to-localhost", h.PutAmpRestrictManagementToLocalhost) |
| 61 | 65 | mgmt.GET("/ampcode/model-mappings", h.GetAmpModelMappings) |
| @@ -188,6 +192,90 @@ func TestPutAmpUpstreamAPIKey(t *testing.T) { · 126 unmodified lines | ||
| 188 | 192 | } |
| 189 | 193 | } |
| 190 | 194 | |
| 195 | +func TestPutAmpUpstreamAPIKeys_PersistsAndReturns(t *testing.T) { | |
| 196 | + h, configPath := newAmpTestHandler(t) | |
| 197 | + r := setupAmpRouter(h) | |
| 198 | + | |
| 199 | + body := `{"value":[{"upstream-api-key":" u1 ","api-keys":[" k1 ","","k2"]}]}` | |
| 200 | + req := httptest.NewRequest(http.MethodPut, "/v0/management/ampcode/upstream-api-keys", bytes.NewBufferString(body)) | |
| 201 | + req.Header.Set("Content-Type", "application/json") | |
| 202 | + w := httptest.NewRecorder() | |
| 203 | + r.ServeHTTP(w, req) | |
| 204 | + | |
| 205 | + if w.Code != http.StatusOK { | |
| 206 | + t.Fatalf("expected status %d, got %d: %s", http.StatusOK, w.Code, w.Body.String()) | |
| 207 | + } | |
| 208 | + | |
| 209 | + // Verify it was persisted to disk | |
| 210 | + loaded, err := config.LoadConfig(configPath) | |
| 211 | + if err != nil { | |
| 212 | + t.Fatalf("failed to load config from disk: %v", err) | |
| 213 | + } | |
| 214 | + if len(loaded.AmpCode.UpstreamAPIKeys) != 1 { | |
| 215 | + t.Fatalf("expected 1 upstream-api-keys entry, got %d", len(loaded.AmpCode.UpstreamAPIKeys)) | |
| 216 | + } | |
| 217 | + entry := loaded.AmpCode.UpstreamAPIKeys[0] | |
| 218 | + if entry.UpstreamAPIKey != "u1" { | |
| 219 | + t.Fatalf("expected upstream-api-key u1, got %q", entry.UpstreamAPIKey) | |
| 220 | + } | |
| 221 | + if len(entry.APIKeys) != 2 || entry.APIKeys[0] != "k1" || entry.APIKeys[1] != "k2" { | |
| 222 | + t.Fatalf("expected api-keys [k1 k2], got %#v", entry.APIKeys) | |
| 223 | + } | |
| 224 | + | |
| 225 | + // Verify it is returned by GET /ampcode | |
| 226 | + req = httptest.NewRequest(http.MethodGet, "/v0/management/ampcode", nil) | |
| 227 | + w = httptest.NewRecorder() | |
| 228 | + r.ServeHTTP(w, req) | |
| 229 | + if w.Code != http.StatusOK { | |
| 230 | + t.Fatalf("expected status %d, got %d", http.StatusOK, w.Code) | |
| 231 | + } | |
| 232 | + var resp map[string]config.AmpCode | |
| 233 | + if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil { | |
| 234 | + t.Fatalf("failed to unmarshal response: %v", err) | |
| 235 | + } | |
| 236 | + if got := resp["ampcode"].UpstreamAPIKeys; len(got) != 1 || got[0].UpstreamAPIKey != "u1" { | |
| 237 | + t.Fatalf("expected upstream-api-keys to be present after update, got %#v", got) | |
| 238 | + } | |
| 239 | +} | |
| 240 | + | |
| 241 | +func TestDeleteAmpUpstreamAPIKeys_ClearsAll(t *testing.T) { | |
| 242 | + h, _ := newAmpTestHandler(t) | |
| 243 | + r := setupAmpRouter(h) | |
| 244 | + | |
| 245 | + // Seed with one entry | |
| 246 | + putBody := `{"value":[{"upstream-api-key":"u1","api-keys":["k1"]}]}` | |
| 247 | + req := httptest.NewRequest(http.MethodPut, "/v0/management/ampcode/upstream-api-keys", bytes.NewBufferString(putBody)) | |
| 248 | + req.Header.Set("Content-Type", "application/json") | |
| 249 | + w := httptest.NewRecorder() | |
| 250 | + r.ServeHTTP(w, req) | |
| 251 | + if w.Code != http.StatusOK { | |
| 252 | + t.Fatalf("expected status %d, got %d: %s", http.StatusOK, w.Code, w.Body.String()) | |
| 253 | + } | |
| 254 | + | |
| 255 | + deleteBody := `{"value":[]}` | |
| 256 | + req = httptest.NewRequest(http.MethodDelete, "/v0/management/ampcode/upstream-api-keys", bytes.NewBufferString(deleteBody)) | |
| 257 | + req.Header.Set("Content-Type", "application/json") | |
| 258 | + w = httptest.NewRecorder() | |
| 259 | + r.ServeHTTP(w, req) | |
| 260 | + if w.Code != http.StatusOK { | |
| 261 | + t.Fatalf("expected status %d, got %d", http.StatusOK, w.Code) | |
| 262 | + } | |
| 263 | + | |
| 264 | + req = httptest.NewRequest(http.MethodGet, "/v0/management/ampcode/upstream-api-keys", nil) | |
| 265 | + w = httptest.NewRecorder() | |
| 266 | + r.ServeHTTP(w, req) | |
| 267 | + if w.Code != http.StatusOK { | |
| 268 | + t.Fatalf("expected status %d, got %d", http.StatusOK, w.Code) | |
| 269 | + } | |
| 270 | + var resp map[string][]config.AmpUpstreamAPIKeyEntry | |
| 271 | + if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil { | |
| 272 | + t.Fatalf("failed to unmarshal response: %v", err) | |
| 273 | + } | |
| 274 | + if resp["upstream-api-keys"] != nil && len(resp["upstream-api-keys"]) != 0 { | |
| 275 | + t.Fatalf("expected cleared list, got %#v", resp["upstream-api-keys"]) | |
| 276 | + } | |
| 277 | +} | |
| 278 | + | |
| 191 | 279 | // TestDeleteAmpUpstreamAPIKey verifies DELETE /v0/management/ampcode/upstream-api-key clears the API key. |
| 192 | 280 | func TestDeleteAmpUpstreamAPIKey(t *testing.T) { |
| 193 | 281 | h, _ := newAmpTestHandler(t) |