Python discover.OpenIDServiceEndpoint类代码示例

 def create_sreg_response(self, fullname='', email='', identifier=''):
     message = Message(OPENID2_NS)
     message.setArg(SREG_NS, "fullname", fullname)
     message.setArg(SREG_NS, "email", email)
     endpoint = OpenIDServiceEndpoint()
     endpoint.display_identifier = identifier
     return SuccessResponse(endpoint, message, signed_fields=message.toPostArgs().keys())

 def begin(self, url):
     endpoint = OpenIDServiceEndpoint()
     endpoint.claimed_id = 'oid'
     endpoint.server_url = 'http://localhost/'
     endpoint.type_uris = [OPENID_2_0_TYPE]
     auth_request = consumer.AuthRequest(endpoint, None)
     return auth_request

 def v1endpoint(self, port):
     """Return an OpenID 1.1 OpenIDServiceEndpoint for the server."""
     base = "http://%s:%s" % (socket.getfqdn('127.0.0.1'), port)
     ep = OpenIDServiceEndpoint()
     ep.claimed_id = base + "/id/bob"
     ep.server_url = base + "/openidserver"
     ep.type_uris = [OPENID_1_1_TYPE]
     return ep

    def make_openid_response(self, sreg_args=None, teams_args=None):
        endpoint = OpenIDServiceEndpoint()
        endpoint.claimed_id = 'some-id'

        message = Message(OPENID2_NS)
        if sreg_args is not None:
            for key, value in sreg_args.items():
                message.setArg(SREG_NS, key, value)
        if teams_args is not None:
            for key, value in teams_args.items():
                message.setArg(TEAMS_NS, key, value)
        response = SuccessResponse(
            endpoint, message, signed_fields=message.toPostArgs().keys())
        return response

def associate(services, url):
    '''Create an association (OpenID section 8) between RP and OP.
    Return response as a dictionary.'''
    req_data = {
        'openid.ns':"http://specs.openid.net/auth/2.0",
        'openid.mode':"associate",
        'openid.assoc_type':"HMAC-SHA1",
        'openid.session_type':"no-encryption",
        }
    if url.startswith('http:'):
        # Use DH exchange
        req_data['openid.session_type'] = "DH-SHA1"
        # Private key: random number between 1 and dh_prime-1
        priv = random.SystemRandom().randrange(1, dh_prime - 1)
        # Public key: 2^priv mod prime
        pubkey = pow(2L, priv, dh_prime)
        dh_public_base64 = base64.b64encode(btwoc(pubkey))
        # No need to send key and generator
        req_data['openid.dh_consumer_public'] = dh_public_base64
    if is_compat_1x(services):
        # 14.2.1: clear session_type in 1.1 compatibility mode
        if req_data['openid.session_type'] == "no-encryption":
            req_data['openid.session_type'] = ''
        del req_data['openid.ns']
    res = urllib.urlopen(url, b(urllib.urlencode(req_data)))
    try:
        if res.getcode() != 200:
            raise ValueError("OpenID provider refuses connection with status %s" % res.getcode())
        data = parse_response(res.read())
    except ValueError:
        endpoint = OpenIDServiceEndpoint.fromOPEndpointURL(url)
        store = MemoryStore()
        consumer = GenericConsumer(store)
        try:
            assoc = consumer._requestAssociation(endpoint, req_data['openid.assoc_type'], req_data['openid.session_type'])
            data = {
                'assoc_handle': assoc.handle,
                'expires_in': assoc.lifetime,
                'mac_key': oidutil.toBase64(assoc.secret),
            }
        except ServerError:
            data = {
                'error': 'Server %s refused its suggested association type: session_type=%s, assoc_type=%s' % (url, req_data['openid.assoc_type'], req_data['openid.session_type']),
            }
    if 'error' in data:
        raise ValueError, "associate failed: "+data['error']
    if url.startswith('http:'):
        enc_mac_key = b(data.get('enc_mac_key'))
        if not enc_mac_key:
            raise ValueError, "Provider protocol error: not using DH-SHA1"
        enc_mac_key = base64.b64decode(enc_mac_key)
        dh_server_public = unbtwoc(base64.b64decode(b(data['dh_server_public'])))
        # shared secret: sha1(2^(server_priv*priv) mod prime) xor enc_mac_key
        shared_secret = btwoc(pow(dh_server_public, priv, dh_prime))
        shared_secret = hashlib.sha1(shared_secret).digest()
        if len(shared_secret) != len(enc_mac_key):
            raise ValueError, "incorrect DH key size"
        # Fake mac_key result
        data['mac_key'] = b(base64.b64encode(string_xor(enc_mac_key, shared_secret)))
    return data

