vvauth 2.4.1 → 2.5.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 ADDED
@@ -0,0 +1,664 @@
1
+ package vvauth
2
+
3
+ import (
4
+ "bytes"
5
+ "crypto/sha256"
6
+ "encoding/hex"
7
+ "encoding/json"
8
+ "fmt"
9
+ "io"
10
+ "net/http"
11
+ "net/http/httptest"
12
+ "os"
13
+ "os/exec"
14
+ "path/filepath"
15
+ "regexp"
16
+ "strings"
17
+ "testing"
18
+ "time"
19
+
20
+ sshagentcrypt "github.com/131/ssh-agent-crypt"
21
+ )
22
+
23
+ const hour = 60 * 60
24
+
25
+ // agentSocket is a throwaway ssh-agent holding one ed25519 key.
26
+ var agentSocket string
27
+
28
+ func TestMain(m *testing.M) {
29
+ directory, err := os.MkdirTemp("", "vvauth-agent-")
30
+ if err != nil {
31
+ panic(err)
32
+ }
33
+ key := filepath.Join(directory, "key")
34
+ if out, err := exec.Command("ssh-keygen", "-q", "-t", "ed25519", "-N", "", "-f", key).CombinedOutput(); err != nil {
35
+ panic(fmt.Sprintf("ssh-keygen: %v %s", err, out))
36
+ }
37
+ out, err := exec.Command("ssh-agent", "-s").Output()
38
+ if err != nil {
39
+ panic(err)
40
+ }
41
+ agentSocket = regexp.MustCompile(`SSH_AUTH_SOCK=([^;]+)`).FindStringSubmatch(string(out))[1]
42
+ pid := regexp.MustCompile(`SSH_AGENT_PID=(\d+)`).FindStringSubmatch(string(out))[1]
43
+ add := exec.Command("ssh-add", key)
44
+ add.Env = append(os.Environ(), "SSH_AUTH_SOCK="+agentSocket)
45
+ if out, err := add.CombinedOutput(); err != nil {
46
+ panic(fmt.Sprintf("ssh-add: %v %s", err, out))
47
+ }
48
+ code := m.Run()
49
+ exec.Command("kill", pid).Run()
50
+ os.RemoveAll(directory)
51
+ os.Exit(code)
52
+ }
53
+
54
+ type request struct {
55
+ Path, Method, Token, Body string
56
+ }
57
+
58
+ type fixtureOptions struct {
59
+ ttl *float64
60
+ renewable *bool
61
+ creationTTL *int64
62
+ lookupStatus int
63
+ renewStatus int
64
+ }
65
+
66
+ func seconds(value float64) *float64 { return &value }
67
+ func boolean(value bool) *bool { return &value }
68
+
69
+ type fixture struct {
70
+ t *testing.T
71
+ server *httptest.Server
72
+ dir string
73
+ requests []request
74
+ options fixtureOptions
75
+ }
76
+
77
+ func newFixture(t *testing.T, options fixtureOptions) *fixture {
78
+ f := &fixture{t: t, dir: t.TempDir(), options: options}
79
+ f.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
80
+ body, _ := io.ReadAll(r.Body)
81
+ f.requests = append(f.requests, request{r.URL.Path, r.Method, r.Header.Get("X-Vault-Token"), string(body)})
82
+ w.Header().Set("Content-Type", "application/json")
83
+ status := func(code int) {
84
+ if code != 0 {
85
+ w.WriteHeader(code)
86
+ }
87
+ }
88
+ switch r.URL.Path {
89
+ case "/v1/auth/jwt/login":
90
+ fmt.Fprintf(w, `{"auth":{"client_token":"fresh-token","lease_duration":%d,"renewable":true}}`, 24*hour)
91
+ case "/v1/auth/token/lookup-self":
92
+ status(options.lookupStatus)
93
+ ttl, renewable, creation := float64(12*hour), true, int64(24*hour)
94
+ if options.ttl != nil {
95
+ ttl = *options.ttl
96
+ }
97
+ if options.renewable != nil {
98
+ renewable = *options.renewable
99
+ }
100
+ if options.creationTTL != nil {
101
+ creation = *options.creationTTL
102
+ }
103
+ fmt.Fprintf(w, `{"data":{"ttl":%v,"renewable":%v,"creation_ttl":%d,"entity_id":"test-entity"}}`, ttl, renewable, creation)
104
+ case "/v1/auth/token/renew-self":
105
+ status(options.renewStatus)
106
+ fmt.Fprintf(w, `{"auth":{"client_token":%q,"lease_duration":%d,"renewable":true}}`, r.Header.Get("X-Vault-Token"), 24*hour)
107
+ case "/v1/identity/entity/id/test-entity":
108
+ fmt.Fprint(w, `{"data":{"metadata":{}}}`)
109
+ default:
110
+ w.WriteHeader(404)
111
+ fmt.Fprint(w, `{}`)
112
+ }
113
+ }))
114
+ t.Cleanup(f.server.Close)
115
+ return f
116
+ }
117
+
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,
128
+ }
129
+ }
130
+
131
+ func (f *fixture) paths() []string {
132
+ var paths []string
133
+ for _, r := range f.requests {
134
+ paths = append(paths, r.Path)
135
+ }
136
+ return paths
137
+ }
138
+
139
+ func (f *fixture) read(v *Vauth) tokenCache {
140
+ f.t.Helper()
141
+ armor, err := os.ReadFile(v.TokenCacheFile())
142
+ if err != nil {
143
+ f.t.Fatal(err)
144
+ }
145
+ body, err := sshagentcrypt.Decrypt(armor, "", &sshagentcrypt.Options{AgentSocket: agentSocket})
146
+ if err != nil {
147
+ f.t.Fatal(err)
148
+ }
149
+ var cache tokenCache
150
+ if err := json.Unmarshal(body, &cache); err != nil {
151
+ f.t.Fatal(err)
152
+ }
153
+ return cache
154
+ }
155
+
156
+ func (f *fixture) write(v *Vauth, cache tokenCache) {
157
+ f.t.Helper()
158
+ if err := v.writeTokenCache(v.TokenCacheFile(), v.TokenCacheFile()+".next", &cache); err != nil {
159
+ f.t.Fatal(err)
160
+ }
161
+ }
162
+
163
+ // remaining rewrites the cached expiry so that ttl seconds remain (0: unlimited).
164
+ func (f *fixture) remaining(v *Vauth, ttl float64) {
165
+ cache := f.read(v)
166
+ cache.ExpiresAt = nil
167
+ if ttl != 0 {
168
+ expires := time.Now().UnixMilli() + int64(ttl*1000)
169
+ cache.ExpiresAt = &expires
170
+ }
171
+ f.write(v, cache)
172
+ }
173
+
174
+ func (f *fixture) seed(v *Vauth, lease int64) {
175
+ renewable := f.options.renewable == nil || *f.options.renewable
176
+ v.saveTokenCache(&token{Value: "cached-token", TTL: float64(lease), LeaseDuration: lease, Renewable: renewable})
177
+ if f.options.ttl != nil {
178
+ f.remaining(v, *f.options.ttl)
179
+ }
180
+ }
181
+
182
+ func connect(t *testing.T, v *Vauth, renew bool) string {
183
+ t.Helper()
184
+ token, err := v.Connect(renew)
185
+ if err != nil {
186
+ t.Fatal(err)
187
+ }
188
+ return token
189
+ }
190
+
191
+ func equal[T comparable](t *testing.T, got, want T) {
192
+ t.Helper()
193
+ if got != want {
194
+ t.Fatalf("got %v, want %v", got, want)
195
+ }
196
+ }
197
+
198
+ func equalPaths(t *testing.T, got []string, want ...string) {
199
+ t.Helper()
200
+ if strings.Join(got, " ") != strings.Join(want, " ") {
201
+ t.Fatalf("requests %v, want %v", got, want)
202
+ }
203
+ }
204
+
205
+ func TestLoginPersistsAndReuses(t *testing.T) {
206
+ f := newFixture(t, fixtureOptions{})
207
+ first := f.client()
208
+ equal(t, connect(t, first, false), "fresh-token")
209
+ cache := f.read(first)
210
+ equal(t, cache.Token, "fresh-token")
211
+ if cache.ExpiresAt == nil || *cache.ExpiresAt < time.Now().UnixMilli()+23*hour*1000 {
212
+ t.Fatalf("expires_at %v", cache.ExpiresAt)
213
+ }
214
+ info, _ := os.Stat(first.TokenCacheFile())
215
+ equal(t, info.Mode().Perm(), 0o600)
216
+ info, _ = os.Stat(filepath.Dir(first.TokenCacheFile()))
217
+ equal(t, info.Mode().Perm(), 0o700)
218
+ second := f.client()
219
+ equal(t, connect(t, second, false), "fresh-token")
220
+ equalPaths(t, f.paths(), "/v1/auth/jwt/login")
221
+ entries, _ := os.ReadDir(filepath.Dir(first.TokenCacheFile()))
222
+ equal(t, len(entries), 1)
223
+ }
224
+
225
+ func TestLastThirdRenewsAndSaves(t *testing.T) {
226
+ f := newFixture(t, fixtureOptions{ttl: seconds(hour)})
227
+ v := f.client()
228
+ f.seed(v, 12*hour)
229
+ equal(t, connect(t, v, false), "cached-token")
230
+ equalPaths(t, f.paths(), "/v1/auth/token/renew-self")
231
+ equal(t, f.requests[0].Method, "POST")
232
+ equal(t, f.requests[0].Token, "cached-token")
233
+ if *f.read(v).ExpiresAt < time.Now().UnixMilli()+23*hour*1000 {
234
+ t.Fatal("renewed expiry not saved")
235
+ }
236
+ }
237
+
238
+ func TestMoreThanOneThirdNoRenewal(t *testing.T) {
239
+ f := newFixture(t, fixtureOptions{ttl: seconds(4*hour + 1)})
240
+ v := f.client()
241
+ f.seed(v, 12*hour)
242
+ equal(t, connect(t, v, false), "cached-token")
243
+ equal(t, len(f.requests), 0)
244
+ }
245
+
246
+ func TestExpiredCacheReplaced(t *testing.T) {
247
+ f := newFixture(t, fixtureOptions{})
248
+ v := f.client()
249
+ f.seed(v, 12*hour)
250
+ f.remaining(v, -1)
251
+ equal(t, connect(t, v, false), "fresh-token")
252
+ equal(t, f.read(v).Token, "fresh-token")
253
+ equalPaths(t, f.paths(), "/v1/auth/jwt/login")
254
+ }
255
+
256
+ func TestCachedTokensReusedWithoutRevocationCheck(t *testing.T) {
257
+ f := newFixture(t, fixtureOptions{lookupStatus: 403})
258
+ v := f.client()
259
+ f.seed(v, 12*hour)
260
+ equal(t, connect(t, v, false), "cached-token")
261
+ equal(t, len(f.requests), 0)
262
+ if _, _, err := v.lookupToken(v.VaultToken); err == nil {
263
+ t.Fatal("lookup should fail")
264
+ }
265
+ }
266
+
267
+ func TestNonRenewableNearingExpiryReauthenticates(t *testing.T) {
268
+ f := newFixture(t, fixtureOptions{ttl: seconds(hour), renewable: boolean(false)})
269
+ v := f.client()
270
+ f.seed(v, 12*hour)
271
+ equal(t, connect(t, v, false), "fresh-token")
272
+ equalPaths(t, f.paths(), "/v1/auth/jwt/login")
273
+ }
274
+
275
+ func TestRejectedRenewalTriggersLogin(t *testing.T) {
276
+ for _, status := range []int{400, 403} {
277
+ f := newFixture(t, fixtureOptions{ttl: seconds(hour), renewStatus: status})
278
+ v := f.client()
279
+ f.seed(v, 12*hour)
280
+ equal(t, connect(t, v, false), "fresh-token")
281
+ equal(t, f.read(v).Token, "fresh-token")
282
+ equalPaths(t, f.paths(), "/v1/auth/token/renew-self", "/v1/auth/jwt/login")
283
+ }
284
+ }
285
+
286
+ func TestServerFailuresDoNotGenerateTokens(t *testing.T) {
287
+ f := newFixture(t, fixtureOptions{lookupStatus: 500})
288
+ v := f.client()
289
+ f.seed(v, 12*hour)
290
+ v.VaultToken = "uncached-token"
291
+ for i := 0; i < 2; i++ {
292
+ if _, err := v.Connect(false); err == nil {
293
+ t.Fatal("connect should fail")
294
+ }
295
+ }
296
+ equalPaths(t, f.paths(), "/v1/auth/token/lookup-self", "/v1/auth/token/lookup-self")
297
+
298
+ f = newFixture(t, fixtureOptions{ttl: seconds(hour), renewStatus: 500})
299
+ v = f.client()
300
+ f.seed(v, 12*hour)
301
+ if _, err := v.Connect(false); err == nil {
302
+ t.Fatal("connect should fail")
303
+ }
304
+ equalPaths(t, f.paths(), "/v1/auth/token/renew-self")
305
+ }
306
+
307
+ func TestEnvironmentTokenRespectedAndCached(t *testing.T) {
308
+ f := newFixture(t, fixtureOptions{})
309
+ v := f.client()
310
+ f.seed(v, 12*hour)
311
+ v.VaultToken = "environment-token"
312
+ 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)
316
+ }
317
+
318
+ func TestNonExpiringTokensReused(t *testing.T) {
319
+ f := newFixture(t, fixtureOptions{ttl: seconds(0)})
320
+ v := f.client()
321
+ f.seed(v, 0)
322
+ equal(t, connect(t, v, false), "cached-token")
323
+ if f.read(v).ExpiresAt != nil {
324
+ t.Fatal("expires_at should be null")
325
+ }
326
+ equal(t, len(f.requests), 0)
327
+ }
328
+
329
+ func TestCorruptCacheReplaced(t *testing.T) {
330
+ f := newFixture(t, fixtureOptions{})
331
+ v := f.client()
332
+ os.MkdirAll(filepath.Dir(v.TokenCacheFile()), 0o700)
333
+ os.WriteFile(v.TokenCacheFile(), []byte("{broken"), 0o600)
334
+ equal(t, connect(t, v, false), "fresh-token")
335
+ equal(t, f.read(v).Token, "fresh-token")
336
+ }
337
+
338
+ func TestPlaintextCacheNotAccepted(t *testing.T) {
339
+ f := newFixture(t, fixtureOptions{})
340
+ 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)
343
+ equal(t, connect(t, v, false), "fresh-token")
344
+ equalPaths(t, f.paths(), "/v1/auth/jwt/login")
345
+ }
346
+
347
+ func TestCacheIsolation(t *testing.T) {
348
+ f := newFixture(t, fixtureOptions{})
349
+ first := f.client()
350
+ f.seed(first, 12*hour)
351
+ second := f.client()
352
+ second.RC.JWTAuth.Role = "other-role"
353
+ equal(t, connect(t, second, false), "fresh-token")
354
+ if first.TokenCacheFile() == second.TokenCacheFile() {
355
+ t.Fatal("cache files should differ")
356
+ }
357
+ equal(t, f.read(first).Token, "cached-token")
358
+ 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() {
362
+ t.Fatal("cache keys should differ")
363
+ }
364
+ entries, _ := os.ReadDir(filepath.Dir(first.TokenCacheFile()))
365
+ equal(t, len(entries), 2)
366
+ armor, _ := os.ReadFile(first.TokenCacheFile())
367
+ if bytes.Contains(armor, []byte("test-jwt")) || bytes.Contains(armor, []byte("cached-token")) {
368
+ t.Fatal("cache leaks secrets")
369
+ }
370
+ }
371
+
372
+ 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"}}`))
385
+ }
386
+
387
+ func TestRepeatedConnectReusesConnection(t *testing.T) {
388
+ f := newFixture(t, fixtureOptions{})
389
+ v := f.client()
390
+ equal(t, connect(t, v, false), "fresh-token")
391
+ equal(t, connect(t, v, false), "fresh-token")
392
+ equal(t, len(f.requests), 1)
393
+ }
394
+
395
+ func TestUnwritableCacheDoesNotPreventLogin(t *testing.T) {
396
+ f := newFixture(t, fixtureOptions{})
397
+ 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)
400
+ var stderr bytes.Buffer
401
+ v.Stderr = &stderr
402
+ equal(t, connect(t, v, false), "fresh-token")
403
+ if !strings.Contains(stderr.String(), "token not persisted") {
404
+ t.Fatalf("stderr %q", stderr.String())
405
+ }
406
+ }
407
+
408
+ func TestWithoutAuthMethodTokensIgnored(t *testing.T) {
409
+ f := newFixture(t, fixtureOptions{lookupStatus: 403})
410
+ v := f.client()
411
+ 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, "")
416
+ equal(t, connect(t, v, true), "")
417
+ equal(t, len(f.requests), 0)
418
+ }
419
+
420
+ func TestRenewIgnoresTokensAndSaves(t *testing.T) {
421
+ f := newFixture(t, fixtureOptions{})
422
+ v := f.client()
423
+ f.seed(v, 12*hour)
424
+ v.VaultToken = "environment-token"
425
+ equal(t, connect(t, v, true), "fresh-token")
426
+ equalPaths(t, f.paths(), "/v1/auth/jwt/login")
427
+ equal(t, f.read(v).Token, "fresh-token")
428
+
429
+ f = newFixture(t, fixtureOptions{})
430
+ v = f.client()
431
+ f.seed(v, 12*hour)
432
+ connect(t, v, false)
433
+ equal(t, connect(t, v, true), "fresh-token")
434
+ equal(t, connect(t, v, true), "fresh-token")
435
+ equalPaths(t, f.paths(), "/v1/auth/jwt/login", "/v1/auth/jwt/login")
436
+ }
437
+
438
+ func TestProportionalThreshold(t *testing.T) {
439
+ for _, c := range []struct {
440
+ lease int64
441
+ remaining float64
442
+ renew bool
443
+ }{
444
+ {24 * hour, 8 * hour, true}, {24 * hour, 8*hour + 1, false},
445
+ {hour, 20 * 60, true}, {hour, 20*60 + 1, false},
446
+ {60, 20, true}, {60, 21, false},
447
+ } {
448
+ f := newFixture(t, fixtureOptions{ttl: seconds(c.remaining)})
449
+ v := f.client()
450
+ f.seed(v, c.lease)
451
+ connect(t, v, false)
452
+ renewed := strings.Contains(strings.Join(f.paths(), " "), "/renew-self")
453
+ if renewed != c.renew {
454
+ t.Fatalf("lease=%d remaining=%v renewed=%v", c.lease, c.remaining, renewed)
455
+ }
456
+ want := c.lease
457
+ if c.renew {
458
+ want = 24 * hour
459
+ }
460
+ equal(t, f.read(v).LeaseDuration, want)
461
+ }
462
+ }
463
+
464
+ func TestLookupsNeverResetLease(t *testing.T) {
465
+ f := newFixture(t, fixtureOptions{ttl: seconds(20 * hour)})
466
+ v := f.client()
467
+ f.seed(v, 24*hour)
468
+ connect(t, v, false)
469
+ equal(t, f.read(v).LeaseDuration, 24*hour)
470
+ f.remaining(v, 12*hour)
471
+ connect(t, f.client(), false)
472
+ equal(t, f.read(v).LeaseDuration, 24*hour)
473
+ f.remaining(v, 8*hour)
474
+ connect(t, f.client(), false)
475
+ equal(t, strings.Count(strings.Join(f.paths(), " "), "/renew-self"), 1)
476
+ }
477
+
478
+ func TestRenewalUpdatesLeaseBaseline(t *testing.T) {
479
+ f := newFixture(t, fixtureOptions{ttl: seconds(20 * 60)})
480
+ v := f.client()
481
+ f.seed(v, hour)
482
+ connect(t, v, false)
483
+ equal(t, f.read(v).LeaseDuration, 24*hour)
484
+ f.remaining(v, 8*hour)
485
+ connect(t, f.client(), false)
486
+ equal(t, strings.Count(strings.Join(f.paths(), " "), "/renew-self"), 2)
487
+ }
488
+
489
+ func TestNormalReuseNeverWrites(t *testing.T) {
490
+ f := newFixture(t, fixtureOptions{})
491
+ v := f.client()
492
+ f.seed(v, 12*hour)
493
+ v.VaultToken = "cached-token"
494
+ before, _ := os.ReadFile(v.TokenCacheFile())
495
+ stat, _ := os.Stat(v.TokenCacheFile())
496
+ equal(t, connect(t, v, false), "cached-token")
497
+ after, _ := os.ReadFile(v.TokenCacheFile())
498
+ if !bytes.Equal(before, after) {
499
+ t.Fatal("cache rewritten")
500
+ }
501
+ again, _ := os.Stat(v.TokenCacheFile())
502
+ equal(t, again.ModTime(), stat.ModTime())
503
+ equal(t, len(f.requests), 0)
504
+ }
505
+
506
+ func TestLookupReturnsLease(t *testing.T) {
507
+ f := newFixture(t, fixtureOptions{ttl: seconds(hour)})
508
+ v := f.client()
509
+ info, lease, err := v.lookupToken("environment-token")
510
+ if err != nil {
511
+ t.Fatal(err)
512
+ }
513
+ equal(t, lease, 24*hour)
514
+ equal(t, info.TTL, float64(hour))
515
+ equal(t, len(f.requests), 1)
516
+ }
517
+
518
+ func TestTokenCacheDisabled(t *testing.T) {
519
+ f := newFixture(t, fixtureOptions{})
520
+ v := f.client()
521
+ v.TokenCache = false
522
+ equal(t, connect(t, v, false), "fresh-token")
523
+ if _, err := os.Stat(v.TokenCacheFile()); err == nil {
524
+ t.Fatal("cache written")
525
+ }
526
+ equalPaths(t, f.paths(), "/v1/auth/jwt/login")
527
+
528
+ f = newFixture(t, fixtureOptions{})
529
+ v = f.client()
530
+ f.seed(v, 12*hour)
531
+ before, _ := os.ReadFile(v.TokenCacheFile())
532
+ v.TokenCache = false
533
+ equal(t, connect(t, v, false), "fresh-token")
534
+ after, _ := os.ReadFile(v.TokenCacheFile())
535
+ if !bytes.Equal(before, after) {
536
+ t.Fatal("disabled cache touched disk")
537
+ }
538
+
539
+ f = newFixture(t, fixtureOptions{})
540
+ v = f.client()
541
+ v.TokenCache = false
542
+ v.VaultToken = "environment-token"
543
+ 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 {
546
+ t.Fatal("cache written")
547
+ }
548
+ }
549
+
550
+ func TestTokenCacheFalseFromRC(t *testing.T) {
551
+ rc, err := ParseRC([]byte("vault_addr: https://vault.example.test\ntoken_cache: false\n"), ".vauthrc", map[string]string{})
552
+ if err != nil {
553
+ t.Fatal(err)
554
+ }
555
+ if rc.TokenCache == nil || *rc.TokenCache {
556
+ t.Fatal("token_cache false not parsed")
557
+ }
558
+ }
559
+
560
+ func TestCacheIsArmorOnly(t *testing.T) {
561
+ f := newFixture(t, fixtureOptions{})
562
+ v := f.client()
563
+ connect(t, v, false)
564
+ armor, _ := os.ReadFile(v.TokenCacheFile())
565
+ if !bytes.HasPrefix(armor, []byte("ssh-agent-crypt:")) || bytes.Contains(armor, []byte("fresh-token")) {
566
+ t.Fatalf("not armored: %q", armor[:40])
567
+ }
568
+ // The ssh-agent-crypt CLI (Go) decrypts the same armor.
569
+ cli := exec.Command("go", "run", "github.com/131/ssh-agent-crypt/cmd/ssh-agent-crypt", "-decrypt")
570
+ cli.Stdin = bytes.NewReader(armor)
571
+ cli.Env = append(os.Environ(), "SSH_AUTH_SOCK="+agentSocket)
572
+ out, err := cli.Output()
573
+ if err != nil {
574
+ t.Skipf("ssh-agent-crypt CLI unavailable: %v", err)
575
+ }
576
+ var cache tokenCache
577
+ if err := json.Unmarshal(out, &cache); err != nil || cache.Token != "fresh-token" {
578
+ t.Fatalf("CLI output %q", out)
579
+ }
580
+ }
581
+
582
+ func TestWithoutAgentCacheSkipped(t *testing.T) {
583
+ f := newFixture(t, fixtureOptions{})
584
+ v := f.client()
585
+ f.seed(v, 12*hour)
586
+ before, _ := os.ReadFile(v.TokenCacheFile())
587
+ v.Agent = ""
588
+ v.TokenCache = false // as New() does when no agent is configured
589
+ equal(t, connect(t, v, false), "fresh-token")
590
+ after, _ := os.ReadFile(v.TokenCacheFile())
591
+ if !bytes.Equal(before, after) {
592
+ t.Fatal("existing armor touched")
593
+ }
594
+ }
595
+
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
+ func TestOneStatusPerConnection(t *testing.T) {
618
+ for _, c := range []struct {
619
+ options fixtureOptions
620
+ operation string
621
+ duration string
622
+ }{
623
+ {fixtureOptions{ttl: seconds(12 * hour)}, "reused", "12h"},
624
+ {fixtureOptions{ttl: seconds(hour)}, "renewed", "1d"},
625
+ {fixtureOptions{ttl: seconds(hour), renewStatus: 400}, "generated", "1d"},
626
+ {fixtureOptions{ttl: seconds(hour), renewStatus: 403}, "generated", "1d"},
627
+ } {
628
+ f := newFixture(t, c.options)
629
+ v := f.client()
630
+ f.seed(v, 12*hour)
631
+ var stderr bytes.Buffer
632
+ v.Stderr = &stderr
633
+ connect(t, v, false)
634
+ equal(t, stderr.String(), fmt.Sprintf("Vauth token: %s · %s · %s\n", c.operation, f.server.URL, c.duration))
635
+ }
636
+ f := newFixture(t, fixtureOptions{lookupStatus: 500})
637
+ v := f.client()
638
+ v.VaultToken = "uncached-token"
639
+ var stderr bytes.Buffer
640
+ v.Stderr = &stderr
641
+ if _, err := v.Connect(false); err == nil {
642
+ t.Fatal("connect should fail")
643
+ }
644
+ equal(t, stderr.String(), "")
645
+ }
646
+
647
+ func TestReplaceEnv(t *testing.T) {
648
+ dict := Lookup{"env": map[string]string{"USER": "alice"}, "profile": map[string]any{"TOKEN": "secret", "N": 3}}
649
+ equal(t, ReplaceEnv("$${env.USER}", dict), "alice")
650
+ equal(t, ReplaceEnv("x-$${profile.TOKEN}-$${profile.N}", dict), "x-secret-3")
651
+ equal(t, ReplaceEnv("$${profile.MISSING}", dict), "$${profile.MISSING}") // unresolved macros are kept, like nyks
652
+ equal(t, ReplaceEnv("plain", dict), "plain")
653
+ }
654
+
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
+ func sha256Hex(value string) string {
662
+ digest := sha256.Sum256([]byte(value))
663
+ return hex.EncodeToString(digest[:])
664
+ }