Debian Codegraph @

autorest/adal/token_test.go

raw
1 package adal
2
3 // Copyright 2017 Microsoft Corporation
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16
17 import (
18 "context"
19 "crypto/rand"
20 "crypto/rsa"
21 "crypto/x509"
22 "crypto/x509/pkix"
23 "encoding/json"
24 "fmt"
25 "io/ioutil"
26 "math/big"
27 "net/http"
28 "net/url"
29 "os"
30 "reflect"
31 "strconv"
32 "strings"
33 "sync"
34 "testing"
35 "time"
36
37 "github.com/Azure/go-autorest/autorest/date"
38 "github.com/Azure/go-autorest/autorest/mocks"
39 jwt "github.com/golang-jwt/jwt/v4"
40 )
41
42 const (
43 defaultFormData = "client_id=id&client_secret=secret&grant_type=client_credentials&resource=resource"
44 defaultManualFormData = "client_id=id&grant_type=refresh_token&refresh_token=refreshtoken&resource=resource"
45 )
46
47 func TestTokenExpires(t *testing.T) {
48 tt := time.Now().Add(5 * time.Second)
49 tk := newTokenExpiresAt(tt)
50
51 if tk.Expires().Equal(tt) {
52 t.Fatalf("adal: Token#Expires miscalculated expiration time -- received %v, expected %v", tk.Expires(), tt)
53 }
54 }
55
56 func TestTokenIsExpired(t *testing.T) {
57 tk := newTokenExpiresAt(time.Now().Add(-5 * time.Second))
58
59 if !tk.IsExpired() {
60 t.Fatalf("adal: Token#IsExpired failed to mark a stale token as expired -- now %v, token expires at %v",
61 time.Now().UTC(), tk.Expires())
62 }
63 }
64
65 func TestTokenIsExpiredUninitialized(t *testing.T) {
66 tk := &Token{}
67
68 if !tk.IsExpired() {
69 t.Fatalf("adal: An uninitialized Token failed to mark itself as expired (expiration time %v)", tk.Expires())
70 }
71 }
72
73 func TestTokenIsNoExpired(t *testing.T) {
74 tk := newTokenExpiresAt(time.Now().Add(1000 * time.Second))
75
76 if tk.IsExpired() {
77 t.Fatalf("adal: Token marked a fresh token as expired -- now %v, token expires at %v", time.Now().UTC(), tk.Expires())
78 }
79 }
80
81 func TestTokenWillExpireIn(t *testing.T) {
82 d := 5 * time.Second
83 tk := newTokenExpiresIn(d)
84
85 if !tk.WillExpireIn(d) {
86 t.Fatal("adal: Token#WillExpireIn mismeasured expiration time")
87 }
88 }
89
90 func TestParseExpiresOn(t *testing.T) {
91 n := time.Now().UTC()
92 amPM := "AM"
93 if n.Hour() >= 12 {
94 amPM = "PM"
95 }
96 testcases := []struct {
97 Name string
98 String string
99 Value int64
100 }{
101 {
102 Name: "integer",
103 String: "3600",
104 Value: 3600,
105 },
106 {
107 Name: "timestamp with AM/PM",
108 String: fmt.Sprintf("%d/%d/%d %d:%02d:%02d %s +00:00", n.Month(), n.Day(), n.Year(), n.Hour(), n.Minute(), n.Second(), amPM),
109 Value: n.Unix(),
110 },
111 {
112 Name: "timestamp without AM/PM",
113 String: fmt.Sprintf("%02d/%02d/%02d %02d:%02d:%02d +00:00", n.Month(), n.Day(), n.Year(), n.Hour(), n.Minute(), n.Second()),
114 Value: n.Unix(),
115 },
116 }
117 for _, tc := range testcases {
118 t.Run(tc.Name, func(subT *testing.T) {
119 jn, err := parseExpiresOn(tc.String)
120 if err != nil {
121 subT.Error(err)
122 }
123 i, err := jn.Int64()
124 if err != nil {
125 subT.Error(err)
126 }
127 if i != tc.Value {
128 subT.Logf("expected %d, got %d", tc.Value, i)
129 subT.Fail()
130 }
131 })
132 }
133 }
134
135 func TestServicePrincipalTokenSetAutoRefresh(t *testing.T) {
136 spt := newServicePrincipalToken()
137
138 if !spt.inner.AutoRefresh {
139 t.Fatal("adal: ServicePrincipalToken did not default to automatic token refreshing")
140 }
141
142 spt.SetAutoRefresh(false)
143 if spt.inner.AutoRefresh {
144 t.Fatal("adal: ServicePrincipalToken#SetAutoRefresh did not disable automatic token refreshing")
145 }
146 }
147
148 func TestServicePrincipalTokenSetCustomRefreshFunc(t *testing.T) {
149 spt := newServicePrincipalToken()
150
151 var refreshFunc TokenRefresh = func(context context.Context, resource string) (*Token, error) {
152 return nil, nil
153 }
154
155 if spt.customRefreshFunc != nil {
156 t.Fatalf("adal: ServicePrincipalToken#SetCustomRefreshFunc had a default custom refresh func when it shouldn't")
157 }
158
159 spt.SetCustomRefreshFunc(refreshFunc)
160
161 if spt.customRefreshFunc == nil {
162 t.Fatalf("adal: ServicePrincipalToken#SetCustomRefreshFunc didn't have a refresh func")
163 }
164 }
165
166 func TestServicePrincipalTokenSetRefreshWithin(t *testing.T) {
167 spt := newServicePrincipalToken()
168
169 if spt.inner.RefreshWithin != defaultRefresh {
170 t.Fatal("adal: ServicePrincipalToken did not correctly set the default refresh interval")
171 }
172
173 spt.SetRefreshWithin(2 * defaultRefresh)
174 if spt.inner.RefreshWithin != 2*defaultRefresh {
175 t.Fatal("adal: ServicePrincipalToken#SetRefreshWithin did not set the refresh interval")
176 }
177 }
178
179 func TestServicePrincipalTokenSetSender(t *testing.T) {
180 spt := newServicePrincipalToken()
181
182 c := &http.Client{}
183 spt.SetSender(c)
184 if !reflect.DeepEqual(c, spt.sender) {
185 t.Fatal("adal: ServicePrincipalToken#SetSender did not set the sender")
186 }
187 }
188
189 func TestServicePrincipalTokenRefreshUsesCustomRefreshFunc(t *testing.T) {
190 spt := newServicePrincipalToken()
191
192 called := false
193 var refreshFunc TokenRefresh = func(context context.Context, resource string) (*Token, error) {
194 called = true
195 return &Token{}, nil
196 }
197 spt.SetCustomRefreshFunc(refreshFunc)
198 if called {
199 t.Fatalf("adal: ServicePrincipalToken#refreshInternal called the refresh function prior to refreshing")
200 }
201
202 spt.refreshInternal(context.Background(), "https://example.com")
203
204 if !called {
205 t.Fatalf("adal: ServicePrincipalToken#refreshInternal didn't call the refresh function")
206 }
207 }
208
209 func TestServicePrincipalTokenRefreshUsesPOST(t *testing.T) {
210 spt := newServicePrincipalToken()
211
212 body := mocks.NewBody(newTokenJSON(`"3600"`, "12345", "test"))
213 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
214
215 c := mocks.NewSender()
216 s := DecorateSender(c,
217 (func() SendDecorator {
218 return func(s Sender) Sender {
219 return SenderFunc(func(r *http.Request) (*http.Response, error) {
220 if r.Method != "POST" {
221 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set HTTP method -- expected %v, received %v", "POST", r.Method)
222 }
223 return resp, nil
224 })
225 }
226 })())
227 spt.SetSender(s)
228 err := spt.Refresh()
229 if err != nil {
230 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
231 }
232
233 if body.IsOpen() {
234 t.Fatalf("the response was not closed!")
235 }
236 }
237
238 func TestNewServicePrincipalTokenFromManagedIdentity(t *testing.T) {
239 spt, err := NewServicePrincipalTokenFromManagedIdentity("https://resource", nil)
240 if err != nil {
241 t.Fatalf("Failed to get MSI SPT: %v", err)
242 }
243
244 body := mocks.NewBody(newTokenJSON(`"3600"`, "12345", "test"))
245 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
246
247 c := mocks.NewSender()
248 s := DecorateSender(c,
249 (func() SendDecorator {
250 return func(s Sender) Sender {
251 return SenderFunc(func(r *http.Request) (*http.Response, error) {
252 if r.Method != "GET" {
253 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set HTTP method -- expected %v, received %v", "GET", r.Method)
254 }
255 if h := r.Header.Get("Metadata"); h != "true" {
256 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set Metadata header for MSI")
257 }
258 return resp, nil
259 })
260 }
261 })())
262 spt.SetSender(s)
263 err = spt.Refresh()
264 if err != nil {
265 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
266 }
267
268 if body.IsOpen() {
269 t.Fatalf("the response was not closed!")
270 }
271 }
272
273 func TestServicePrincipalTokenFromMSICloudshell(t *testing.T) {
274 os.Setenv(msiEndpointEnv, "http://dummy")
275 defer func() {
276 os.Unsetenv(msiEndpointEnv)
277 }()
278 spt, err := NewServicePrincipalTokenFromMSI("", "https://resource")
279 if err != nil {
280 t.Fatalf("Failed to get MSI SPT: %v", err)
281 }
282
283 body := mocks.NewBody(newTokenJSON(`"3600"`, "12345", "test"))
284 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
285
286 c := mocks.NewSender()
287 s := DecorateSender(c,
288 (func() SendDecorator {
289 return func(s Sender) Sender {
290 return SenderFunc(func(r *http.Request) (*http.Response, error) {
291 if r.Method != http.MethodPost {
292 t.Fatalf("adal: cloudshell did not correctly set HTTP method -- expected %v, received %v", "GET", r.Method)
293 }
294 if h := r.Header.Get("Metadata"); h != "true" {
295 t.Fatalf("adal: cloudshell did not correctly set Metadata header")
296 }
297 if h := r.Header.Get("Content-Type"); h != "application/x-www-form-urlencoded" {
298 t.Fatalf("adal: cloudshell did not correctly set Content-Type header")
299 }
300 return resp, nil
301 })
302 }
303 })())
304 spt.SetSender(s)
305 err = spt.Refresh()
306 if err != nil {
307 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
308 }
309
310 if body.IsOpen() {
311 t.Fatalf("the response was not closed!")
312 }
313 }
314
315 func TestServicePrincipalTokenFromMSIRefreshZeroRetry(t *testing.T) {
316 resource := "https://resource"
317 cb := func(token Token) error { return nil }
318
319 endpoint, _ := GetMSIVMEndpoint()
320 spt, err := NewServicePrincipalTokenFromMSI(endpoint, resource, cb)
321 if err != nil {
322 t.Fatalf("Failed to get MSI SPT: %v", err)
323 }
324 spt.MaxMSIRefreshAttempts = 1
325
326 body := mocks.NewBody(newTokenJSON(`"3600"`, "12345", "test"))
327 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
328
329 c := mocks.NewSender()
330 s := DecorateSender(c,
331 (func() SendDecorator {
332 return func(s Sender) Sender {
333 return SenderFunc(func(r *http.Request) (*http.Response, error) {
334 // second invocation, perform MSI request validation
335 if r.Method != "GET" {
336 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set HTTP method -- expected %v, received %v", "GET", r.Method)
337 }
338 if h := r.Header.Get("Metadata"); h != "true" {
339 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set Metadata header for MSI")
340 }
341 return resp, nil
342 })
343 }
344 })())
345 spt.SetSender(s)
346 err = spt.Refresh()
347 if err != nil {
348 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
349 }
350
351 if body.IsOpen() {
352 t.Fatalf("the response was not closed!")
353 }
354 }
355
356 func TestServicePrincipalTokenFromASE(t *testing.T) {
357 os.Setenv("MSI_ENDPOINT", "http://localhost")
358 os.Setenv("MSI_SECRET", "super")
359 defer func() {
360 os.Unsetenv("MSI_ENDPOINT")
361 os.Unsetenv("MSI_SECRET")
362 }()
363 resource := "https://resource"
364 spt, err := NewServicePrincipalTokenFromMSI("", resource)
365 if err != nil {
366 t.Fatalf("Failed to get MSI SPT: %v", err)
367 }
368 spt.MaxMSIRefreshAttempts = 1
369 // expires_on is sent in UTC
370 nowTime := time.Now()
371 expiresOn := nowTime.UTC().Add(time.Hour)
372 // use int format for expires_in
373 body := mocks.NewBody(newTokenJSON("3600", expiresOn.Format(expiresOnDateFormat), "test"))
374 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
375
376 c := mocks.NewSender()
377 s := DecorateSender(c,
378 (func() SendDecorator {
379 return func(s Sender) Sender {
380 return SenderFunc(func(r *http.Request) (*http.Response, error) {
381 if r.Method != "GET" {
382 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set HTTP method -- expected %v, received %v", "GET", r.Method)
383 }
384 if h := r.Header.Get(metadataHeader); h != "" {
385 t.Fatalf("adal: ServicePrincipalToken#Refresh incorrectly set Metadata header for ASE")
386 }
387 if s := r.Header.Get(secretHeader); s != "super" {
388 t.Fatalf("adal: unexpected secret header value %s", s)
389 }
390 if r.URL.Host != "localhost" {
391 t.Fatalf("adal: unexpected host %s", r.URL.Host)
392 }
393 qp := r.URL.Query()
394 if api := qp.Get("api-version"); api != appServiceAPIVersion2017 {
395 t.Fatalf("adal: unexpected api-version %s", api)
396 }
397 return resp, nil
398 })
399 }
400 })())
401 spt.SetSender(s)
402 err = spt.Refresh()
403 if err != nil {
404 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
405 }
406 v, err := spt.inner.Token.ExpiresOn.Int64()
407 if err != nil {
408 t.Fatalf("adal: failed to get ExpiresOn %v", err)
409 }
410 if nowAsUnix := nowTime.Add(time.Hour).Unix(); v != nowAsUnix {
411 t.Fatalf("adal: expected %v, got %v", nowAsUnix, v)
412 }
413 if body.IsOpen() {
414 t.Fatalf("the response was not closed!")
415 }
416 }
417
418 func TestServicePrincipalTokenFromADFS(t *testing.T) {
419 os.Setenv("MSI_ENDPOINT", "http://localhost")
420 os.Setenv("MSI_SECRET", "super")
421 defer func() {
422 os.Unsetenv("MSI_ENDPOINT")
423 os.Unsetenv("MSI_SECRET")
424 }()
425 resource := "https://resource"
426 endpoint, _ := GetMSIEndpoint()
427 spt, err := NewServicePrincipalTokenFromMSI(endpoint, resource)
428 if err != nil {
429 t.Fatalf("Failed to get MSI SPT: %v", err)
430 }
431 spt.MaxMSIRefreshAttempts = 1
432 const expiresIn = 3600
433 body := mocks.NewBody(newADFSTokenJSON(expiresIn))
434 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
435
436 c := mocks.NewSender()
437 s := DecorateSender(c,
438 (func() SendDecorator {
439 return func(s Sender) Sender {
440 return SenderFunc(func(r *http.Request) (*http.Response, error) {
441 if r.Method != "GET" {
442 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set HTTP method -- expected %v, received %v", "GET", r.Method)
443 }
444 if h := r.Header.Get(metadataHeader); h != "" {
445 t.Fatalf("adal: ServicePrincipalToken#Refresh incorrectly set Metadata header for ASE")
446 }
447 if s := r.Header.Get(secretHeader); s != "super" {
448 t.Fatalf("adal: unexpected secret header value %s", s)
449 }
450 if r.URL.Host != "localhost" {
451 t.Fatalf("adal: unexpected host %s", r.URL.Host)
452 }
453 qp := r.URL.Query()
454 if api := qp.Get("api-version"); api != appServiceAPIVersion2017 {
455 t.Fatalf("adal: unexpected api-version %s", api)
456 }
457 return resp, nil
458 })
459 }
460 })())
461 spt.SetSender(s)
462 err = spt.Refresh()
463 if err != nil {
464 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
465 }
466 i, err := spt.inner.Token.ExpiresIn.Int64()
467 if err != nil {
468 t.Fatalf("unexpected parsing of expires_in: %v", err)
469 }
470 if i != expiresIn {
471 t.Fatalf("unexpected expires_in %d", i)
472 }
473 if spt.inner.Token.ExpiresOn.String() != "" {
474 t.Fatal("expected empty expires_on")
475 }
476 if body.IsOpen() {
477 t.Fatalf("the response was not closed!")
478 }
479 }
480
481 func TestServicePrincipalTokenFromMSIRefreshCancel(t *testing.T) {
482 ctx, cancel := context.WithCancel(context.Background())
483 endpoint, _ := GetMSIVMEndpoint()
484
485 spt, err := NewServicePrincipalTokenFromMSI(endpoint, "https://resource")
486 if err != nil {
487 t.Fatalf("Failed to get MSI SPT: %v", err)
488 }
489
490 c := mocks.NewSender()
491 c.AppendAndRepeatResponse(mocks.NewResponseWithStatus("Internal server error", http.StatusInternalServerError), 5)
492
493 var wg sync.WaitGroup
494 wg.Add(1)
495 start := time.Now()
496 end := time.Now()
497
498 go func() {
499 spt.SetSender(c)
500 err = spt.RefreshWithContext(ctx)
501 end = time.Now()
502 wg.Done()
503 }()
504
505 cancel()
506 wg.Wait()
507 time.Sleep(5 * time.Millisecond)
508
509 if end.Sub(start) >= time.Second {
510 t.Fatalf("TestServicePrincipalTokenFromMSIRefreshCancel failed to cancel")
511 }
512 }
513
514 func TestServicePrincipalTokenRefreshSetsMimeType(t *testing.T) {
515 spt := newServicePrincipalToken()
516
517 body := mocks.NewBody(newTokenJSON(`"3600"`, "12345", "test"))
518 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
519
520 c := mocks.NewSender()
521 s := DecorateSender(c,
522 (func() SendDecorator {
523 return func(s Sender) Sender {
524 return SenderFunc(func(r *http.Request) (*http.Response, error) {
525 if r.Header.Get(http.CanonicalHeaderKey("Content-Type")) != "application/x-www-form-urlencoded" {
526 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set Content-Type -- expected %v, received %v",
527 "application/x-form-urlencoded",
528 r.Header.Get(http.CanonicalHeaderKey("Content-Type")))
529 }
530 return resp, nil
531 })
532 }
533 })())
534 spt.SetSender(s)
535 err := spt.Refresh()
536 if err != nil {
537 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
538 }
539 }
540
541 func TestServicePrincipalTokenRefreshSetsURL(t *testing.T) {
542 spt := newServicePrincipalToken()
543
544 body := mocks.NewBody(newTokenJSON(`"3600"`, "12345", "test"))
545 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
546
547 c := mocks.NewSender()
548 s := DecorateSender(c,
549 (func() SendDecorator {
550 return func(s Sender) Sender {
551 return SenderFunc(func(r *http.Request) (*http.Response, error) {
552 if r.URL.String() != TestOAuthConfig.TokenEndpoint.String() {
553 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set the URL -- expected %v, received %v",
554 TestOAuthConfig.TokenEndpoint, r.URL)
555 }
556 return resp, nil
557 })
558 }
559 })())
560 spt.SetSender(s)
561 err := spt.Refresh()
562 if err != nil {
563 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
564 }
565 }
566
567 func testServicePrincipalTokenRefreshSetsBody(t *testing.T, spt *ServicePrincipalToken, f func(*testing.T, []byte)) {
568 body := mocks.NewBody(newTokenJSON(`"3600"`, "12345", "test"))
569 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
570
571 c := mocks.NewSender()
572 s := DecorateSender(c,
573 (func() SendDecorator {
574 return func(s Sender) Sender {
575 return SenderFunc(func(r *http.Request) (*http.Response, error) {
576 b, err := ioutil.ReadAll(r.Body)
577 if err != nil {
578 t.Fatalf("adal: Failed to read body of Service Principal token request (%v)", err)
579 }
580 f(t, b)
581 return resp, nil
582 })
583 }
584 })())
585 spt.SetSender(s)
586 err := spt.Refresh()
587 if err != nil {
588 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
589 }
590 }
591
592 func TestServicePrincipalTokenManualRefreshSetsBody(t *testing.T) {
593 sptManual := newServicePrincipalTokenManual()
594 testServicePrincipalTokenRefreshSetsBody(t, sptManual, func(t *testing.T, b []byte) {
595 if string(b) != defaultManualFormData {
596 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set the HTTP Request Body -- expected %v, received %v",
597 defaultManualFormData, string(b))
598 }
599 })
600 }
601
602 func TestServicePrincipalTokenCertficateRefreshSetsBody(t *testing.T) {
603 sptCert := newServicePrincipalTokenCertificate(t)
604 testServicePrincipalTokenRefreshSetsBody(t, sptCert, func(t *testing.T, b []byte) {
605 body := string(b)
606
607 values, _ := url.ParseQuery(body)
608 if values["client_assertion_type"][0] != "urn:ietf:params:oauth:client-assertion-type:jwt-bearer" ||
609 values["client_id"][0] != "id" ||
610 values["grant_type"][0] != "client_credentials" ||
611 values["resource"][0] != "resource" {
612 t.Fatalf("adal: ServicePrincipalTokenCertificate#Refresh did not correctly set the HTTP Request Body.")
613 }
614
615 tok, _ := jwt.Parse(values["client_assertion"][0], nil)
616 if tok == nil {
617 t.Fatalf("adal: ServicePrincipalTokenCertificate#Expected client_assertion to be a JWT")
618 }
619 if _, ok := tok.Header["x5t"]; !ok {
620 t.Fatalf("adal: ServicePrincipalTokenCertificate#Expected client_assertion to have an x5t header")
621 }
622 if _, ok := tok.Header["x5c"]; !ok {
623 t.Fatalf("adal: ServicePrincipalTokenCertificate#Expected client_assertion to have an x5c header")
624 }
625 claims, ok := tok.Claims.(jwt.MapClaims)
626 if !ok {
627 t.Fatalf("expected MapClaims, got %T", tok.Claims)
628 }
629 if err := claims.Valid(); err != nil {
630 t.Fatalf("invalid claim: %v", err)
631 }
632 if aud := claims["aud"]; aud != "https://login.test.com/SomeTenantID/oauth2/token?api-version=1.0" {
633 t.Fatalf("unexpected aud: %s", aud)
634 }
635 if iss := claims["iss"]; iss != "id" {
636 t.Fatalf("unexpected iss: %s", iss)
637 }
638 if sub := claims["sub"]; sub != "id" {
639 t.Fatalf("unexpected sub: %s", sub)
640 }
641 })
642 }
643
644 func TestServicePrincipalTokenUsernamePasswordRefreshSetsBody(t *testing.T) {
645 spt := newServicePrincipalTokenUsernamePassword(t)
646 testServicePrincipalTokenRefreshSetsBody(t, spt, func(t *testing.T, b []byte) {
647 body := string(b)
648
649 values, _ := url.ParseQuery(body)
650 if values["client_id"][0] != "id" ||
651 values["grant_type"][0] != "password" ||
652 values["username"][0] != "username" ||
653 values["password"][0] != "password" ||
654 values["resource"][0] != "resource" {
655 t.Fatalf("adal: ServicePrincipalTokenUsernamePassword#Refresh did not correctly set the HTTP Request Body.")
656 }
657 })
658 }
659
660 func TestServicePrincipalTokenAuthorizationCodeRefreshSetsBody(t *testing.T) {
661 spt := newServicePrincipalTokenAuthorizationCode(t)
662 testServicePrincipalTokenRefreshSetsBody(t, spt, func(t *testing.T, b []byte) {
663 body := string(b)
664
665 values, _ := url.ParseQuery(body)
666 if values["client_id"][0] != "id" ||
667 values["grant_type"][0] != OAuthGrantTypeAuthorizationCode ||
668 values["code"][0] != "code" ||
669 values["client_secret"][0] != "clientSecret" ||
670 values["redirect_uri"][0] != "http://redirectUri/getToken" ||
671 values["resource"][0] != "resource" {
672 t.Fatalf("adal: ServicePrincipalTokenAuthorizationCode#Refresh did not correctly set the HTTP Request Body.")
673 }
674 })
675 testServicePrincipalTokenRefreshSetsBody(t, spt, func(t *testing.T, b []byte) {
676 body := string(b)
677
678 values, _ := url.ParseQuery(body)
679 if values["client_id"][0] != "id" ||
680 values["grant_type"][0] != OAuthGrantTypeRefreshToken ||
681 values["code"][0] != "code" ||
682 values["client_secret"][0] != "clientSecret" ||
683 values["redirect_uri"][0] != "http://redirectUri/getToken" ||
684 values["resource"][0] != "resource" {
685 t.Fatalf("adal: ServicePrincipalTokenAuthorizationCode#Refresh did not correctly set the HTTP Request Body.")
686 }
687 })
688 }
689
690 func TestServicePrincipalTokenSecretRefreshSetsBody(t *testing.T) {
691 spt := newServicePrincipalToken()
692 testServicePrincipalTokenRefreshSetsBody(t, spt, func(t *testing.T, b []byte) {
693 if string(b) != defaultFormData {
694 t.Fatalf("adal: ServicePrincipalToken#Refresh did not correctly set the HTTP Request Body -- expected %v, received %v",
695 defaultFormData, string(b))
696 }
697
698 })
699 }
700
701 func TestServicePrincipalTokenFederatedJwtRefreshSetsBody(t *testing.T) {
702 sptCert := newServicePrincipalTokenFederatedJwt(t)
703 testServicePrincipalTokenRefreshSetsBody(t, sptCert, func(t *testing.T, b []byte) {
704 body := string(b)
705
706 values, _ := url.ParseQuery(body)
707 if values["client_assertion_type"][0] != "urn:ietf:params:oauth:client-assertion-type:jwt-bearer" ||
708 values["client_id"][0] != "id" ||
709 values["grant_type"][0] != "client_credentials" ||
710 values["resource"][0] != "resource" {
711 t.Fatalf("adal: ServicePrincipalTokenCertificate#Refresh did not correctly set the HTTP Request Body.")
712 }
713
714 tok, _ := jwt.Parse(values["client_assertion"][0], nil)
715 if tok == nil {
716 t.Fatalf("adal: ServicePrincipalTokenCertificate#Expected client_assertion to be a JWT")
717 }
718 if _, ok := tok.Header["typ"]; !ok {
719 t.Fatalf("adal: ServicePrincipalTokenCertificate#Expected client_assertion to have an typ header")
720 }
721
722 claims, ok := tok.Claims.(jwt.MapClaims)
723 if !ok {
724 t.Fatalf("expected MapClaims, got %T", tok.Claims)
725 }
726 if err := claims.Valid(); err != nil {
727 t.Fatalf("invalid claim: %v", err)
728 }
729 if aud := claims["aud"]; aud != "testAudience" {
730 t.Fatalf("unexpected aud: %s", aud)
731 }
732 if iss := claims["iss"]; iss != "id" {
733 t.Fatalf("unexpected iss: %s", iss)
734 }
735 if sub := claims["sub"]; sub != "id" {
736 t.Fatalf("unexpected sub: %s", sub)
737 }
738 })
739 }
740
741 func TestServicePrincipalTokenRefreshClosesRequestBody(t *testing.T) {
742 spt := newServicePrincipalToken()
743
744 body := mocks.NewBody(newTokenJSON(`"3600"`, "12345", "test"))
745 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
746
747 c := mocks.NewSender()
748 s := DecorateSender(c,
749 (func() SendDecorator {
750 return func(s Sender) Sender {
751 return SenderFunc(func(r *http.Request) (*http.Response, error) {
752 return resp, nil
753 })
754 }
755 })())
756 spt.SetSender(s)
757 err := spt.Refresh()
758 if err != nil {
759 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
760 }
761 if resp.Body.(*mocks.Body).IsOpen() {
762 t.Fatal("adal: ServicePrincipalToken#Refresh failed to close the HTTP Response Body")
763 }
764 }
765
766 func TestServicePrincipalTokenRefreshRejectsResponsesWithStatusNotOK(t *testing.T) {
767 spt := newServicePrincipalToken()
768
769 body := mocks.NewBody(newTokenJSON(`"3600"`, "12345", "test"))
770 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusUnauthorized, "Unauthorized")
771
772 c := mocks.NewSender()
773 s := DecorateSender(c,
774 (func() SendDecorator {
775 return func(s Sender) Sender {
776 return SenderFunc(func(r *http.Request) (*http.Response, error) {
777 return resp, nil
778 })
779 }
780 })())
781 spt.SetSender(s)
782 err := spt.Refresh()
783 if err == nil {
784 t.Fatalf("adal: ServicePrincipalToken#Refresh should reject a response with status != %d", http.StatusOK)
785 }
786 }
787
788 func TestServicePrincipalTokenRefreshRejectsEmptyBody(t *testing.T) {
789 spt := newServicePrincipalToken()
790
791 c := mocks.NewSender()
792 s := DecorateSender(c,
793 (func() SendDecorator {
794 return func(s Sender) Sender {
795 return SenderFunc(func(r *http.Request) (*http.Response, error) {
796 return mocks.NewResponse(), nil
797 })
798 }
799 })())
800 spt.SetSender(s)
801 err := spt.Refresh()
802 if err == nil {
803 t.Fatal("adal: ServicePrincipalToken#Refresh should reject an empty token")
804 }
805 }
806
807 func TestServicePrincipalTokenRefreshPropagatesErrors(t *testing.T) {
808 spt := newServicePrincipalToken()
809
810 c := mocks.NewSender()
811 c.SetError(fmt.Errorf("Faux Error"))
812 spt.SetSender(c)
813
814 err := spt.Refresh()
815 if err == nil {
816 t.Fatal("adal: Failed to propagate the request error")
817 }
818 }
819
820 func TestServicePrincipalTokenRefreshReturnsErrorIfNotOk(t *testing.T) {
821 spt := newServicePrincipalToken()
822
823 c := mocks.NewSender()
824 c.AppendResponse(mocks.NewResponseWithStatus("401 NotAuthorized", http.StatusUnauthorized))
825 spt.SetSender(c)
826
827 err := spt.Refresh()
828 if err == nil {
829 t.Fatalf("adal: Failed to return an when receiving a status code other than HTTP %d", http.StatusOK)
830 }
831 }
832
833 func TestServicePrincipalTokenRefreshUnmarshals(t *testing.T) {
834 spt := newServicePrincipalToken()
835
836 expiresOn := strconv.Itoa(int(time.Now().Add(3600 * time.Second).Sub(date.UnixEpoch()).Seconds()))
837 j := newTokenJSON(`"3600"`, expiresOn, "resource")
838 resp := mocks.NewResponseWithContent(j)
839 c := mocks.NewSender()
840 s := DecorateSender(c,
841 (func() SendDecorator {
842 return func(s Sender) Sender {
843 return SenderFunc(func(r *http.Request) (*http.Response, error) {
844 return resp, nil
845 })
846 }
847 })())
848 spt.SetSender(s)
849
850 err := spt.Refresh()
851 if err != nil {
852 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
853 } else if spt.inner.Token.AccessToken != "accessToken" ||
854 spt.inner.Token.ExpiresIn != "3600" ||
855 spt.inner.Token.ExpiresOn != json.Number(expiresOn) ||
856 spt.inner.Token.NotBefore != json.Number(expiresOn) ||
857 spt.inner.Token.Resource != "resource" ||
858 spt.inner.Token.Type != "Bearer" {
859 t.Fatalf("adal: ServicePrincipalToken#Refresh failed correctly unmarshal the JSON -- expected %v, received %v",
860 j, *spt)
861 }
862 }
863
864 func TestServicePrincipalTokenEnsureFreshRefreshes(t *testing.T) {
865 spt := newServicePrincipalToken()
866 expireToken(&spt.inner.Token)
867
868 body := mocks.NewBody(newTokenJSON(`"3600"`, "12345", "test"))
869 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
870
871 f := false
872 c := mocks.NewSender()
873 s := DecorateSender(c,
874 (func() SendDecorator {
875 return func(s Sender) Sender {
876 return SenderFunc(func(r *http.Request) (*http.Response, error) {
877 f = true
878 return resp, nil
879 })
880 }
881 })())
882 spt.SetSender(s)
883 err := spt.EnsureFresh()
884 if err != nil {
885 t.Fatalf("adal: ServicePrincipalToken#EnsureFresh returned an unexpected error (%v)", err)
886 }
887 if !f {
888 t.Fatal("adal: ServicePrincipalToken#EnsureFresh failed to call Refresh for stale token")
889 }
890 }
891
892 func TestServicePrincipalTokenEnsureFreshWithIntExpiresOn(t *testing.T) {
893 spt := newServicePrincipalToken()
894 expireToken(&spt.inner.Token)
895
896 body := mocks.NewBody(newTokenJSONIntExpiresOn(`"3600"`, 12345, "test"))
897 resp := mocks.NewResponseWithBodyAndStatus(body, http.StatusOK, "OK")
898
899 f := false
900 c := mocks.NewSender()
901 s := DecorateSender(c,
902 (func() SendDecorator {
903 return func(s Sender) Sender {
904 return SenderFunc(func(r *http.Request) (*http.Response, error) {
905 f = true
906 return resp, nil
907 })
908 }
909 })())
910 spt.SetSender(s)
911 err := spt.EnsureFresh()
912 if err != nil {
913 t.Fatalf("adal: ServicePrincipalToken#EnsureFresh returned an unexpected error (%v)", err)
914 }
915 if !f {
916 t.Fatal("adal: ServicePrincipalToken#EnsureFresh failed to call Refresh for stale token")
917 }
918 }
919
920 func TestServicePrincipalTokenEnsureFreshFails1(t *testing.T) {
921 spt := newServicePrincipalToken()
922 expireToken(&spt.inner.Token)
923
924 c := mocks.NewSender()
925 c.SetError(fmt.Errorf("some failure"))
926
927 spt.SetSender(c)
928 err := spt.EnsureFresh()
929 if err == nil {
930 t.Fatal("adal: ServicePrincipalToken#EnsureFresh didn't return an error")
931 }
932 if _, ok := err.(TokenRefreshError); ok {
933 t.Fatal("adal: ServicePrincipalToken#EnsureFresh unexpected TokenRefreshError")
934 }
935 }
936
937 func TestServicePrincipalTokenEnsureFreshFails2(t *testing.T) {
938 spt := newServicePrincipalToken()
939 expireToken(&spt.inner.Token)
940
941 c := mocks.NewSender()
942 c.AppendResponse(mocks.NewResponseWithStatus("bad request", http.StatusBadRequest))
943
944 spt.SetSender(c)
945 err := spt.EnsureFresh()
946 if err == nil {
947 t.Fatal("adal: ServicePrincipalToken#EnsureFresh didn't return an error")
948 }
949 if _, ok := err.(TokenRefreshError); !ok {
950 t.Fatal("adal: ServicePrincipalToken#EnsureFresh didn't return a TokenRefreshError")
951 }
952 }
953
954 func TestServicePrincipalTokenEnsureFreshSkipsIfFresh(t *testing.T) {
955 spt := newServicePrincipalToken()
956 setTokenToExpireIn(&spt.inner.Token, 1000*time.Second)
957
958 f := false
959 c := mocks.NewSender()
960 s := DecorateSender(c,
961 (func() SendDecorator {
962 return func(s Sender) Sender {
963 return SenderFunc(func(r *http.Request) (*http.Response, error) {
964 f = true
965 return mocks.NewResponse(), nil
966 })
967 }
968 })())
969 spt.SetSender(s)
970 err := spt.EnsureFresh()
971 if err != nil {
972 t.Fatalf("adal: ServicePrincipalToken#EnsureFresh returned an unexpected error (%v)", err)
973 }
974 if f {
975 t.Fatal("adal: ServicePrincipalToken#EnsureFresh invoked Refresh for fresh token")
976 }
977 }
978
979 func TestRefreshCallback(t *testing.T) {
980 callbackTriggered := false
981 spt := newServicePrincipalToken(func(Token) error {
982 callbackTriggered = true
983 return nil
984 })
985
986 expiresOn := strconv.Itoa(int(time.Now().Add(3600 * time.Second).Sub(date.UnixEpoch()).Seconds()))
987
988 sender := mocks.NewSender()
989 j := newTokenJSON(`"3600"`, expiresOn, "resource")
990 sender.AppendResponse(mocks.NewResponseWithContent(j))
991 spt.SetSender(sender)
992 err := spt.Refresh()
993 if err != nil {
994 t.Fatalf("adal: ServicePrincipalToken#Refresh returned an unexpected error (%v)", err)
995 }
996 if !callbackTriggered {
997 t.Fatalf("adal: RefreshCallback failed to trigger call callback")
998 }
999 }
1000
1001 func TestRefreshCallbackErrorPropagates(t *testing.T) {
1002 errorText := "this is an error text"
1003 spt := newServicePrincipalToken(func(Token) error {
1004 return fmt.Errorf(errorText)
1005 })
1006
1007 expiresOn := strconv.Itoa(int(time.Now().Add(3600 * time.Second).Sub(date.UnixEpoch()).Seconds()))
1008
1009 sender := mocks.NewSender()
1010 j := newTokenJSON(`"3600"`, expiresOn, "resource")
1011 sender.AppendResponse(mocks.NewResponseWithContent(j))
1012 spt.SetSender(sender)
1013 err := spt.Refresh()
1014
1015 if err == nil || !strings.Contains(err.Error(), errorText) {
1016 t.Fatalf("adal: RefreshCallback failed to propagate error")
1017 }
1018 }
1019
1020 // This demonstrates the danger of manual token without a refresh token
1021 func TestServicePrincipalTokenManualRefreshFailsWithoutRefresh(t *testing.T) {
1022 spt := newServicePrincipalTokenManual()
1023 spt.inner.Token.RefreshToken = ""
1024 err := spt.Refresh()
1025 if err == nil {
1026 t.Fatalf("adal: ServicePrincipalToken#Refresh should have failed with a ManualTokenSecret without a refresh token")
1027 }
1028 }
1029
1030 func TestNewServicePrincipalTokenFromMSI(t *testing.T) {
1031 const resource = "https://resource"
1032 cb := func(token Token) error { return nil }
1033
1034 spt, err := NewServicePrincipalTokenFromMSI("http://msiendpoint/", resource, cb)
1035 if err != nil {
1036 t.Fatalf("Failed to get MSI SPT: %v", err)
1037 }
1038
1039 // check some of the SPT fields
1040 if _, ok := spt.inner.Secret.(*ServicePrincipalMSISecret); !ok {
1041 t.Fatal("SPT secret was not of MSI type")
1042 }
1043
1044 if spt.inner.Resource != resource {
1045 t.Fatal("SPT came back with incorrect resource")
1046 }
1047
1048 if len(spt.refreshCallbacks) != 1 {
1049 t.Fatal("SPT had incorrect refresh callbacks.")
1050 }
1051 }
1052
1053 func TestNewServicePrincipalTokenFromMSIWithUserAssignedID(t *testing.T) {
1054 const (
1055 resource = "https://resource"
1056 userID = "abc123"
1057 )
1058 cb := func(token Token) error { return nil }
1059
1060 spt, err := NewServicePrincipalTokenFromMSIWithUserAssignedID("http://msiendpoint/", resource, userID, cb)
1061 if err != nil {
1062 t.Fatalf("Failed to get MSI SPT: %v", err)
1063 }
1064
1065 // check some of the SPT fields
1066 if _, ok := spt.inner.Secret.(*ServicePrincipalMSISecret); !ok {
1067 t.Fatal("SPT secret was not of MSI type")
1068 }
1069
1070 if spt.inner.Resource != resource {
1071 t.Fatal("SPT came back with incorrect resource")
1072 }
1073
1074 if len(spt.refreshCallbacks) != 1 {
1075 t.Fatal("SPT had incorrect refresh callbacks.")
1076 }
1077
1078 if spt.inner.ClientID != userID {
1079 t.Fatal("SPT had incorrect client ID")
1080 }
1081 }
1082
1083 func TestNewServicePrincipalTokenFromMSIWithIdentityResourceID(t *testing.T) {
1084 const (
1085 resource = "https://resource"
1086 identityResourceID = "/subscriptions/testSub/resourceGroups/testGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-identity"
1087 )
1088 cb := func(token Token) error { return nil }
1089
1090 spt, err := NewServicePrincipalTokenFromMSIWithIdentityResourceID("http://msiendpoint/", resource, identityResourceID, cb)
1091 if err != nil {
1092 t.Fatalf("Failed to get MSI SPT: %v", err)
1093 }
1094
1095 // check some of the SPT fields
1096 if _, ok := spt.inner.Secret.(*ServicePrincipalMSISecret); !ok {
1097 t.Fatal("SPT secret was not of MSI type")
1098 }
1099
1100 if spt.inner.Resource != resource {
1101 t.Fatal("SPT came back with incorrect resource")
1102 }
1103
1104 if len(spt.refreshCallbacks) != 1 {
1105 t.Fatal("SPT had incorrect refresh callbacks.")
1106 }
1107
1108 urlPathParameter := url.Values{}
1109 urlPathParameter.Set("mi_res_id", identityResourceID)
1110
1111 if !strings.Contains(spt.inner.OauthConfig.TokenEndpoint.RawQuery, urlPathParameter.Encode()) {
1112 t.Fatal("SPT tokenEndpoint should contains mi_res_id")
1113 }
1114 }
1115
1116 func TestNewServicePrincipalTokenFromManualTokenSecret(t *testing.T) {
1117 token := newToken()
1118 secret := &ServicePrincipalAuthorizationCodeSecret{
1119 ClientSecret: "clientSecret",
1120 AuthorizationCode: "code123",
1121 RedirectURI: "redirect",
1122 }
1123
1124 spt, err := NewServicePrincipalTokenFromManualTokenSecret(TestOAuthConfig, "id", "resource", token, secret, nil)
1125 if err != nil {
1126 t.Fatalf("Failed creating new SPT: %s", err)
1127 }
1128
1129 if !reflect.DeepEqual(token, spt.inner.Token) {
1130 t.Fatalf("Tokens do not match: %s, %s", token, spt.inner.Token)
1131 }
1132
1133 if !reflect.DeepEqual(secret, spt.inner.Secret) {
1134 t.Fatalf("Secrets do not match: %s, %s", secret, spt.inner.Secret)
1135 }
1136
1137 }
1138
1139 func TestGetVMEndpoint(t *testing.T) {
1140 endpoint, err := GetMSIVMEndpoint()
1141 if err != nil {
1142 t.Fatal("Coudn't get VM endpoint")
1143 }
1144
1145 if endpoint != msiEndpoint {
1146 t.Fatal("Didn't get correct endpoint")
1147 }
1148 }
1149
1150 func TestGetAppServiceEndpoint(t *testing.T) {
1151 const testEndpoint = "http://172.16.1.2:8081/msi/token"
1152 const aseSecret = "the_secret"
1153 if err := os.Setenv(msiEndpointEnv, testEndpoint); err != nil {
1154 t.Fatalf("os.Setenv: %v", err)
1155 }
1156 if err := os.Setenv(msiSecretEnv, aseSecret); err != nil {
1157 t.Fatalf("os.Setenv: %v", err)
1158 }
1159 defer func() {
1160 os.Unsetenv(msiEndpointEnv)
1161 os.Unsetenv(msiSecretEnv)
1162 }()
1163
1164 endpoint, err := GetMSIAppServiceEndpoint()
1165 if err != nil {
1166 t.Fatal("Coudn't get App Service endpoint")
1167 }
1168
1169 if endpoint != testEndpoint {
1170 t.Fatal("Didn't get correct endpoint")
1171 }
1172 }
1173
1174 func TestGetMSIEndpoint(t *testing.T) {
1175 const (
1176 testEndpoint = "http://172.16.1.2:8081/msi/token"
1177 testSecret = "DEADBEEF-BBBB-AAAA-DDDD-DDD000000DDD"
1178 )
1179
1180 // Test VM well-known endpoint is returned
1181 if err := os.Unsetenv(msiEndpointEnv); err != nil {
1182 t.Fatalf("os.Unsetenv: %v", err)
1183 }
1184
1185 if err := os.Unsetenv(msiSecretEnv); err != nil {
1186 t.Fatalf("os.Unsetenv: %v", err)
1187 }
1188
1189 vmEndpoint, err := GetMSIEndpoint()
1190 if err != nil {
1191 t.Fatal("Coudn't get VM endpoint")
1192 }
1193
1194 if vmEndpoint != msiEndpoint {
1195 t.Fatal("Didn't get correct endpoint")
1196 }
1197
1198 // Test App Service endpoint is returned
1199 if err := os.Setenv(msiEndpointEnv, testEndpoint); err != nil {
1200 t.Fatalf("os.Setenv: %v", err)
1201 }
1202
1203 if err := os.Setenv(msiSecretEnv, testSecret); err != nil {
1204 t.Fatalf("os.Setenv: %v", err)
1205 }
1206
1207 asEndpoint, err := GetMSIEndpoint()
1208 if err != nil {
1209 t.Fatal("Coudn't get App Service endpoint")
1210 }
1211
1212 if asEndpoint != testEndpoint {
1213 t.Fatal("Didn't get correct endpoint")
1214 }
1215
1216 if err := os.Unsetenv(msiEndpointEnv); err != nil {
1217 t.Fatalf("os.Unsetenv: %v", err)
1218 }
1219
1220 if err := os.Unsetenv(msiSecretEnv); err != nil {
1221 t.Fatalf("os.Unsetenv: %v", err)
1222 }
1223 }
1224
1225 func TestClientSecretWithASESet(t *testing.T) {
1226 if err := os.Setenv(msiEndpointEnv, "http://172.16.1.2:8081/msi/token"); err != nil {
1227 t.Fatalf("os.Setenv: %v", err)
1228 }
1229 if err := os.Setenv(msiSecretEnv, "the_secret"); err != nil {
1230 t.Fatalf("os.Setenv: %v", err)
1231 }
1232 defer func() {
1233 os.Unsetenv(msiEndpointEnv)
1234 os.Unsetenv(msiSecretEnv)
1235 }()
1236 spt := newServicePrincipalToken()
1237 if _, ok := spt.inner.Secret.(*ServicePrincipalMSISecret); ok {
1238 t.Fatal("should not have MSI secret for client secret token even when ASE is enabled")
1239 }
1240 }
1241
1242 func TestMarshalServicePrincipalNoSecret(t *testing.T) {
1243 spt := newServicePrincipalTokenManual()
1244 b, err := json.Marshal(spt)
1245 if err != nil {
1246 t.Fatalf("failed to marshal token: %+v", err)
1247 }
1248 var spt2 *ServicePrincipalToken
1249 err = json.Unmarshal(b, &spt2)
1250 if err != nil {
1251 t.Fatalf("failed to unmarshal token: %+v", err)
1252 }
1253 if !reflect.DeepEqual(spt, spt2) {
1254 t.Fatal("tokens don't match")
1255 }
1256 }
1257
1258 func TestMarshalServicePrincipalTokenSecret(t *testing.T) {
1259 spt := newServicePrincipalToken()
1260 b, err := json.Marshal(spt)
1261 if err != nil {
1262 t.Fatalf("failed to marshal token: %+v", err)
1263 }
1264 var spt2 *ServicePrincipalToken
1265 err = json.Unmarshal(b, &spt2)
1266 if err != nil {
1267 t.Fatalf("failed to unmarshal token: %+v", err)
1268 }
1269 if !reflect.DeepEqual(spt, spt2) {
1270 t.Fatal("tokens don't match")
1271 }
1272 }
1273
1274 func TestMarshalServicePrincipalCertificateSecret(t *testing.T) {
1275 spt := newServicePrincipalTokenCertificate(t)
1276 b, err := json.Marshal(spt)
1277 if err == nil {
1278 t.Fatal("expected error when marshalling certificate token")
1279 }
1280 var spt2 *ServicePrincipalToken
1281 err = json.Unmarshal(b, &spt2)
1282 if err == nil {
1283 t.Fatal("expected error when unmarshalling certificate token")
1284 }
1285 }
1286
1287 func TestMarshalServicePrincipalMSISecret(t *testing.T) {
1288 spt, err := newServicePrincipalTokenFromMSI("http://msiendpoint/", "https://resource", "", "")
1289 if err != nil {
1290 t.Fatalf("failed to get MSI SPT: %+v", err)
1291 }
1292 b, err := json.Marshal(spt)
1293 if err == nil {
1294 t.Fatal("expected error when marshalling MSI token")
1295 }
1296 var spt2 *ServicePrincipalToken
1297 err = json.Unmarshal(b, &spt2)
1298 if err == nil {
1299 t.Fatal("expected error when unmarshalling MSI token")
1300 }
1301 }
1302
1303 func TestMarshalServicePrincipalUsernamePasswordSecret(t *testing.T) {
1304 spt := newServicePrincipalTokenUsernamePassword(t)
1305 b, err := json.Marshal(spt)
1306 if err != nil {
1307 t.Fatalf("failed to marshal token: %+v", err)
1308 }
1309 var spt2 *ServicePrincipalToken
1310 err = json.Unmarshal(b, &spt2)
1311 if err != nil {
1312 t.Fatalf("failed to unmarshal token: %+v", err)
1313 }
1314 if !reflect.DeepEqual(spt, spt2) {
1315 t.Fatal("tokens don't match")
1316 }
1317 }
1318
1319 func TestMarshalServicePrincipalAuthorizationCodeSecret(t *testing.T) {
1320 spt := newServicePrincipalTokenAuthorizationCode(t)
1321 b, err := json.Marshal(spt)
1322 if err != nil {
1323 t.Fatalf("failed to marshal token: %+v", err)
1324 }
1325 var spt2 *ServicePrincipalToken
1326 err = json.Unmarshal(b, &spt2)
1327 if err != nil {
1328 t.Fatalf("failed to unmarshal token: %+v", err)
1329 }
1330 if !reflect.DeepEqual(spt, spt2) {
1331 t.Fatal("tokens don't match")
1332 }
1333 }
1334
1335 func TestMarshalServicePrincipalFederatedSecret(t *testing.T) {
1336 spt := newServicePrincipalTokenFederatedJwt(t)
1337 b, err := json.Marshal(spt)
1338 if err == nil {
1339 t.Fatal("expected error when marshalling certificate token")
1340 }
1341 var spt2 *ServicePrincipalToken
1342 err = json.Unmarshal(b, &spt2)
1343 if err == nil {
1344 t.Fatal("expected error when unmarshalling certificate token")
1345 }
1346 }
1347
1348 func TestMarshalInnerToken(t *testing.T) {
1349 spt := newServicePrincipalTokenManual()
1350 tokenJSON, err := spt.MarshalTokenJSON()
1351 if err != nil {
1352 t.Fatalf("failed to marshal token: %+v", err)
1353 }
1354
1355 testToken := newToken()
1356 testToken.RefreshToken = "refreshtoken"
1357
1358 testTokenJSON, err := json.Marshal(testToken)
1359 if err != nil {
1360 t.Fatalf("failed to marshal test token: %+v", err)
1361 }
1362
1363 if !reflect.DeepEqual(tokenJSON, testTokenJSON) {
1364 t.Fatalf("tokens don't match: %s, %s", tokenJSON, testTokenJSON)
1365 }
1366
1367 var t1 Token
1368 err = json.Unmarshal(tokenJSON, &t1)
1369 if err != nil {
1370 t.Fatalf("failed to unmarshal token: %+v", err)
1371 }
1372
1373 if !reflect.DeepEqual(t1, testToken) {
1374 t.Fatalf("tokens don't match: %s, %s", t1, testToken)
1375 }
1376 }
1377
1378 func TestNewMultiTenantServicePrincipalToken(t *testing.T) {
1379 cfg, err := NewMultiTenantOAuthConfig(TestActiveDirectoryEndpoint, TestTenantID, TestAuxTenantIDs, OAuthOptions{})
1380 if err != nil {
1381 t.Fatalf("autorest/adal: unexpected error while creating multitenant config: %v", err)
1382 }
1383 mt, err := NewMultiTenantServicePrincipalToken(cfg, "clientID", "superSecret", "resource")
1384 if err != nil {
1385 t.Fatalf("autorest/adal: unexpected error while creating multitenant service principal token: %v", err)
1386 }
1387 if !strings.Contains(mt.PrimaryToken.inner.OauthConfig.AuthorizeEndpoint.String(), TestTenantID) {
1388 t.Fatal("didn't find primary tenant ID in primary SPT")
1389 }
1390 for i := range mt.AuxiliaryTokens {
1391 if ep := mt.AuxiliaryTokens[i].inner.OauthConfig.AuthorizeEndpoint.String(); !strings.Contains(ep, fmt.Sprintf("%s%d", TestAuxTenantPrefix, i)) {
1392 t.Fatalf("didn't find auxiliary tenant ID in token %s", ep)
1393 }
1394 }
1395 }
1396
1397 func TestNewMultiTenantServicePrincipalTokenFromCertificate(t *testing.T) {
1398 cfg, err := NewMultiTenantOAuthConfig(TestActiveDirectoryEndpoint, TestTenantID, TestAuxTenantIDs, OAuthOptions{})
1399 if err != nil {
1400 t.Fatalf("autorest/adal: unexpected error while creating multitenant config: %v", err)
1401 }
1402 cert, key := newTestCertificate(t)
1403 mt, err := NewMultiTenantServicePrincipalTokenFromCertificate(cfg, "clientID", cert, key, "resource")
1404 if err != nil {
1405 t.Fatalf("autorest/adal: unexpected error while creating multitenant service principal token: %v", err)
1406 }
1407 if !strings.Contains(mt.PrimaryToken.inner.OauthConfig.AuthorizeEndpoint.String(), TestTenantID) {
1408 t.Fatal("didn't find primary tenant ID in primary SPT")
1409 }
1410 for i := range mt.AuxiliaryTokens {
1411 if ep := mt.AuxiliaryTokens[i].inner.OauthConfig.AuthorizeEndpoint.String(); !strings.Contains(ep, fmt.Sprintf("%s%d", TestAuxTenantPrefix, i)) {
1412 t.Fatalf("didn't find auxiliary tenant ID in token %s", ep)
1413 }
1414 }
1415 }
1416
1417 func TestMSIAvailableSuccess(t *testing.T) {
1418 c := mocks.NewSender()
1419 c.AppendResponse(mocks.NewResponse())
1420 if !MSIAvailable(context.Background(), c) {
1421 t.Fatal("unexpected false")
1422 }
1423 }
1424
1425 func TestMSIAvailableAppService(t *testing.T) {
1426 os.Setenv("MSI_ENDPOINT", "http://localhost")
1427 os.Setenv("MSI_SECRET", "super")
1428 defer func() {
1429 os.Unsetenv("MSI_ENDPOINT")
1430 os.Unsetenv("MSI_SECRET")
1431 }()
1432 c := mocks.NewSender()
1433 c.AppendResponse(mocks.NewResponse())
1434 available := MSIAvailable(context.Background(), c)
1435
1436 if !available {
1437 t.Fatal("expected MSI to be available")
1438 }
1439 }
1440
1441 func TestMSIAvailableIMDS(t *testing.T) {
1442 c := mocks.NewSender()
1443 c.AppendResponse(mocks.NewResponse())
1444 available := MSIAvailable(context.Background(), c)
1445
1446 if !available {
1447 t.Fatal("expected MSI to be available")
1448 }
1449 }
1450
1451 func TestMSIAvailableSlow(t *testing.T) {
1452 c := mocks.NewSender()
1453 // introduce a long response delay to simulate the endpoint not being available
1454 c.AppendResponseWithDelay(mocks.NewResponse(), 5*time.Second)
1455 if MSIAvailable(context.Background(), c) {
1456 t.Fatal("unexpected true")
1457 }
1458 }
1459
1460 func TestMSIAvailableFail(t *testing.T) {
1461 expectErr := "failed to make msi http request"
1462 c := mocks.NewSender()
1463 c.AppendAndRepeatError(fmt.Errorf(expectErr), 2)
1464 if MSIAvailable(context.Background(), c) {
1465 t.Fatal("unexpected true")
1466 }
1467 _, err := getMSIEndpoint(context.Background(), c)
1468 if !strings.Contains(err.Error(), "") {
1469 t.Fatalf("expected error: '%s', but got error '%s'", expectErr, err)
1470 }
1471 }
1472
1473 func newTokenJSON(expiresIn, expiresOn, resource string) string {
1474 nb, err := parseExpiresOn(expiresOn)
1475 if err != nil {
1476 panic(err)
1477 }
1478 return fmt.Sprintf(`{
1479 "access_token" : "accessToken",
1480 "expires_in" : %s,
1481 "expires_on" : "%s",
1482 "not_before" : "%s",
1483 "resource" : "%s",
1484 "token_type" : "Bearer",
1485 "refresh_token": "ABC123"
1486 }`,
1487 expiresIn, expiresOn, nb, resource)
1488 }
1489
1490 func newTokenJSONIntExpiresOn(expiresIn string, expiresOn int, resource string) string {
1491 return fmt.Sprintf(`{
1492 "access_token" : "accessToken",
1493 "expires_in" : %s,
1494 "expires_on" : %d,
1495 "not_before" : "%d",
1496 "resource" : "%s",
1497 "token_type" : "Bearer",
1498 "refresh_token": "ABC123"
1499 }`,
1500 expiresIn, expiresOn, expiresOn, resource)
1501 }
1502
1503 func newADFSTokenJSON(expiresIn int) string {
1504 return fmt.Sprintf(`{
1505 "access_token" : "accessToken",
1506 "expires_in" : %d,
1507 "token_type" : "Bearer"
1508 }`,
1509 expiresIn)
1510 }
1511
1512 func newTokenExpiresIn(expireIn time.Duration) *Token {
1513 t := newToken()
1514 return setTokenToExpireIn(&t, expireIn)
1515 }
1516
1517 func newTokenExpiresAt(expireAt time.Time) *Token {
1518 t := newToken()
1519 return setTokenToExpireAt(&t, expireAt)
1520 }
1521
1522 func expireToken(t *Token) *Token {
1523 return setTokenToExpireIn(t, 0)
1524 }
1525
1526 func setTokenToExpireAt(t *Token, expireAt time.Time) *Token {
1527 t.ExpiresIn = "3600"
1528 t.ExpiresOn = json.Number(strconv.FormatInt(int64(expireAt.Sub(date.UnixEpoch())/time.Second), 10))
1529 t.NotBefore = t.ExpiresOn
1530 return t
1531 }
1532
1533 func setTokenToExpireIn(t *Token, expireIn time.Duration) *Token {
1534 return setTokenToExpireAt(t, time.Now().Add(expireIn))
1535 }
1536
1537 func newServicePrincipalToken(callbacks ...TokenRefreshCallback) *ServicePrincipalToken {
1538 spt, _ := NewServicePrincipalToken(TestOAuthConfig, "id", "secret", "resource", callbacks...)
1539 return spt
1540 }
1541
1542 func newServicePrincipalTokenManual() *ServicePrincipalToken {
1543 token := newToken()
1544 token.RefreshToken = "refreshtoken"
1545 spt, _ := NewServicePrincipalTokenFromManualToken(TestOAuthConfig, "id", "resource", token)
1546 return spt
1547 }
1548
1549 func newTestCertificate(t *testing.T) (*x509.Certificate, *rsa.PrivateKey) {
1550 template := x509.Certificate{
1551 SerialNumber: big.NewInt(0),
1552 Subject: pkix.Name{CommonName: "test"},
1553 BasicConstraintsValid: true,
1554 }
1555 privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
1556 if err != nil {
1557 t.Fatal(err)
1558 }
1559 certificateBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &privateKey.PublicKey, privateKey)
1560 if err != nil {
1561 t.Fatal(err)
1562 }
1563 certificate, err := x509.ParseCertificate(certificateBytes)
1564 if err != nil {
1565 t.Fatal(err)
1566 }
1567 return certificate, privateKey
1568 }
1569
1570 func newServicePrincipalTokenCertificate(t *testing.T) *ServicePrincipalToken {
1571 certificate, privateKey := newTestCertificate(t)
1572
1573 spt, _ := NewServicePrincipalTokenFromCertificate(TestOAuthConfig, "id", certificate, privateKey, "resource")
1574 return spt
1575 }
1576
1577 func newServicePrincipalTokenUsernamePassword(t *testing.T) *ServicePrincipalToken {
1578 spt, _ := NewServicePrincipalTokenFromUsernamePassword(TestOAuthConfig, "id", "username", "password", "resource")
1579 return spt
1580 }
1581
1582 func newServicePrincipalTokenAuthorizationCode(t *testing.T) *ServicePrincipalToken {
1583 spt, _ := NewServicePrincipalTokenFromAuthorizationCode(TestOAuthConfig, "id", "clientSecret", "code", "http://redirectUri/getToken", "resource")
1584 return spt
1585 }
1586
1587 func newServicePrincipalTokenFederatedJwt(t *testing.T) *ServicePrincipalToken {
1588 token := jwt.New(jwt.SigningMethodHS256)
1589 token.Header["typ"] = "JWT"
1590 token.Claims = jwt.MapClaims{
1591 "aud": "testAudience",
1592 "iss": "id",
1593 "sub": "id",
1594 "nbf": time.Now().Unix(),
1595 "exp": time.Now().Add(24 * time.Hour).Unix(),
1596 }
1597
1598 signedString, err := token.SignedString([]byte("test key"))
1599 if err != nil {
1600 t.Fatal(err)
1601 }
1602 spt, _ := NewServicePrincipalTokenFromFederatedToken(TestOAuthConfig, "id", signedString, "resource")
1603 return spt
1604 }