vvauth 2.5.0 → 2.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.github/workflows/test.yml +14 -0
- package/API_and_tests.md +144 -0
- package/README.md +87 -33
- package/SECURITY_AUDIT_fable-5.1.md +88 -0
- package/SECURITY_AUDIT_gpt-6.1-sol.md +196 -0
- package/cmd/vauth/main.go +19 -3
- package/go.mod +5 -3
- package/go.sum +12 -2
- package/index.js +146 -345
- package/package.json +7 -7
- package/rc.go +41 -148
- package/test/token-cache.js +271 -135
- package/vault.go +5 -197
- package/vauth.go +109 -228
- package/vauth_test.go +315 -111
- package/cache.go +0 -101
- package/humandiff.go +0 -50
package/vauth_test.go
CHANGED
|
@@ -18,6 +18,7 @@ import (
|
|
|
18
18
|
"time"
|
|
19
19
|
|
|
20
20
|
sshagentcrypt "github.com/131/ssh-agent-crypt"
|
|
21
|
+
vauthlogin "github.com/131/vauth-login"
|
|
21
22
|
)
|
|
22
23
|
|
|
23
24
|
const hour = 60 * 60
|
|
@@ -45,6 +46,11 @@ func TestMain(m *testing.M) {
|
|
|
45
46
|
if out, err := add.CombinedOutput(); err != nil {
|
|
46
47
|
panic(fmt.Sprintf("ssh-add: %v %s", err, out))
|
|
47
48
|
}
|
|
49
|
+
// ssh-agent-crypt falls back to these for key selection; the real user's
|
|
50
|
+
// identity is not in the throwaway agent.
|
|
51
|
+
for _, name := range []string{"SSH_AGENT_CRYPT_KEY", "VAUTH_USER_IDENTITY", "VAUTH_USER_MAIL"} {
|
|
52
|
+
os.Unsetenv(name)
|
|
53
|
+
}
|
|
48
54
|
code := m.Run()
|
|
49
55
|
exec.Command("kill", pid).Run()
|
|
50
56
|
os.RemoveAll(directory)
|
|
@@ -61,6 +67,9 @@ type fixtureOptions struct {
|
|
|
61
67
|
creationTTL *int64
|
|
62
68
|
lookupStatus int
|
|
63
69
|
renewStatus int
|
|
70
|
+
metadata map[string]any
|
|
71
|
+
database map[string]any
|
|
72
|
+
secrets map[string]any
|
|
64
73
|
}
|
|
65
74
|
|
|
66
75
|
func seconds(value float64) *float64 { return &value }
|
|
@@ -105,7 +114,18 @@ func newFixture(t *testing.T, options fixtureOptions) *fixture {
|
|
|
105
114
|
status(options.renewStatus)
|
|
106
115
|
fmt.Fprintf(w, `{"auth":{"client_token":%q,"lease_duration":%d,"renewable":true}}`, r.Header.Get("X-Vault-Token"), 24*hour)
|
|
107
116
|
case "/v1/identity/entity/id/test-entity":
|
|
108
|
-
|
|
117
|
+
json.NewEncoder(w).Encode(map[string]any{"data": map[string]any{"metadata": options.metadata}})
|
|
118
|
+
case "/v1/private/alice/data/.vauth_database":
|
|
119
|
+
if r.Method == "POST" {
|
|
120
|
+
var payload struct {
|
|
121
|
+
Data map[string]any `json:"data"`
|
|
122
|
+
}
|
|
123
|
+
json.Unmarshal(body, &payload)
|
|
124
|
+
f.options.database = payload.Data
|
|
125
|
+
}
|
|
126
|
+
json.NewEncoder(w).Encode(map[string]any{"data": map[string]any{"data": f.options.database}})
|
|
127
|
+
case "/v1/secrets/data/app":
|
|
128
|
+
json.NewEncoder(w).Encode(map[string]any{"data": map[string]any{"data": options.secrets}})
|
|
109
129
|
default:
|
|
110
130
|
w.WriteHeader(404)
|
|
111
131
|
fmt.Fprint(w, `{}`)
|
|
@@ -115,19 +135,83 @@ func newFixture(t *testing.T, options fixtureOptions) *fixture {
|
|
|
115
135
|
return f
|
|
116
136
|
}
|
|
117
137
|
|
|
118
|
-
//
|
|
119
|
-
func (
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
138
|
+
// configuredClient constructs through the public readers, using synthetic RC/env.
|
|
139
|
+
func configuredClient(t *testing.T, document map[string]any, overrides map[string]string) *Vauth {
|
|
140
|
+
t.Helper()
|
|
141
|
+
file := filepath.Join(t.TempDir(), ".vauthrc")
|
|
142
|
+
body, err := json.Marshal(document)
|
|
143
|
+
if err != nil {
|
|
144
|
+
t.Fatal(err)
|
|
145
|
+
}
|
|
146
|
+
if err := os.WriteFile(file, body, 0600); err != nil {
|
|
147
|
+
t.Fatal(err)
|
|
148
|
+
}
|
|
149
|
+
t.Setenv("VAUTHRC", file)
|
|
150
|
+
t.Setenv("VAULT_TOKEN", "")
|
|
151
|
+
t.Setenv("VAULT_ADDR", "")
|
|
152
|
+
for key, value := range overrides {
|
|
153
|
+
t.Setenv(key, value)
|
|
128
154
|
}
|
|
155
|
+
v, err := New()
|
|
156
|
+
if err != nil {
|
|
157
|
+
t.Fatal(err)
|
|
158
|
+
}
|
|
159
|
+
v.Stderr = io.Discard
|
|
160
|
+
return v
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
type clientOptions struct {
|
|
164
|
+
token string
|
|
165
|
+
rc map[string]any
|
|
166
|
+
noAuth bool
|
|
129
167
|
}
|
|
130
168
|
|
|
169
|
+
// client avoids the real user's configuration and cache.
|
|
170
|
+
func (f *fixture) client(settings ...clientOptions) *Vauth {
|
|
171
|
+
options := clientOptions{}
|
|
172
|
+
if len(settings) != 0 {
|
|
173
|
+
options = settings[0]
|
|
174
|
+
}
|
|
175
|
+
document := map[string]any{"vault_addr": f.server.URL, "jwt_auth": map[string]any{"path": "jwt", "jwt": "test-jwt", "role": "test-role"}}
|
|
176
|
+
for key, value := range options.rc {
|
|
177
|
+
document[key] = value
|
|
178
|
+
}
|
|
179
|
+
if options.noAuth {
|
|
180
|
+
delete(document, "jwt_auth")
|
|
181
|
+
}
|
|
182
|
+
v := configuredClient(f.t, document, map[string]string{"VAULT_TOKEN": options.token})
|
|
183
|
+
v.Agent = agentSocket
|
|
184
|
+
v.TokenCache = true
|
|
185
|
+
v.CacheDir = filepath.Join(f.dir, ".vauth", "tokens")
|
|
186
|
+
return v
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
// Fixture data follows the shared cache format; the application owns no cache code.
|
|
190
|
+
type tokenCache struct {
|
|
191
|
+
Token string `json:"token"`
|
|
192
|
+
LeaseDuration int64 `json:"lease_duration"`
|
|
193
|
+
Renewable bool `json:"renewable"`
|
|
194
|
+
ExpiresAt *int64 `json:"expires_at"`
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
func testCacheKey(v *Vauth) string {
|
|
198
|
+
key := `{"vault_addr":` + string(jsonString(strings.Trim(v.VAULT_ADDR(), "/")))
|
|
199
|
+
body, err := json.Marshal(v.RC())
|
|
200
|
+
if err != nil {
|
|
201
|
+
panic(err)
|
|
202
|
+
}
|
|
203
|
+
rc, err := vauthlogin.ParseRC(body, "fixture RC", v.Environ)
|
|
204
|
+
if err != nil {
|
|
205
|
+
panic(err)
|
|
206
|
+
}
|
|
207
|
+
if auth := rc.AuthKey(); auth != "" {
|
|
208
|
+
key += "," + auth
|
|
209
|
+
}
|
|
210
|
+
return sha256Hex(key + "}")
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
func cacheFile(v *Vauth) string { return filepath.Join(v.CacheDir, testCacheKey(v)+".creds") }
|
|
214
|
+
|
|
131
215
|
func (f *fixture) paths() []string {
|
|
132
216
|
var paths []string
|
|
133
217
|
for _, r := range f.requests {
|
|
@@ -138,7 +222,7 @@ func (f *fixture) paths() []string {
|
|
|
138
222
|
|
|
139
223
|
func (f *fixture) read(v *Vauth) tokenCache {
|
|
140
224
|
f.t.Helper()
|
|
141
|
-
armor, err := os.ReadFile(v
|
|
225
|
+
armor, err := os.ReadFile(cacheFile(v))
|
|
142
226
|
if err != nil {
|
|
143
227
|
f.t.Fatal(err)
|
|
144
228
|
}
|
|
@@ -155,7 +239,18 @@ func (f *fixture) read(v *Vauth) tokenCache {
|
|
|
155
239
|
|
|
156
240
|
func (f *fixture) write(v *Vauth, cache tokenCache) {
|
|
157
241
|
f.t.Helper()
|
|
158
|
-
|
|
242
|
+
body, err := json.Marshal(cache)
|
|
243
|
+
if err != nil {
|
|
244
|
+
f.t.Fatal(err)
|
|
245
|
+
}
|
|
246
|
+
armor, err := sshagentcrypt.Encrypt(body, "", &sshagentcrypt.Options{AgentSocket: agentSocket})
|
|
247
|
+
if err != nil {
|
|
248
|
+
f.t.Fatal(err)
|
|
249
|
+
}
|
|
250
|
+
if err := os.MkdirAll(v.CacheDir, 0700); err != nil {
|
|
251
|
+
f.t.Fatal(err)
|
|
252
|
+
}
|
|
253
|
+
if err := os.WriteFile(cacheFile(v), []byte(armor), 0600); err != nil {
|
|
159
254
|
f.t.Fatal(err)
|
|
160
255
|
}
|
|
161
256
|
}
|
|
@@ -173,7 +268,8 @@ func (f *fixture) remaining(v *Vauth, ttl float64) {
|
|
|
173
268
|
|
|
174
269
|
func (f *fixture) seed(v *Vauth, lease int64) {
|
|
175
270
|
renewable := f.options.renewable == nil || *f.options.renewable
|
|
176
|
-
|
|
271
|
+
expires := time.Now().UnixMilli() + lease*1000
|
|
272
|
+
f.write(v, tokenCache{Token: "cached-token", LeaseDuration: lease, Renewable: renewable, ExpiresAt: &expires})
|
|
177
273
|
if f.options.ttl != nil {
|
|
178
274
|
f.remaining(v, *f.options.ttl)
|
|
179
275
|
}
|
|
@@ -211,14 +307,14 @@ func TestLoginPersistsAndReuses(t *testing.T) {
|
|
|
211
307
|
if cache.ExpiresAt == nil || *cache.ExpiresAt < time.Now().UnixMilli()+23*hour*1000 {
|
|
212
308
|
t.Fatalf("expires_at %v", cache.ExpiresAt)
|
|
213
309
|
}
|
|
214
|
-
info, _ := os.Stat(first
|
|
310
|
+
info, _ := os.Stat(cacheFile(first))
|
|
215
311
|
equal(t, info.Mode().Perm(), 0o600)
|
|
216
|
-
info, _ = os.Stat(filepath.Dir(first
|
|
312
|
+
info, _ = os.Stat(filepath.Dir(cacheFile(first)))
|
|
217
313
|
equal(t, info.Mode().Perm(), 0o700)
|
|
218
314
|
second := f.client()
|
|
219
315
|
equal(t, connect(t, second, false), "fresh-token")
|
|
220
316
|
equalPaths(t, f.paths(), "/v1/auth/jwt/login")
|
|
221
|
-
entries, _ := os.ReadDir(filepath.Dir(first
|
|
317
|
+
entries, _ := os.ReadDir(filepath.Dir(cacheFile(first)))
|
|
222
318
|
equal(t, len(entries), 1)
|
|
223
319
|
}
|
|
224
320
|
|
|
@@ -259,7 +355,7 @@ func TestCachedTokensReusedWithoutRevocationCheck(t *testing.T) {
|
|
|
259
355
|
f.seed(v, 12*hour)
|
|
260
356
|
equal(t, connect(t, v, false), "cached-token")
|
|
261
357
|
equal(t, len(f.requests), 0)
|
|
262
|
-
if _,
|
|
358
|
+
if _, err := v.LookupSelf(v.VAULT_TOKEN()); err == nil {
|
|
263
359
|
t.Fatal("lookup should fail")
|
|
264
360
|
}
|
|
265
361
|
}
|
|
@@ -285,12 +381,11 @@ func TestRejectedRenewalTriggersLogin(t *testing.T) {
|
|
|
285
381
|
|
|
286
382
|
func TestServerFailuresDoNotGenerateTokens(t *testing.T) {
|
|
287
383
|
f := newFixture(t, fixtureOptions{lookupStatus: 500})
|
|
288
|
-
v := f.client()
|
|
384
|
+
v := f.client(clientOptions{token: "uncached-token"})
|
|
289
385
|
f.seed(v, 12*hour)
|
|
290
|
-
v.VaultToken = "uncached-token"
|
|
291
386
|
for i := 0; i < 2; i++ {
|
|
292
|
-
if _, err := v.
|
|
293
|
-
t.Fatal("
|
|
387
|
+
if _, err := v.LookupSelf(v.VAULT_TOKEN()); err == nil {
|
|
388
|
+
t.Fatal("lookup should fail")
|
|
294
389
|
}
|
|
295
390
|
}
|
|
296
391
|
equalPaths(t, f.paths(), "/v1/auth/token/lookup-self", "/v1/auth/token/lookup-self")
|
|
@@ -304,15 +399,13 @@ func TestServerFailuresDoNotGenerateTokens(t *testing.T) {
|
|
|
304
399
|
equalPaths(t, f.paths(), "/v1/auth/token/renew-self")
|
|
305
400
|
}
|
|
306
401
|
|
|
307
|
-
func
|
|
402
|
+
func TestInheritedTokenIsOfflineAndNotCached(t *testing.T) {
|
|
308
403
|
f := newFixture(t, fixtureOptions{})
|
|
309
|
-
v := f.client()
|
|
404
|
+
v := f.client(clientOptions{token: "environment-token"})
|
|
310
405
|
f.seed(v, 12*hour)
|
|
311
|
-
v.VaultToken = "environment-token"
|
|
312
406
|
equal(t, connect(t, v, false), "environment-token")
|
|
313
|
-
equal(t, f.read(v).Token, "
|
|
314
|
-
equal(t, f.requests
|
|
315
|
-
equal(t, len(f.requests), 1)
|
|
407
|
+
equal(t, f.read(v).Token, "cached-token")
|
|
408
|
+
equal(t, len(f.requests), 0)
|
|
316
409
|
}
|
|
317
410
|
|
|
318
411
|
func TestNonExpiringTokensReused(t *testing.T) {
|
|
@@ -329,8 +422,8 @@ func TestNonExpiringTokensReused(t *testing.T) {
|
|
|
329
422
|
func TestCorruptCacheReplaced(t *testing.T) {
|
|
330
423
|
f := newFixture(t, fixtureOptions{})
|
|
331
424
|
v := f.client()
|
|
332
|
-
os.MkdirAll(filepath.Dir(v
|
|
333
|
-
os.WriteFile(v
|
|
425
|
+
os.MkdirAll(filepath.Dir(cacheFile(v)), 0o700)
|
|
426
|
+
os.WriteFile(cacheFile(v), []byte("{broken"), 0o600)
|
|
334
427
|
equal(t, connect(t, v, false), "fresh-token")
|
|
335
428
|
equal(t, f.read(v).Token, "fresh-token")
|
|
336
429
|
}
|
|
@@ -338,8 +431,8 @@ func TestCorruptCacheReplaced(t *testing.T) {
|
|
|
338
431
|
func TestPlaintextCacheNotAccepted(t *testing.T) {
|
|
339
432
|
f := newFixture(t, fixtureOptions{})
|
|
340
433
|
v := f.client()
|
|
341
|
-
os.MkdirAll(filepath.Dir(v
|
|
342
|
-
os.WriteFile(v
|
|
434
|
+
os.MkdirAll(filepath.Dir(cacheFile(v)), 0o700)
|
|
435
|
+
os.WriteFile(cacheFile(v), []byte(`{"token":"plain-token","lease_duration":43200,"renewable":true,"expires_at":null}`), 0o600)
|
|
343
436
|
equal(t, connect(t, v, false), "fresh-token")
|
|
344
437
|
equalPaths(t, f.paths(), "/v1/auth/jwt/login")
|
|
345
438
|
}
|
|
@@ -348,40 +441,32 @@ func TestCacheIsolation(t *testing.T) {
|
|
|
348
441
|
f := newFixture(t, fixtureOptions{})
|
|
349
442
|
first := f.client()
|
|
350
443
|
f.seed(first, 12*hour)
|
|
351
|
-
second := f.client()
|
|
352
|
-
second.RC.JWTAuth.Role = "other-role"
|
|
444
|
+
second := f.client(clientOptions{rc: map[string]any{"jwt_auth": map[string]any{"path": "jwt", "jwt": "test-jwt", "role": "other-role"}}})
|
|
353
445
|
equal(t, connect(t, second, false), "fresh-token")
|
|
354
|
-
if first
|
|
446
|
+
if cacheFile(first) == cacheFile(second) {
|
|
355
447
|
t.Fatal("cache files should differ")
|
|
356
448
|
}
|
|
357
449
|
equal(t, f.read(first).Token, "cached-token")
|
|
358
450
|
equal(t, f.read(second).Token, "fresh-token")
|
|
359
|
-
third := f.client()
|
|
360
|
-
third
|
|
361
|
-
if third.TokenCacheKey() == first.TokenCacheKey() {
|
|
451
|
+
third := f.client(clientOptions{rc: map[string]any{"vault_addr": "http://other-vault.test"}})
|
|
452
|
+
if testCacheKey(third) == testCacheKey(first) {
|
|
362
453
|
t.Fatal("cache keys should differ")
|
|
363
454
|
}
|
|
364
|
-
entries, _ := os.ReadDir(filepath.Dir(first
|
|
455
|
+
entries, _ := os.ReadDir(filepath.Dir(cacheFile(first)))
|
|
365
456
|
equal(t, len(entries), 2)
|
|
366
|
-
armor, _ := os.ReadFile(first
|
|
457
|
+
armor, _ := os.ReadFile(cacheFile(first))
|
|
367
458
|
if bytes.Contains(armor, []byte("test-jwt")) || bytes.Contains(armor, []byte("cached-token")) {
|
|
368
459
|
t.Fatal("cache leaks secrets")
|
|
369
460
|
}
|
|
370
461
|
}
|
|
371
462
|
|
|
372
463
|
func TestTokenCacheKeyMatchesNode(t *testing.T) {
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
v
|
|
376
|
-
equal(t, v
|
|
377
|
-
v =
|
|
378
|
-
equal(t, v
|
|
379
|
-
rc, err := ParseRC([]byte("vault_addr: https://vault.example.test\nssh_auth:\n role: $${env.USER}\n"), ".vauthrc", map[string]string{"USER": "bob"})
|
|
380
|
-
if err != nil {
|
|
381
|
-
t.Fatal(err)
|
|
382
|
-
}
|
|
383
|
-
v = &Vauth{VaultAddr: rc.VaultAddr, RC: *rc}
|
|
384
|
-
equal(t, v.TokenCacheKey(), sha256Hex(`{"vault_addr":"https://vault.example.test","ssh_auth":{"role":"bob"}}`))
|
|
464
|
+
v := configuredClient(t, map[string]any{"vault_addr": "https://vault.example.test/", "ssh_auth": map[string]any{"role": "alice"}}, nil)
|
|
465
|
+
equal(t, testCacheKey(v), sha256Hex(`{"vault_addr":"https://vault.example.test","ssh_auth":{"role":"alice"}}`))
|
|
466
|
+
v = configuredClient(t, map[string]any{"vault_addr": "https://vault.example.test", "jwt_auth": map[string]any{"path": "jwt", "jwt": "x", "role": "r"}}, nil)
|
|
467
|
+
equal(t, testCacheKey(v), sha256Hex(`{"vault_addr":"https://vault.example.test","jwt_auth":{"jwt":"x","path":"jwt","role":"r"}}`))
|
|
468
|
+
v = configuredClient(t, map[string]any{"vault_addr": "https://vault.example.test", "ssh_auth": map[string]any{"role": "$${env.USER}"}}, map[string]string{"USER": "bob"})
|
|
469
|
+
equal(t, testCacheKey(v), sha256Hex(`{"vault_addr":"https://vault.example.test","ssh_auth":{"role":"bob"}}`))
|
|
385
470
|
}
|
|
386
471
|
|
|
387
472
|
func TestRepeatedConnectReusesConnection(t *testing.T) {
|
|
@@ -395,8 +480,8 @@ func TestRepeatedConnectReusesConnection(t *testing.T) {
|
|
|
395
480
|
func TestUnwritableCacheDoesNotPreventLogin(t *testing.T) {
|
|
396
481
|
f := newFixture(t, fixtureOptions{})
|
|
397
482
|
v := f.client()
|
|
398
|
-
os.MkdirAll(filepath.Dir(filepath.Dir(v
|
|
399
|
-
os.WriteFile(filepath.Dir(v
|
|
483
|
+
os.MkdirAll(filepath.Dir(filepath.Dir(cacheFile(v))), 0o700)
|
|
484
|
+
os.WriteFile(filepath.Dir(cacheFile(v)), []byte("not a directory"), 0o600)
|
|
400
485
|
var stderr bytes.Buffer
|
|
401
486
|
v.Stderr = &stderr
|
|
402
487
|
equal(t, connect(t, v, false), "fresh-token")
|
|
@@ -405,23 +490,20 @@ func TestUnwritableCacheDoesNotPreventLogin(t *testing.T) {
|
|
|
405
490
|
}
|
|
406
491
|
}
|
|
407
492
|
|
|
408
|
-
func
|
|
493
|
+
func TestWithoutAuthMethodInheritanceStillWorks(t *testing.T) {
|
|
409
494
|
f := newFixture(t, fixtureOptions{lookupStatus: 403})
|
|
410
|
-
v := f.client()
|
|
495
|
+
v := f.client(clientOptions{token: "uncached-token", noAuth: true})
|
|
411
496
|
f.seed(v, 12*hour)
|
|
412
|
-
v
|
|
413
|
-
v.
|
|
414
|
-
equal(t, connect(t, v, false), "")
|
|
415
|
-
equal(t, v.VaultToken, "")
|
|
497
|
+
equal(t, connect(t, v, false), "uncached-token")
|
|
498
|
+
equal(t, v.VAULT_TOKEN(), "uncached-token")
|
|
416
499
|
equal(t, connect(t, v, true), "")
|
|
417
500
|
equal(t, len(f.requests), 0)
|
|
418
501
|
}
|
|
419
502
|
|
|
420
503
|
func TestRenewIgnoresTokensAndSaves(t *testing.T) {
|
|
421
504
|
f := newFixture(t, fixtureOptions{})
|
|
422
|
-
v := f.client()
|
|
505
|
+
v := f.client(clientOptions{token: "environment-token"})
|
|
423
506
|
f.seed(v, 12*hour)
|
|
424
|
-
v.VaultToken = "environment-token"
|
|
425
507
|
equal(t, connect(t, v, true), "fresh-token")
|
|
426
508
|
equalPaths(t, f.paths(), "/v1/auth/jwt/login")
|
|
427
509
|
equal(t, f.read(v).Token, "fresh-token")
|
|
@@ -488,17 +570,16 @@ func TestRenewalUpdatesLeaseBaseline(t *testing.T) {
|
|
|
488
570
|
|
|
489
571
|
func TestNormalReuseNeverWrites(t *testing.T) {
|
|
490
572
|
f := newFixture(t, fixtureOptions{})
|
|
491
|
-
v := f.client()
|
|
573
|
+
v := f.client(clientOptions{token: "cached-token"})
|
|
492
574
|
f.seed(v, 12*hour)
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
stat, _ := os.Stat(v.TokenCacheFile())
|
|
575
|
+
before, _ := os.ReadFile(cacheFile(v))
|
|
576
|
+
stat, _ := os.Stat(cacheFile(v))
|
|
496
577
|
equal(t, connect(t, v, false), "cached-token")
|
|
497
|
-
after, _ := os.ReadFile(v
|
|
578
|
+
after, _ := os.ReadFile(cacheFile(v))
|
|
498
579
|
if !bytes.Equal(before, after) {
|
|
499
580
|
t.Fatal("cache rewritten")
|
|
500
581
|
}
|
|
501
|
-
again, _ := os.Stat(v
|
|
582
|
+
again, _ := os.Stat(cacheFile(v))
|
|
502
583
|
equal(t, again.ModTime(), stat.ModTime())
|
|
503
584
|
equal(t, len(f.requests), 0)
|
|
504
585
|
}
|
|
@@ -506,11 +587,11 @@ func TestNormalReuseNeverWrites(t *testing.T) {
|
|
|
506
587
|
func TestLookupReturnsLease(t *testing.T) {
|
|
507
588
|
f := newFixture(t, fixtureOptions{ttl: seconds(hour)})
|
|
508
589
|
v := f.client()
|
|
509
|
-
info,
|
|
590
|
+
info, err := v.LookupSelf("environment-token")
|
|
510
591
|
if err != nil {
|
|
511
592
|
t.Fatal(err)
|
|
512
593
|
}
|
|
513
|
-
equal(t,
|
|
594
|
+
equal(t, info.LeaseDuration, 24*hour)
|
|
514
595
|
equal(t, info.TTL, float64(hour))
|
|
515
596
|
equal(t, len(f.requests), 1)
|
|
516
597
|
}
|
|
@@ -520,7 +601,7 @@ func TestTokenCacheDisabled(t *testing.T) {
|
|
|
520
601
|
v := f.client()
|
|
521
602
|
v.TokenCache = false
|
|
522
603
|
equal(t, connect(t, v, false), "fresh-token")
|
|
523
|
-
if _, err := os.Stat(v
|
|
604
|
+
if _, err := os.Stat(cacheFile(v)); err == nil {
|
|
524
605
|
t.Fatal("cache written")
|
|
525
606
|
}
|
|
526
607
|
equalPaths(t, f.paths(), "/v1/auth/jwt/login")
|
|
@@ -528,27 +609,26 @@ func TestTokenCacheDisabled(t *testing.T) {
|
|
|
528
609
|
f = newFixture(t, fixtureOptions{})
|
|
529
610
|
v = f.client()
|
|
530
611
|
f.seed(v, 12*hour)
|
|
531
|
-
before, _ := os.ReadFile(v
|
|
612
|
+
before, _ := os.ReadFile(cacheFile(v))
|
|
532
613
|
v.TokenCache = false
|
|
533
614
|
equal(t, connect(t, v, false), "fresh-token")
|
|
534
|
-
after, _ := os.ReadFile(v
|
|
615
|
+
after, _ := os.ReadFile(cacheFile(v))
|
|
535
616
|
if !bytes.Equal(before, after) {
|
|
536
617
|
t.Fatal("disabled cache touched disk")
|
|
537
618
|
}
|
|
538
619
|
|
|
539
620
|
f = newFixture(t, fixtureOptions{})
|
|
540
|
-
v = f.client()
|
|
621
|
+
v = f.client(clientOptions{token: "environment-token"})
|
|
541
622
|
v.TokenCache = false
|
|
542
|
-
v.VaultToken = "environment-token"
|
|
543
623
|
equal(t, connect(t, v, false), "environment-token")
|
|
544
|
-
|
|
545
|
-
if _, err := os.Stat(v
|
|
624
|
+
equal(t, len(f.requests), 0)
|
|
625
|
+
if _, err := os.Stat(cacheFile(v)); err == nil {
|
|
546
626
|
t.Fatal("cache written")
|
|
547
627
|
}
|
|
548
628
|
}
|
|
549
629
|
|
|
550
630
|
func TestTokenCacheFalseFromRC(t *testing.T) {
|
|
551
|
-
rc, err := ParseRC([]byte("vault_addr: https://vault.example.test\ntoken_cache: false\n"), ".vauthrc", map[string]string{})
|
|
631
|
+
rc, err := vauthlogin.ParseRC([]byte("vault_addr: https://vault.example.test\ntoken_cache: false\n"), ".vauthrc", map[string]string{})
|
|
552
632
|
if err != nil {
|
|
553
633
|
t.Fatal(err)
|
|
554
634
|
}
|
|
@@ -561,7 +641,7 @@ func TestCacheIsArmorOnly(t *testing.T) {
|
|
|
561
641
|
f := newFixture(t, fixtureOptions{})
|
|
562
642
|
v := f.client()
|
|
563
643
|
connect(t, v, false)
|
|
564
|
-
armor, _ := os.ReadFile(v
|
|
644
|
+
armor, _ := os.ReadFile(cacheFile(v))
|
|
565
645
|
if !bytes.HasPrefix(armor, []byte("ssh-agent-crypt:")) || bytes.Contains(armor, []byte("fresh-token")) {
|
|
566
646
|
t.Fatalf("not armored: %q", armor[:40])
|
|
567
647
|
}
|
|
@@ -583,37 +663,16 @@ func TestWithoutAgentCacheSkipped(t *testing.T) {
|
|
|
583
663
|
f := newFixture(t, fixtureOptions{})
|
|
584
664
|
v := f.client()
|
|
585
665
|
f.seed(v, 12*hour)
|
|
586
|
-
before, _ := os.ReadFile(v
|
|
666
|
+
before, _ := os.ReadFile(cacheFile(v))
|
|
587
667
|
v.Agent = ""
|
|
588
668
|
v.TokenCache = false // as New() does when no agent is configured
|
|
589
669
|
equal(t, connect(t, v, false), "fresh-token")
|
|
590
|
-
after, _ := os.ReadFile(v
|
|
670
|
+
after, _ := os.ReadFile(cacheFile(v))
|
|
591
671
|
if !bytes.Equal(before, after) {
|
|
592
672
|
t.Fatal("existing armor touched")
|
|
593
673
|
}
|
|
594
674
|
}
|
|
595
675
|
|
|
596
|
-
func TestTokenStatus(t *testing.T) {
|
|
597
|
-
v := &Vauth{VaultAddr: "https://vault.example.test"}
|
|
598
|
-
for _, c := range []struct {
|
|
599
|
-
ttl float64
|
|
600
|
-
duration string
|
|
601
|
-
}{
|
|
602
|
-
{2*86400 + 3*hour + 20*60 + 5, "2d 3h"}, {12*hour + 30*60 + 5, "12h 30m"}, {5*60 + 20, "5m 20s"},
|
|
603
|
-
{86400, "1d"}, {30 * 60, "30m"}, {45, "45s"}, {86400 + 20, "1d 20s"}, {hour + 5, "1h 5s"},
|
|
604
|
-
{400*86400 + 2*hour, "1y 1month"}, {60.9, "1m 1s"},
|
|
605
|
-
} {
|
|
606
|
-
var stderr bytes.Buffer
|
|
607
|
-
v.Stderr = &stderr
|
|
608
|
-
v.tokenStatus("reused", &token{TTL: c.ttl})
|
|
609
|
-
equal(t, stderr.String(), "Vauth token: reused · https://vault.example.test · "+c.duration+"\n")
|
|
610
|
-
}
|
|
611
|
-
var stderr bytes.Buffer
|
|
612
|
-
v.Stderr = &stderr
|
|
613
|
-
v.tokenStatus("generated", &token{})
|
|
614
|
-
equal(t, stderr.String(), "Vauth token: generated · https://vault.example.test · valid indefinitely\n")
|
|
615
|
-
}
|
|
616
|
-
|
|
617
676
|
func TestOneStatusPerConnection(t *testing.T) {
|
|
618
677
|
for _, c := range []struct {
|
|
619
678
|
options fixtureOptions
|
|
@@ -631,11 +690,11 @@ func TestOneStatusPerConnection(t *testing.T) {
|
|
|
631
690
|
var stderr bytes.Buffer
|
|
632
691
|
v.Stderr = &stderr
|
|
633
692
|
connect(t, v, false)
|
|
634
|
-
equal(t, stderr.String(), fmt.Sprintf("Vauth token: %s · %s
|
|
693
|
+
equal(t, stderr.String(), fmt.Sprintf("Vauth token: %s · %s\n", c.operation, c.duration))
|
|
635
694
|
}
|
|
636
|
-
f := newFixture(t, fixtureOptions{
|
|
695
|
+
f := newFixture(t, fixtureOptions{ttl: seconds(hour), renewStatus: 500})
|
|
637
696
|
v := f.client()
|
|
638
|
-
v
|
|
697
|
+
f.seed(v, 12*hour)
|
|
639
698
|
var stderr bytes.Buffer
|
|
640
699
|
v.Stderr = &stderr
|
|
641
700
|
if _, err := v.Connect(false); err == nil {
|
|
@@ -652,13 +711,158 @@ func TestReplaceEnv(t *testing.T) {
|
|
|
652
711
|
equal(t, ReplaceEnv("plain", dict), "plain")
|
|
653
712
|
}
|
|
654
713
|
|
|
655
|
-
func TestHumanDiff(t *testing.T) {
|
|
656
|
-
equal(t, HumanDiff(0, 2), "0s")
|
|
657
|
-
equal(t, HumanDiff(59, 2), "59s")
|
|
658
|
-
equal(t, HumanDiff(3600*24*31, 2), "1month 1d")
|
|
659
|
-
}
|
|
660
|
-
|
|
661
714
|
func sha256Hex(value string) string {
|
|
662
715
|
digest := sha256.Sum256([]byte(value))
|
|
663
716
|
return hex.EncodeToString(digest[:])
|
|
664
717
|
}
|
|
718
|
+
|
|
719
|
+
func TestEnvMapKeysMustBeVariableNames(t *testing.T) {
|
|
720
|
+
f := newFixture(t, fixtureOptions{})
|
|
721
|
+
v := f.client()
|
|
722
|
+
v.Config.Env = &EnvConfig{}
|
|
723
|
+
v.Config.Env.Map.Set("SAFE; printf INJECTED >&2; #", "dummy")
|
|
724
|
+
if _, err := v.Env(false); err == nil || !strings.Contains(err.Error(), "Invalid environment variable name") {
|
|
725
|
+
t.Fatalf("hostile env.map key accepted: %v", err)
|
|
726
|
+
}
|
|
727
|
+
v.Config.Env = &EnvConfig{}
|
|
728
|
+
v.Config.Env.Map.Set("TF_HTTP_USERNAME", "$${profile.VAUTH_USER_LOGIN}")
|
|
729
|
+
if _, err := v.Env(false); err != nil {
|
|
730
|
+
t.Fatal(err)
|
|
731
|
+
}
|
|
732
|
+
}
|
|
733
|
+
|
|
734
|
+
func TestCheckProjectVersion(t *testing.T) {
|
|
735
|
+
dir := t.TempDir()
|
|
736
|
+
manifest := filepath.Join(dir, "package.json")
|
|
737
|
+
write := func(body string) { os.WriteFile(manifest, []byte(body), 0o644) }
|
|
738
|
+
write(`{"dependencies":{"vvauth":"^2.5.0","yaml":"^2"}}`)
|
|
739
|
+
if err := CheckProjectVersion(manifest, "v2.7.1"); err != nil {
|
|
740
|
+
t.Fatal(err)
|
|
741
|
+
}
|
|
742
|
+
if err := CheckProjectVersion(manifest, "v3.0.0"); err == nil || !strings.Contains(err.Error(), "project requires ^2.5.0") {
|
|
743
|
+
t.Fatalf("v3 accepted by ^2.5.0: %v", err)
|
|
744
|
+
}
|
|
745
|
+
if err := CheckProjectVersion(manifest, "(devel)"); err != nil {
|
|
746
|
+
t.Fatal("devel builds must not be checked:", err)
|
|
747
|
+
}
|
|
748
|
+
write(`{"dependencies":{"yaml":"^2"}}`)
|
|
749
|
+
if err := CheckProjectVersion(manifest, "v0.0.1"); err != nil {
|
|
750
|
+
t.Fatal("unrelated dependencies must be ignored:", err)
|
|
751
|
+
}
|
|
752
|
+
if err := CheckProjectVersion(filepath.Join(dir, "missing.json"), "v1.0.0"); err != nil {
|
|
753
|
+
t.Fatal(err)
|
|
754
|
+
}
|
|
755
|
+
}
|
|
756
|
+
|
|
757
|
+
func TestProfileKVAndEnvironmentUseLoginTransport(t *testing.T) {
|
|
758
|
+
f := newFixture(t, fixtureOptions{
|
|
759
|
+
metadata: map[string]any{"VAUTH_USER_LOGIN": "alice", "VAUTH_USER_NAME": "Alice", "VAUTH_USER_MAIL": "alice@example.test"},
|
|
760
|
+
database: map[string]any{"TEAM": "ops"}, secrets: map[string]any{"API_KEY": "fixture-secret"},
|
|
761
|
+
})
|
|
762
|
+
v := f.client()
|
|
763
|
+
v.Config.Env = &EnvConfig{Git: true, Paths: []string{"app"}}
|
|
764
|
+
v.Config.Env.Map.Set("LOGIN", "$${profile.VAUTH_USER_LOGIN}")
|
|
765
|
+
v.Config.Env.Map.Set("TEAM", "$${profile.TEAM}")
|
|
766
|
+
v.Config.Env.Map.Set("API_KEY", "$${secrets.API_KEY}")
|
|
767
|
+
env, err := v.Env(true)
|
|
768
|
+
if err != nil {
|
|
769
|
+
t.Fatal(err)
|
|
770
|
+
}
|
|
771
|
+
for key, want := range map[string]string{"VAULT_TOKEN": "fresh-token", "LOGIN": "alice", "TEAM": "ops", "API_KEY": "fixture-secret", "GIT_AUTHOR_NAME": "Alice"} {
|
|
772
|
+
value, ok := env.Get(key)
|
|
773
|
+
if !ok {
|
|
774
|
+
t.Fatalf("missing %s", key)
|
|
775
|
+
}
|
|
776
|
+
equal(t, value, want)
|
|
777
|
+
}
|
|
778
|
+
equalPaths(t, f.paths(), "/v1/auth/jwt/login", "/v1/auth/token/lookup-self", "/v1/identity/entity/id/test-entity", "/v1/private/alice/data/.vauth_database", "/v1/secrets/data/app")
|
|
779
|
+
for _, r := range f.requests[1:] {
|
|
780
|
+
equal(t, r.Token, "fresh-token")
|
|
781
|
+
}
|
|
782
|
+
if err := v.Set("feature", "enabled"); err != nil {
|
|
783
|
+
t.Fatal(err)
|
|
784
|
+
}
|
|
785
|
+
equal(t, f.options.database["FEATURE"], "enabled")
|
|
786
|
+
if err := v.Unset("feature"); err != nil {
|
|
787
|
+
t.Fatal(err)
|
|
788
|
+
}
|
|
789
|
+
if _, ok := f.options.database["FEATURE"]; ok {
|
|
790
|
+
t.Fatal("unset key retained")
|
|
791
|
+
}
|
|
792
|
+
logins := 0
|
|
793
|
+
for _, r := range f.requests {
|
|
794
|
+
if strings.HasSuffix(r.Path, "/login") {
|
|
795
|
+
logins++
|
|
796
|
+
}
|
|
797
|
+
}
|
|
798
|
+
equal(t, logins, 1)
|
|
799
|
+
}
|
|
800
|
+
|
|
801
|
+
func TestEnvironmentConfigIsSeparateFromAuthentication(t *testing.T) {
|
|
802
|
+
config, err := ParseConfig([]byte(`jwt_auth: ignored
|
|
803
|
+
env: {map: {LOGIN: '$${env.LOGIN}'}}
|
|
804
|
+
ssh-agent-crypt: {path: '$${env.FILE}'}
|
|
805
|
+
`), ".vauthrc", map[string]string{"LOGIN": "alice", "FILE": "fixture.creds"})
|
|
806
|
+
if err != nil {
|
|
807
|
+
t.Fatal(err)
|
|
808
|
+
}
|
|
809
|
+
value, _ := config.Env.Map.Get("LOGIN")
|
|
810
|
+
equal(t, value, "alice")
|
|
811
|
+
equal(t, config.AgentCrypt.Path, "fixture.creds")
|
|
812
|
+
}
|
|
813
|
+
|
|
814
|
+
func TestNewConsumesCompleteRCSnapshot(t *testing.T) {
|
|
815
|
+
document := map[string]any{
|
|
816
|
+
"env": map[string]any{"map": map[string]any{"VALUE": "$${env.LOCAL_VALUE}", "USER": "$${profile.USER}"}},
|
|
817
|
+
"extra": map[string]any{"nested": []any{"retained"}},
|
|
818
|
+
}
|
|
819
|
+
v := configuredClient(t, document, map[string]string{"LOCAL_VALUE": "local-value", "VAULT_ADDR": "https://vault.example.test"})
|
|
820
|
+
value, _ := v.Config.Env.Map.Get("VALUE")
|
|
821
|
+
equal(t, value, "local-value")
|
|
822
|
+
value, _ = v.Config.Env.Map.Get("USER")
|
|
823
|
+
equal(t, value, "$${profile.USER}")
|
|
824
|
+
v.Config.Env.Map.Set("VALUE", "consumer-value")
|
|
825
|
+
equal(t, v.RC()["env"].(map[string]any)["map"].(map[string]any)["VALUE"], "$${env.LOCAL_VALUE}")
|
|
826
|
+
if _, ok := v.RC()["extra"]; !ok {
|
|
827
|
+
t.Fatal("complete RC section lost")
|
|
828
|
+
}
|
|
829
|
+
if err := os.Remove(os.Getenv("VAUTHRC")); err != nil {
|
|
830
|
+
t.Fatal(err)
|
|
831
|
+
}
|
|
832
|
+
config, err := configFromRC(v.RC(), ".", v.Environ)
|
|
833
|
+
if err != nil {
|
|
834
|
+
t.Fatal(err)
|
|
835
|
+
}
|
|
836
|
+
value, _ = config.Env.Map.Get("VALUE")
|
|
837
|
+
equal(t, value, "local-value")
|
|
838
|
+
}
|
|
839
|
+
|
|
840
|
+
func TestGitLabUsesWorkingProjectWithExternalRC(t *testing.T) {
|
|
841
|
+
project := t.TempDir()
|
|
842
|
+
for _, args := range [][]string{{"init", "-q", project}, {"-C", project, "remote", "add", "origin", "git@git.example.test:Team/app.git"}} {
|
|
843
|
+
if out, err := exec.Command("git", args...).CombinedOutput(); err != nil {
|
|
844
|
+
t.Fatalf("git: %v %s", err, out)
|
|
845
|
+
}
|
|
846
|
+
}
|
|
847
|
+
cwd, err := os.Getwd()
|
|
848
|
+
if err != nil {
|
|
849
|
+
t.Fatal(err)
|
|
850
|
+
}
|
|
851
|
+
if err := os.Chdir(project); err != nil {
|
|
852
|
+
t.Fatal(err)
|
|
853
|
+
}
|
|
854
|
+
t.Cleanup(func() {
|
|
855
|
+
if err := os.Chdir(cwd); err != nil {
|
|
856
|
+
t.Error(err)
|
|
857
|
+
}
|
|
858
|
+
})
|
|
859
|
+
for _, ci := range []string{"", "1"} {
|
|
860
|
+
v := configuredClient(t, map[string]any{"env": map[string]any{"gitlab": true, "map": map[string]any{"PROJECT": "$${env.CI_PROJECT_PATH}"}}}, map[string]string{"CI": ci, "CI_PROJECT_PATH": "pipeline/project"})
|
|
861
|
+
want := "Team/app"
|
|
862
|
+
if ci != "" {
|
|
863
|
+
want = "pipeline/project"
|
|
864
|
+
}
|
|
865
|
+
value, _ := v.Config.Env.Map.Get("PROJECT")
|
|
866
|
+
equal(t, value, want)
|
|
867
|
+
}
|
|
868
|
+
}
|