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/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
- fmt.Fprint(w, `{"data":{"metadata":{}}}`)
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
- // client avoids the real user's environment, configuration and cache.
119
- func (f *fixture) client() *Vauth {
120
- return &Vauth{
121
- RC: RC{JWTAuth: &JWTAuth{Path: "jwt", JWT: "test-jwt", Role: "test-role"}},
122
- VaultAddr: f.server.URL,
123
- Agent: agentSocket,
124
- TokenCache: true,
125
- CacheDir: filepath.Join(f.dir, ".vauth", "tokens"),
126
- Environ: map[string]string{},
127
- Stderr: io.Discard,
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.TokenCacheFile())
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
- if err := v.writeTokenCache(v.TokenCacheFile(), v.TokenCacheFile()+".next", &cache); err != nil {
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
- v.saveTokenCache(&token{Value: "cached-token", TTL: float64(lease), LeaseDuration: lease, Renewable: renewable})
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.TokenCacheFile())
310
+ info, _ := os.Stat(cacheFile(first))
215
311
  equal(t, info.Mode().Perm(), 0o600)
216
- info, _ = os.Stat(filepath.Dir(first.TokenCacheFile()))
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.TokenCacheFile()))
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 _, _, err := v.lookupToken(v.VaultToken); err == nil {
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.Connect(false); err == nil {
293
- t.Fatal("connect should fail")
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 TestEnvironmentTokenRespectedAndCached(t *testing.T) {
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, "environment-token")
314
- equal(t, f.requests[0].Token, "environment-token")
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.TokenCacheFile()), 0o700)
333
- os.WriteFile(v.TokenCacheFile(), []byte("{broken"), 0o600)
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.TokenCacheFile()), 0o700)
342
- os.WriteFile(v.TokenCacheFile(), []byte(`{"token":"plain-token","lease_duration":43200,"renewable":true,"expires_at":null}`), 0o600)
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.TokenCacheFile() == second.TokenCacheFile() {
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.VaultAddr = "http://other-vault.test"
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.TokenCacheFile()))
455
+ entries, _ := os.ReadDir(filepath.Dir(cacheFile(first)))
365
456
  equal(t, len(entries), 2)
366
- armor, _ := os.ReadFile(first.TokenCacheFile())
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
- // sha256 of JSON.stringify({vault_addr, ssh_auth, jwt_auth}) as the Node
374
- // implementation renders it (undefined members omitted).
375
- v := &Vauth{VaultAddr: "https://vault.example.test/", RC: RC{SSHAuth: &SSHAuth{Role: "alice"}}}
376
- equal(t, v.TokenCacheKey(), sha256Hex(`{"vault_addr":"https://vault.example.test","ssh_auth":{"role":"alice"}}`))
377
- v = &Vauth{VaultAddr: "https://vault.example.test", RC: RC{JWTAuth: &JWTAuth{Path: "jwt", JWT: "x", Role: "r"}}}
378
- equal(t, v.TokenCacheKey(), sha256Hex(`{"vault_addr":"https://vault.example.test","jwt_auth":{"path":"jwt","jwt":"x","role":"r"}}`))
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.TokenCacheFile())), 0o700)
399
- os.WriteFile(filepath.Dir(v.TokenCacheFile()), []byte("not a directory"), 0o600)
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 TestWithoutAuthMethodTokensIgnored(t *testing.T) {
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.RC = RC{}
413
- v.VaultToken = "uncached-token"
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
- v.VaultToken = "cached-token"
494
- before, _ := os.ReadFile(v.TokenCacheFile())
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.TokenCacheFile())
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.TokenCacheFile())
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, lease, err := v.lookupToken("environment-token")
590
+ info, err := v.LookupSelf("environment-token")
510
591
  if err != nil {
511
592
  t.Fatal(err)
512
593
  }
513
- equal(t, lease, 24*hour)
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.TokenCacheFile()); err == nil {
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.TokenCacheFile())
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.TokenCacheFile())
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
- equalPaths(t, f.paths(), "/v1/auth/token/lookup-self")
545
- if _, err := os.Stat(v.TokenCacheFile()); err == nil {
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.TokenCacheFile())
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.TokenCacheFile())
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.TokenCacheFile())
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 · %s\n", c.operation, f.server.URL, c.duration))
693
+ equal(t, stderr.String(), fmt.Sprintf("Vauth token: %s · %s\n", c.operation, c.duration))
635
694
  }
636
- f := newFixture(t, fixtureOptions{lookupStatus: 500})
695
+ f := newFixture(t, fixtureOptions{ttl: seconds(hour), renewStatus: 500})
637
696
  v := f.client()
638
- v.VaultToken = "uncached-token"
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
+ }