def openid2_get_redirect(request, provider, callback, scope, mode):
	xrds = urllib.urlopen(providers[provider]["xrds"])
	if xrds.getcode() != 200:
		raise Exception("OpenID Failed: Invalid response from " + providers[provider]["displayname"] + " on obtaining a XRDS information: " + xrds.read())
	xrds = xrds.read()
	
	from openid.consumer.consumer import Consumer
	from openid.consumer.discover import OpenIDServiceEndpoint
	from openid.store.memstore import MemoryStore
	
	service =  OpenIDServiceEndpoint.fromXRDS(providers[provider]["xrds"], xrds)[0]
	
	consumer = Consumer(request.session, MemoryStore())
	
	auth = consumer.beginWithoutDiscovery(service)
	
	if "extensions" in providers[provider]:
		for ext, d in providers[provider]["extensions"].iteritems():
			for k, v in d.iteritems():
				auth.addExtensionArg(ext, k, v) 
				
	if mode == "compact": # works with Google
		auth.addExtensionArg("http://specs.openid.net/extensions/ui/1.0", "mode", "popup")
	
	return auth.redirectURL(realm=SITE_ROOT_URL, return_to=callback)

    def test_sreg(self):
        authreq = self.consumer.beginWithoutDiscovery(
            OpenIDServiceEndpoint.fromOPEndpointURL('http://example.com/endpoint/'))

        sreg_request = sreg.SRegRequest(required=['nickname'])
        authreq.addExtension(sreg_request)

        url = authreq.redirectURL(
            'http://localhost/',
            return_to='http://localhost/')

        self.client.post('/login/')

        response = self.client.open(make_builder(url))

        self.assertEqual(response.status_code, 302)
        parsed = urlparse(response.headers['LOCATION'])

        info = self.consumer.complete(
            dict(parse_qsl(parsed.query)),
            response.headers['LOCATION'])

        self.assertIsInstance(info, SuccessResponse)


        sreg_resp = sreg.SRegResponse.fromSuccessResponse(info)
        self.assertEqual(sreg_resp['nickname'], 'user')

    def setUp(self):
        CatchLogs.setUp(self)
        self.consumer = ErrorRaisingConsumer(store=None)

        self.endpoint = OpenIDServiceEndpoint()
        self.endpoint.type_uris = [OPENID_2_0_TYPE]
        self.endpoint.server_url = 'bogus'

    def make_endpoint(self, protocol_uri, claimed_id, local_id=None):
        """Create an endpoint for use with `Consumer.beginWithoutDiscovery`.

        :arg protocol_uri: The URI for the OpenID protocol version.  This
            should be one of the OPENID_X_Y_TYPE constants.
        :arg claimed_id: The claimed identity URL for the endpoint.
        :arg local_id: The OP local identifier for the endpoint.  If this
            argument is not provided, it defaults to claimed_id.
        """
        msg = "Unexpected protocol URI: %s" % protocol_uri
        assert protocol_uri in OPENID_TYPES, msg

        endpoint = OpenIDServiceEndpoint()
        endpoint.type_uris = [protocol_uri]
        endpoint.server_url = self.base_openid_url
        endpoint.claimed_id = claimed_id
        endpoint.local_id = local_id or claimed_id
        return endpoint

def make_endpoint(protocol_uri, claimed_id, local_id=None):
    """Create an endpoint for use with `Consumer.beginWithoutDiscovery`.

    :arg protocol_uri: The URI for the OpenID protocol version.  This
        should be one of the OPENID_X_Y_TYPE constants.
    :arg claimed_id: The claimed identity URL for the endpoint.
    :arg local_id: The OP local identifier for the endpoint.  If this
        argument is not provided, it defaults to claimed_id.
    """
    assert protocol_uri in [
        OPENID_1_0_TYPE, OPENID_1_1_TYPE, OPENID_2_0_TYPE], (
        "Unexpected protocol URI: %s" % protocol_uri)

    endpoint = OpenIDServiceEndpoint()
    endpoint.type_uris = [protocol_uri]
    endpoint.server_url = get_requested_server_url(claimed_id)
    endpoint.claimed_id = claimed_id
    endpoint.local_id = local_id or claimed_id
    return endpoint

    def test_setup_redirect(self):
        authreq = self.consumer.beginWithoutDiscovery(
            OpenIDServiceEndpoint.fromOPEndpointURL('http://example.com/endpoint/'))

        url = authreq.redirectURL(
            'http://localhost/',
            return_to='http://localhost/')

        response = self.client.open(make_builder(url))

        self.assertEqual(response.status_code, 302)
        self.assertEqual(
            parse_qs(urlparse(response.headers['LOCATION']).query)['next'][0],
            url)

