vvauth 2.4.0 → 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/.github/workflows/publish-npm.yml +5 -0
- package/.github/workflows/release.yml +33 -0
- package/.github/workflows/test.yml +38 -0
- package/.goreleaser.yaml +31 -0
- package/README.md +17 -0
- package/cache.go +101 -0
- package/cmd/vauth/main.go +202 -0
- package/go.mod +16 -0
- package/go.sum +14 -0
- package/humandiff.go +50 -0
- package/index.js +1 -1
- package/package.json +1 -1
- package/rc.go +427 -0
- package/test/token-cache.js +24 -0
- package/vault.go +238 -0
- package/vauth.go +518 -0
- package/vauth_test.go +664 -0
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
|
+
}
|