2022-08-24 00:20:30 +00:00
|
|
|
// Copyright 2020-2022 the Pinniped contributors. All Rights Reserved.
|
2020-12-09 01:33:08 +00:00
|
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
|
2020-12-08 01:28:51 +00:00
|
|
|
package oidc
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
2020-12-09 16:04:58 +00:00
|
|
|
"net/url"
|
2020-12-08 01:28:51 +00:00
|
|
|
|
2021-01-20 17:54:44 +00:00
|
|
|
"github.com/coreos/go-oidc/v3/oidc"
|
2020-12-09 16:04:58 +00:00
|
|
|
"github.com/ory/fosite"
|
|
|
|
"github.com/ory/fosite/compose"
|
2020-12-08 18:17:03 +00:00
|
|
|
"github.com/ory/fosite/handler/oauth2"
|
|
|
|
"github.com/ory/fosite/handler/openid"
|
|
|
|
"github.com/pkg/errors"
|
2020-12-09 16:04:58 +00:00
|
|
|
)
|
2020-12-08 18:17:03 +00:00
|
|
|
|
2020-12-09 16:04:58 +00:00
|
|
|
const (
|
2022-08-24 21:45:55 +00:00
|
|
|
tokenTypeAccessToken = "urn:ietf:params:oauth:token-type:access_token" //nolint:gosec
|
|
|
|
tokenTypeJWT = "urn:ietf:params:oauth:token-type:jwt" //nolint:gosec
|
|
|
|
pinnipedTokenExchangeScope = "pinniped:request-audience" //nolint:gosec
|
2020-12-08 01:28:51 +00:00
|
|
|
)
|
|
|
|
|
2020-12-09 16:04:58 +00:00
|
|
|
type stsParams struct {
|
|
|
|
subjectAccessToken string
|
|
|
|
requestedAudience string
|
|
|
|
}
|
|
|
|
|
2020-12-08 01:28:51 +00:00
|
|
|
func TokenExchangeFactory(config *compose.Config, storage interface{}, strategy interface{}) interface{} {
|
2020-12-08 18:17:03 +00:00
|
|
|
return &TokenExchangeHandler{
|
2020-12-09 16:04:58 +00:00
|
|
|
idTokenStrategy: strategy.(openid.OpenIDConnectTokenStrategy),
|
|
|
|
accessTokenStrategy: strategy.(oauth2.AccessTokenStrategy),
|
|
|
|
accessTokenStorage: storage.(oauth2.AccessTokenStorage),
|
2020-12-08 18:17:03 +00:00
|
|
|
}
|
2020-12-08 01:28:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type TokenExchangeHandler struct {
|
2020-12-08 18:17:03 +00:00
|
|
|
idTokenStrategy openid.OpenIDConnectTokenStrategy
|
|
|
|
accessTokenStrategy oauth2.AccessTokenStrategy
|
|
|
|
accessTokenStorage oauth2.AccessTokenStorage
|
2020-12-08 01:28:51 +00:00
|
|
|
}
|
|
|
|
|
2021-03-01 19:08:41 +00:00
|
|
|
var _ fosite.TokenEndpointHandler = (*TokenExchangeHandler)(nil)
|
|
|
|
|
2020-12-08 01:28:51 +00:00
|
|
|
func (t *TokenExchangeHandler) HandleTokenEndpointRequest(ctx context.Context, requester fosite.AccessRequester) error {
|
2021-03-01 19:08:41 +00:00
|
|
|
if !t.CanHandleTokenEndpointRequest(requester) {
|
2020-12-08 18:17:03 +00:00
|
|
|
return errors.WithStack(fosite.ErrUnknownRequest)
|
|
|
|
}
|
2020-12-08 01:28:51 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *TokenExchangeHandler) PopulateTokenEndpointResponse(ctx context.Context, requester fosite.AccessRequester, responder fosite.AccessResponder) error {
|
2020-12-09 16:04:58 +00:00
|
|
|
// Skip this request if it's for a different grant type.
|
|
|
|
if err := t.HandleTokenEndpointRequest(ctx, requester); err != nil {
|
2020-12-08 18:17:03 +00:00
|
|
|
return errors.WithStack(err)
|
|
|
|
}
|
2020-12-09 16:04:58 +00:00
|
|
|
|
|
|
|
// Validate the basic RFC8693 parameters we support.
|
|
|
|
params, err := t.validateParams(requester.GetRequestForm())
|
2020-12-08 18:17:03 +00:00
|
|
|
if err != nil {
|
|
|
|
return errors.WithStack(err)
|
|
|
|
}
|
2020-12-09 16:04:58 +00:00
|
|
|
|
|
|
|
// Validate the incoming access token and lookup the information about the original authorize request.
|
|
|
|
originalRequester, err := t.validateAccessToken(ctx, requester, params.subjectAccessToken)
|
|
|
|
if err != nil {
|
|
|
|
return errors.WithStack(err)
|
2020-12-08 18:17:03 +00:00
|
|
|
}
|
2020-12-09 16:04:58 +00:00
|
|
|
|
2020-12-16 03:59:57 +00:00
|
|
|
// Require that the incoming access token has the pinniped:request-audience and OpenID scopes.
|
2020-12-09 23:15:50 +00:00
|
|
|
if !originalRequester.GetGrantedScopes().Has(pinnipedTokenExchangeScope) {
|
2022-08-24 00:20:30 +00:00
|
|
|
return errors.WithStack(fosite.ErrAccessDenied.WithHintf("Missing the %q scope.", pinnipedTokenExchangeScope))
|
2020-12-09 19:56:53 +00:00
|
|
|
}
|
2020-12-09 23:15:50 +00:00
|
|
|
if !originalRequester.GetGrantedScopes().Has(oidc.ScopeOpenID) {
|
2022-08-24 00:20:30 +00:00
|
|
|
return errors.WithStack(fosite.ErrAccessDenied.WithHintf("Missing the %q scope.", oidc.ScopeOpenID))
|
2020-12-09 23:15:50 +00:00
|
|
|
}
|
2020-12-09 19:56:53 +00:00
|
|
|
|
2020-12-09 16:04:58 +00:00
|
|
|
// Use the original authorize request information, along with the requested audience, to mint a new JWT.
|
|
|
|
responseToken, err := t.mintJWT(ctx, originalRequester, params.requestedAudience)
|
2020-12-08 18:17:03 +00:00
|
|
|
if err != nil {
|
|
|
|
return errors.WithStack(err)
|
|
|
|
}
|
2020-12-09 16:04:58 +00:00
|
|
|
|
|
|
|
// Format the response parameters according to RFC8693.
|
|
|
|
responder.SetAccessToken(responseToken)
|
2020-12-08 18:17:03 +00:00
|
|
|
responder.SetTokenType("N_A")
|
2020-12-09 19:56:53 +00:00
|
|
|
responder.SetExtra("issued_token_type", tokenTypeJWT)
|
2020-12-08 01:28:51 +00:00
|
|
|
return nil
|
|
|
|
}
|
2020-12-09 16:04:58 +00:00
|
|
|
|
|
|
|
func (t *TokenExchangeHandler) mintJWT(ctx context.Context, requester fosite.Requester, audience string) (string, error) {
|
|
|
|
downscoped := fosite.NewAccessRequest(requester.GetSession())
|
|
|
|
downscoped.Client.(*fosite.DefaultClient).ID = audience
|
|
|
|
return t.idTokenStrategy.GenerateIDToken(ctx, downscoped)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *TokenExchangeHandler) validateParams(params url.Values) (*stsParams, error) {
|
|
|
|
var result stsParams
|
|
|
|
|
|
|
|
// Validate some required parameters.
|
|
|
|
result.requestedAudience = params.Get("audience")
|
|
|
|
if result.requestedAudience == "" {
|
2022-08-24 00:20:30 +00:00
|
|
|
return nil, fosite.ErrInvalidRequest.WithHint("Missing 'audience' parameter.")
|
2020-12-09 16:04:58 +00:00
|
|
|
}
|
|
|
|
result.subjectAccessToken = params.Get("subject_token")
|
|
|
|
if result.subjectAccessToken == "" {
|
2022-08-24 00:20:30 +00:00
|
|
|
return nil, fosite.ErrInvalidRequest.WithHint("Missing 'subject_token' parameter.")
|
2020-12-09 16:04:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Validate some parameters with hardcoded values we support.
|
|
|
|
if params.Get("subject_token_type") != tokenTypeAccessToken {
|
2022-08-24 00:20:30 +00:00
|
|
|
return nil, fosite.ErrInvalidRequest.WithHintf("Unsupported 'subject_token_type' parameter value, must be %q.", tokenTypeAccessToken)
|
2020-12-09 16:04:58 +00:00
|
|
|
}
|
|
|
|
if params.Get("requested_token_type") != tokenTypeJWT {
|
2022-08-24 00:20:30 +00:00
|
|
|
return nil, fosite.ErrInvalidRequest.WithHintf("Unsupported 'requested_token_type' parameter value, must be %q.", tokenTypeJWT)
|
2020-12-09 16:04:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Validate that none of these unsupported parameters were sent. These are optional and we do not currently support them.
|
|
|
|
for _, param := range []string{
|
|
|
|
"resource",
|
|
|
|
"scope",
|
|
|
|
"actor_token",
|
|
|
|
"actor_token_type",
|
|
|
|
} {
|
|
|
|
if params.Get(param) != "" {
|
2022-08-24 00:20:30 +00:00
|
|
|
return nil, fosite.ErrInvalidRequest.WithHintf("Unsupported parameter %q.", param)
|
2020-12-09 16:04:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return &result, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *TokenExchangeHandler) validateAccessToken(ctx context.Context, requester fosite.AccessRequester, accessToken string) (fosite.Requester, error) {
|
2022-08-24 00:20:30 +00:00
|
|
|
// Look up the access token's stored session data.
|
2020-12-09 16:04:58 +00:00
|
|
|
signature := t.accessTokenStrategy.AccessTokenSignature(accessToken)
|
|
|
|
originalRequester, err := t.accessTokenStorage.GetAccessTokenSession(ctx, signature, requester.GetSession())
|
|
|
|
if err != nil {
|
2022-08-24 00:20:30 +00:00
|
|
|
// The access token was not found, or there was some other error while reading it.
|
|
|
|
return nil, fosite.ErrRequestUnauthorized.WithWrap(err).WithHint("Invalid 'subject_token' parameter value.")
|
|
|
|
}
|
|
|
|
// Validate the access token using its stored session data, which includes its expiration time.
|
|
|
|
if err := t.accessTokenStrategy.ValidateAccessToken(ctx, originalRequester, accessToken); err != nil {
|
|
|
|
return nil, errors.WithStack(err)
|
2020-12-09 16:04:58 +00:00
|
|
|
}
|
|
|
|
return originalRequester, nil
|
|
|
|
}
|
2021-03-01 19:08:41 +00:00
|
|
|
|
|
|
|
func (t *TokenExchangeHandler) CanSkipClientAuth(_ fosite.AccessRequester) bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *TokenExchangeHandler) CanHandleTokenEndpointRequest(requester fosite.AccessRequester) bool {
|
|
|
|
return requester.GetGrantTypes().ExactOne("urn:ietf:params:oauth:grant-type:token-exchange")
|
|
|
|
}
|