def _verifyDiscoveryResultsOpenID2(self, resp_msg, endpoint):
    to_match = OpenIDServiceEndpoint()
    to_match.type_uris = [OPENID_2_0_TYPE]
    to_match.claimed_id = resp_msg.getArg(OPENID2_NS, 'claimed_id')
    to_match.local_id = resp_msg.getArg(OPENID2_NS, 'identity')

    # Raises a KeyError when the op_endpoint is not present
    to_match.server_url = resp_msg.getArg(
        OPENID2_NS, 'op_endpoint', no_default)

    # claimed_id and identifier must both be present or both
    # be absent
    if (to_match.claimed_id is None and
        to_match.local_id is not None):
        raise consumer.ProtocolError(
            'openid.identity is present without openid.claimed_id')

    elif (to_match.claimed_id is not None and
          to_match.local_id is None):
        raise consumer.ProtocolError(
            'openid.claimed_id is present without openid.identity')

    # This is a response without identifiers, so there's really no
    # checking that we can do, so return an endpoint that's for
    # the specified `openid.op_endpoint'
    elif to_match.claimed_id is None:
        return OpenIDServiceEndpoint.fromOPEndpointURL(to_match.server_url)

    # The claimed ID doesn't match, so we have to do discovery
    # again. This covers not using sessions, OP identifier
    # endpoints and responses that didn't match the original
    # request.
    if to_match.server_url.startswith(u'https://www.google.com/a/'):
        import urllib
        claimed_id = u'https://www.google.com/accounts/o8/user-xrds?uri=%s' % urllib.quote_plus(to_match.claimed_id)
    else:
        claimed_id = to_match.claimed_id

    if not endpoint:
        oidutil.log('No pre-discovered information supplied.')
        endpoint = self._discoverAndVerify(claimed_id, [to_match])
    else:
        # The claimed ID matches, so we use the endpoint that we
        # discovered in initiation. This should be the most common
        # case.
        try:
            self._verifyDiscoverySingle(endpoint, to_match)
        except consumer.ProtocolError, e:
            oidutil.log(
                "Error attempting to use stored discovery information: " +
                str(e))
            oidutil.log("Attempting discovery to verify endpoint")
            endpoint = self._discoverAndVerify(
                claimed_id, [to_match])

    def test_immediate_failure(self):
        authreq = self.consumer.beginWithoutDiscovery(
            OpenIDServiceEndpoint.fromOPEndpointURL('http://example.com/endpoint/'))

        url = authreq.redirectURL(
            'http://localhost/',
            return_to='http://localhost/',
            immediate=True)

        response = self.client.open(make_builder(url))
        self.assertEqual(response.status_code, 302)
        parsed = urlparse(response.headers['LOCATION'])

        info = self.consumer.complete(
            dict(parse_qsl(parsed.query)),
            response.headers['LOCATION'])

        self.assertIsInstance(info, SetupNeededResponse)

    def make_identifier_select_endpoint(self, protocol_uri):
        """Create an endpoint for use in OpenID identifier select mode.

        :arg protocol_uri: The URI for the OpenID protocol version.  This
            should be one of the OPENID_X_Y_TYPE constants.

        If the OpenID 1.x protocol is selected, the endpoint will be
        suitable for use with Launchpad's non-standard identifier select
        workflow.
        """
        msg = "Unexpected protocol URI: %s" % protocol_uri
        assert protocol_uri in OPENID_TYPES, msg

        endpoint = OpenIDServiceEndpoint()
        endpoint.server_url = self.base_openid_url
        if protocol_uri == OPENID_2_0_TYPE:
            endpoint.type_uris = [OPENID_IDP_2_0_TYPE]
        else:
            endpoint.type_uris = [protocol_uri]
            endpoint.claimed_id = IDENTIFIER_SELECT
            endpoint.local_id = IDENTIFIER_SELECT
        return endpoint

 def test_no_op_url(self):
     html = '<html><head><link rel="openid.server"></head></html>'
     self.assertEqual(OpenIDServiceEndpoint.fromHTML('http://example.url/', html), [])