Changeset 8119


Ignore:
Timestamp:
24/08/12 14:51:54 (8 years ago)
Author:
pjkersha
Message:

Fixes to SLCS example, changed default token type to bearer

Location:
trunk/ndg_oauth
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/ndg_oauth/ndg_oauth_client/ndg/oauth/client/examples/__init__.py

    r8114 r8119  
    4646                    "</h2>"] 
    4747        if tok: 
    48             response.append("<pre>%s</pre>" % tok) 
     48            if isinstance(tok, basestring): 
     49                response.append("<pre>%s</pre>" % tok) 
     50            else: 
     51                for i in tok: 
     52                    response.append("<pre>%s</pre>" % i) 
    4953        else: 
    5054            response.append("<p>token not found</p>") 
  • trunk/ndg_oauth/ndg_oauth_client/ndg/oauth/client/examples/bearer_tok/bearer_tok_client_app.ini

    r8114 r8119  
    4040paste.filter_app_factory = ndg.oauth.client.wsgi.oauth2_client:Oauth2ClientMiddleware.filter_app_factory 
    4141oauth2.session_key = %(beakerSessionKeyName)s 
    42 oauth2.access_token_type=bearer 
     42# Allowed values: slcs (returns a cert as access token) or bearer (which  
     43# returns a UUID).  bearer is the default 
     44#oauth2.access_token_type=bearer 
     45 
    4346# Default: 
    4447#oauth2.oauth2_token_key = oauth2client.token 
  • trunk/ndg_oauth/ndg_oauth_client/ndg/oauth/client/examples/slcs/slcs_oauth_client_app.ini

    r8112 r8119  
    4141paste.filter_app_factory = ndg.oauth.client.wsgi.oauth2_client:Oauth2ClientMiddleware.filter_app_factory 
    4242oauth2.session_key = %(beakerSessionKeyName)s 
     43# Allowed values: slcs (returns a cert as access token) or bearer (which  
     44# returns a UUID).  bearer is the default 
     45oauth2.access_token_type=slcs 
    4346# Default: 
    4447#oauth2.oauth2_token_key = oauth2client.token 
    4548# OAuth client configuration 
    46 oauth2.client_cert = %(here)s/../config/pki/localhost.crt 
    47 oauth2.client_key = %(here)s/../config/pki/localhost.key 
    48 oauth2.ca_dir = %(here)s/../config/pki/ca 
     49oauth2.client_cert = %(here)s/../shared_config/pki/localhost.crt 
     50oauth2.client_key = %(here)s/../shared_config/pki/localhost.key 
     51oauth2.ca_dir = %(here)s/../shared_config/pki/ca 
    4952 
    5053# ca_cert_file = 
     
    5760 
    5861[app:App] 
    59 paste.app_factory = ndg.oauth.client.examples.wsgi.wsgi_test_app:WsgiTestApp.app_factory 
     62paste.app_factory = ndg.oauth.client.examples:WsgiTestApp.app_factory 
    6063 
    6164# WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT* 
  • trunk/ndg_oauth/ndg_oauth_client/ndg/oauth/client/wsgi/oauth2_client.py

    r8112 r8119  
    6565     
    6666    propertyDefaults = { 
    67         ACCESS_TOKEN_TYPE_OPTION: 'slcs', 
     67        ACCESS_TOKEN_TYPE_OPTION: 'bearer', 
    6868        AUTHENTICATION_COMPLETE_OPTION: '', 
    6969        AUTHENTICATION_TRIGGER_OPTION: AUTHENTICATION_TRIGGER_ALWAYS, 
     
    111111        self._set_configuration(prefix, local_conf) 
    112112        if self.access_token_type == 'slcs': 
    113             log.debug("Setting client as Oauth2MyProxyClient") 
     113            log.debug("Setting client as Oauth2MyProxyClient (SLCS)") 
    114114            self._oauth_client_class = Oauth2MyProxyClient 
    115115            self._token_retriever_class = MyProxyTokenRetriever 
    116116        else: 
    117             log.debug("Setting client as Oauth2Client") 
     117            log.debug("Setting client as Oauth2Client (Bearer token)") 
    118118            self._oauth_client_class = Oauth2Client 
    119119            self._token_retriever_class = TokenRetriever 
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/examples/bearer_tok/bearer_tok_server_app.ini

    r8118 r8119  
    2424           repoze_who 
    2525           AuthnForm 
    26 #           MyProxyClient 
    2726           OAuth2Authz 
    2827           OAuth2ServerFilterApp 
     
    6968authenticationForm.layout.helpIcon = /layout/help.png 
    7069 
    71  
    72 [filter:MyProxyClient] 
    73 paste.filter_app_factory = myproxy.server.wsgi.middleware:MyProxyClientMiddleware.filter_app_factory 
    74 # Default environ key for MyProxy client 
    75 # myproxy.client.clientEnvKeyName=myproxy.server.wsgi.middleware.MyProxyClientMiddleware.myProxyClient 
    76  
    77 # MyProxy server which this MyProxy WSGI app is a client to.  Set here to the  
    78 # fully qualified domain name or else set the MYPROXY_SERVER environment 
    79 # variable.  See the documentation for the MyProxyClient egg for details 
    80 myproxy.client.hostname = myproxy.ac.uk 
    81 #myproxy.client.port = 7512 
    82  
    83 # CA Certificate directory to enable this application to trust the MyProxy 
    84 # server that it fronts e.g. set to /etc/grid-security/certificates.  For these 
    85 # tests set to local ca directory 
    86 myproxy.client.caCertDir = %(here)s/ca 
    87  
    8870[filter:OAuth2Authz] 
    8971# Authorization filter configuration options - defaults are commented out. 
     
    10991# OAuth2 server configuration options - defaults are commented out. 
    11092#oauth2server.access_token_lifetime=86400 
    111 # Allowed values: slcs (default) or bearer (which returns a UUID) 
     93# Allowed values: slcs (returns a cert as access token) or bearer (which  
     94# returns a UUID).  bearer is the default 
    11295#oauth2server.access_token_type=slcs 
    113 oauth2server.access_token_type=bearer 
     96#oauth2server.access_token_type=bearer 
    11497#oauth2server.authorization_grant_lifetime=600 
    11598oauth2server.base_url_path=/oauth 
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/lib/authorization_server.py

    r8057 r8119  
    1 """OAuth 2.0 WSGI server middleware providing MyProxy certificates as access tokens 
     1"""OAuth 2.0 WSGI server middleware implements support for basic bearer  
     2tokens and also X.509 certificates as access tokens 
     3 
     4OAuth 2.0 Authorisation Server 
    25""" 
    36__author__ = "R B Wilkinson" 
     
    2225 
    2326log = logging.getLogger(__name__) 
     27 
    2428 
    2529class AuthorizationServer(object): 
     
    108112            for param in required_parameters: 
    109113                if param not in params: 
    110                     log.error("Missing request parameter %s from params: %s" % (param, params)) 
    111                     raise OauthException('invalid_request', ("Missing request parameter: %s" % param)) 
     114                    log.error("Missing request parameter %s from params: %s", 
     115                              param, params) 
     116                    raise OauthException('invalid_request',  
     117                                         "Missing request parameter: %s" % param) 
    112118 
    113119            if not client_authorized: 
    114                 raise OauthException('access_denied', 'User has declined authorization') 
     120                raise OauthException('access_denied',  
     121                                     'User has declined authorization') 
    115122 
    116123            response_type = params.get('response_type', None) 
    117124            if response_type != 'code': 
    118                 raise OauthException('unsupported_response_type', ("Response type %s not supported" % response_type)) 
    119  
    120             client_error = self.client_register.is_valid_client(auth_request.client_id, auth_request.redirect_uri) 
     125                raise OauthException('unsupported_response_type',  
     126                                     "Response type %s not supported" %  
     127                                     response_type) 
     128 
     129            client_error = self.client_register.is_valid_client( 
     130                                                        auth_request.client_id,  
     131                                                        auth_request.redirect_uri) 
    121132            if client_error: 
    122133                log.error("Invalid client: %s", client_error) 
     
    127138            client = self.client_register.register[auth_request.client_id] 
    128139            if len(client.redirect_uris) != 1 and not auth_request.redirect_uri: 
    129                 log.error("An authorization request has been made without a return URI") 
    130                 return (None, httplib.BAD_REQUEST, 'An authorization request has been made without a return URI.') 
     140                log.error("An authorization request has been made without a " 
     141                          "return URI") 
     142                return (None,  
     143                        httplib.BAD_REQUEST,  
     144                        ('An authorization request has been made without a ' 
     145                        'return URI.')) 
    131146 
    132147            # Preconditions satisfied - generate grant. 
    133             (grant, code) = self.authorizer.generate_authorization_grant(auth_request, request) 
     148            (grant, code) = self.authorizer.generate_authorization_grant( 
     149                                                                auth_request,  
     150                                                                request) 
    134151            auth_response = AuthorizeResponse(code, auth_request.state) 
    135152 
    136153            if not self.authorization_grant_register.add_grant(grant): 
    137154                log.error('Registering grant failed') 
    138                 raise OauthException('server_error', 'Authorization grant could not be created') 
     155                raise OauthException('server_error',  
     156                                     'Authorization grant could not be created') 
    139157        except OauthException, exc: 
    140             log.error("Redirecting back after error: %s - %s", exc.error, exc.error_description) 
    141             return self._redirect_after_authorize(auth_request, None, exc.error, exc.error_description) 
     158            log.error("Redirecting back after error: %s - %s",  
     159                      exc.error, exc.error_description) 
     160             
     161            return self._redirect_after_authorize(auth_request, None, exc.error, 
     162                                                  exc.error_description) 
    142163 
    143164        log.debug("Redirecting back after successful authorization.") 
    144165        return self._redirect_after_authorize(auth_request, auth_response) 
    145166 
    146     def _redirect_after_authorize(self, auth_request, auth_response=None, error=None, error_description=None): 
     167    def _redirect_after_authorize(self,  
     168                                  auth_request,  
     169                                  auth_response=None,  
     170                                  error=None,  
     171                                  error_description=None): 
    147172        """Redirects to the redirect URI after the authorization process as 
    148173        completed. 
     
    167192        # Get the redirect URI. 
    168193        client = self.client_register.register[auth_request.client_id] 
    169         redirect_uri = (auth_request.redirect_uri if auth_request.redirect_uri else client.redirect_uris[0]) 
     194        redirect_uri = ( 
     195            auth_request.redirect_uri if auth_request.redirect_uri else \ 
     196                client.redirect_uris[0] 
     197        ) 
    170198        if not redirect_uri: 
    171199            return(None, httplib.BAD_REQUEST, 
     
    174202        # Redirect back to client with authorization code or error. 
    175203        if error: 
    176             url_parameters = [('error', error), ('error_description', error_description)] 
     204            url_parameters = [('error', error),  
     205                              ('error_description', error_description)] 
    177206        else: 
    178207            url_parameters = [('code', auth_response.code)] 
    179         full_redirect_uri = self._make_combined_url(redirect_uri, url_parameters, auth_request.state) 
     208             
     209        full_redirect_uri = self._make_combined_url(redirect_uri,  
     210                                                    url_parameters,  
     211                                                    auth_request.state) 
    180212        log.debug("Redirecting to URI: %s", full_redirect_uri) 
    181213        return(full_redirect_uri, None, None) 
     
    203235        if parameters: 
    204236            query_string = urllib.urlencode(parameters) 
    205             url_parts.extend([('&' if (sep_with_ampersand) else '?'), query_string]) 
     237            url_parts.extend([('&' if (sep_with_ampersand) else '?'),  
     238                              query_string]) 
    206239            sep_with_ampersand = True 
    207240 
     
    257290 
    258291        try: 
    259             # Parameters should only be taken from the body, not the URL query string. 
     292            # Parameters should only be taken from the body, not the URL query  
     293            # string. 
    260294            params = request.POST 
    261295            self.check_request(request, params, post_only=True) 
     
    272306            for param in required_parameters: 
    273307                if param not in params: 
    274                     log.error("Missing request parameter %s from inputs: %s" % (param, params)) 
    275                     raise OauthException('invalid_request', ("Missing request parameter: %s" % param)) 
     308                    log.error("Missing request parameter %s from inputs: %s", 
     309                              param, params) 
     310                    raise OauthException('invalid_request',  
     311                                    ("Missing request parameter: %s" % param)) 
    276312 
    277313        except OauthException, exc: 
    278             return (self._error_access_token_response(exc.error, exc.error_description), None, None) 
     314            return (self._error_access_token_response(exc.error,  
     315                                                      exc.error_description),  
     316                    None, None) 
    279317 
    280318        token_request = AccessTokenRequest(params.get('grant_type', None), 
     
    288326                request) 
    289327        except OauthException, exc: 
    290             return (self._error_access_token_response(exc.error, exc.error_description), None, None) 
     328            return (self._error_access_token_response(exc.error,  
     329                                                      exc.error_description),  
     330                    None, None) 
    291331 
    292332        if response: 
    293333            return(self._access_token_response(response), None, None) 
    294334        else: 
    295             return(None, httplib.INTERNAL_SERVER_ERROR, 'Access token generation failed.') 
     335            return(None, httplib.INTERNAL_SERVER_ERROR,  
     336                   'Access token generation failed.') 
    296337 
    297338    def _access_token_response(self, resp): 
     
    349390        """ 
    350391        if request.scheme != 'https': 
    351             raise OauthException('invalid_request', 'Transport layer security must be used for this request.') 
     392            raise OauthException('invalid_request',  
     393                                 'Transport layer security must be used for ' 
     394                                 'this request.') 
    352395 
    353396        if post_only and (request.method != 'POST'): 
    354             raise OauthException('invalid_request', 'HTTP POST method must be used for this request.') 
     397            raise OauthException('invalid_request',  
     398                                 'HTTP POST method must be used for this ' 
     399                                 'request.') 
    355400 
    356401        # Check for duplicate parameters. 
     
    361406        for key, count in param_counts.iteritems(): 
    362407            if count > 1: 
    363                 raise OauthException('invalid_request', ('Parameter "%s" is repeated.' % key)) 
     408                raise OauthException('invalid_request',  
     409                                     'Parameter "%s" is repeated.' % key) 
    364410        return 
    365411 
     
    490536            if error_description: 
    491537                return ('unauthorized_client', error_description) 
     538             
    492539        return (None, None) 
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/lib/resource_request/myproxy_cert_request.py

    r8057 r8119  
    1313 
    1414log = logging.getLogger(__name__) 
     15 
    1516 
    1617class MyproxyCertRequest(object): 
  • trunk/ndg_oauth/ndg_oauth_server/ndg/oauth/server/wsgi/oauth2_server.py

    r8106 r8119  
    1 """OAuth 2.0 WSGI server middleware providing MyProxy certificates as access tokens 
     1"""OAuth 2.0 WSGI server middleware implements Authorisation and Resource  
     2server functionality.  It includes support for basic bearer tokens and also  
     3a customisation - X.509 certificates as access tokens - for use with an SLCS 
     4(Short-lived Credential Service) 
    25""" 
    36__author__ = "R B Wilkinson" 
     
    3235log = logging.getLogger(__name__) 
    3336 
     37 
    3438class Oauth2ServerMiddleware(object): 
    3539    """ 
    36     WSGI OAuth 2.0 server. 
     40    WSGI OAuth 2.0 server implements Authorisation and Resource server functions 
     41     
    3742    Requires: 
    3843    o Beaker session 
    3944    o An authentication provider that sets the user's ID in the environ, e.g., 
    4045      repose.who 
    41     o MyProxyClientMiddleware 
     46    o MyProxyClientMiddleware (ONLY required for X.509 cert based token 
     47      generation used with SLCS config) 
    4248    o Middleware to set user's decisions for authorization of OAuth clients in 
    4349      the environ, e.g., ndg.oauth.server.wsgi.authorization_filter. 
     
    4551    PARAM_PREFIX = 'oauth2server.' 
    4652    CERT_DN_ENVIRON_KEY = 'SSL_CLIENT_S_DN' 
     53     
    4754    # Configuration options 
    4855    ACCESS_TOKEN_LIFETIME_OPTION = 'access_token_lifetime' 
     
    6370    propertyDefaults = { 
    6471        ACCESS_TOKEN_LIFETIME_OPTION: 86400, 
    65         ACCESS_TOKEN_TYPE_OPTION: 'slcs', 
     72        ACCESS_TOKEN_TYPE_OPTION: 'bearer', 
    6673        AUTHORIZATION_GRANT_LIFETIME_OPTION: 600, 
    6774        BASE_URL_PATH_OPTION: '', 
     
    105112        if self.access_token_type == 'bearer': 
    106113            # Simple bearer token configuration. 
    107             access_token_generator = BearerTokenGenerator(self.access_token_lifetime_seconds, self.access_token_type) 
     114            access_token_generator = BearerTokenGenerator( 
     115                                        self.access_token_lifetime_seconds,  
     116                                        self.access_token_type) 
     117             
    108118        elif self.access_token_type == 'slcs': 
    109             # Configure authorization server to use MyProxy certificates as access tokens. 
     119            # Configure authorization server to use MyProxy certificates as  
     120            # access tokens. 
    110121            access_token_generator = MyProxyCertTokenGenerator( 
    111                 self.access_token_lifetime_seconds, self.access_token_type, 
     122                self.access_token_lifetime_seconds,  
     123                self.access_token_type, 
    112124                certificate_request_parameter=self.certificate_request_parameter, 
    113125                myproxy_client_env_key=self.myproxy_client_env_key, 
    114126                myproxy_global_password=self.myproxy_global_password, 
    115                 user_identifier_grant_data_key=self.USER_IDENTIFIER_GRANT_DATA_KEY) 
     127                user_identifier_grant_data_key=\ 
     128                    self.USER_IDENTIFIER_GRANT_DATA_KEY) 
    116129        else: 
    117130            raise ValueError("Invalid configuration value %s for %s" % 
    118131                             (self.access_token_type, 
    119132                              self.ACCESS_TOKEN_TYPE_OPTION)) 
     133             
    120134        # Store user identifier with grant - this isn't needed for the OAuth 
    121135        # protocol but is needed to return certificates using MyProxy. 
     
    129143        if self.client_authentication_method == 'certificate': 
    130144            client_authenticator = CertificateClientAuthenticator() 
     145             
    131146        elif self.client_authentication_method == 'none': 
    132147            client_authenticator = NoopClientAuthenticator() 
     148             
    133149        else: 
    134150            raise ValueError("Invalid configuration value %s for %s" % 
     
    205221        user = req.environ.get(self.user_identifier_env_key) 
    206222        if not user: 
    207             log.debug("%s not in environ - authentication required" % self.user_identifier_env_key) 
     223            log.debug("%s not in environ - authentication required", 
     224                      self.user_identifier_env_key) 
    208225            start_response(self._get_http_status_string(httplib.UNAUTHORIZED), []) 
    209226            return [] 
     
    219236 
    220237        # Request authorization grant. 
    221         (redirect_uri, error, error_description) = self._authorizationServer.authorize(req, client_authorized) 
     238        (redirect_uri,  
     239         error,  
     240         error_description) = self._authorizationServer.authorize(req,  
     241                                                            client_authorized) 
    222242        if error: 
    223243            self._error_response(error, error_description, start_response) 
     
    247267        @param req: HTTP request object 
    248268        """ 
    249         client_authorizations = req.environ.get(self.client_authorizations_env_key) 
     269        client_authorizations = req.environ.get( 
     270                                            self.client_authorizations_env_key) 
    250271        client_id = req.params.get('client_id') 
    251272        scope = req.params.get('scope') 
    252273        if not client_authorizations: 
    253274            client_authorized = None 
    254             log.debug("Client authorization register not found in environ (key %s).", self.client_authorizations_env_key) 
    255         else: 
    256             client_authorized = client_authorizations.is_client_authorized_by_user(user, client_id, scope) 
     275            log.debug("Client authorization register not found in environ " 
     276                      "(key %s).", self.client_authorizations_env_key) 
     277        else: 
     278            client_authorized = \ 
     279                client_authorizations.is_client_authorized_by_user(user,  
     280                                                                   client_id,  
     281                                                                   scope) 
    257282        if client_authorized is None: 
    258             log.debug("Client not authorized by user (client_id: %s  scope: %s  user: %s).", client_id, scope, user) 
     283            log.debug("Client not authorized by user (client_id: %s  scope: %s" 
     284                      "  user: %s).", client_id, scope, user) 
     285             
    259286            url_params = {'client_id': client_id, 
    260287                          'scope': scope, 
     
    264291                              urllib.urlencode(url_params))) 
    265292            return (None, url) 
     293         
    266294        return (client_authorized, None) 
    267295 
     
    300328            ('Pragma', 'no-store') 
    301329        ] 
    302         status_str = self._get_http_status_string(error_status if error_status else httplib.OK) 
     330        status_str = self._get_http_status_string( 
     331                                error_status if error_status else httplib.OK) 
    303332        if error_status: 
    304333            log.debug("Error obtaining access token: %s - %s", status_str, 
     
    321350        @return: WSGI response 
    322351        """ 
    323         (response, error_status, error_description) = self._authorizationServer.check_token(req) 
     352        response, error_status = self._authorizationServer.check_token(req)[0:2] 
    324353        if response is None: 
    325354            response = '' 
     
    330359            ('Pragma', 'no-store') 
    331360        ] 
    332         status_str = self._get_http_status_string(error_status if error_status else httplib.OK) 
     361        status_str = self._get_http_status_string( 
     362                                error_status if error_status else httplib.OK) 
    333363 
    334364        start_response(status_str, headers) 
Note: See TracChangeset for help on using the changeset viewer.