def test_issuer_mismatch(self):
ISSUER = "https://login.microsoftonline.com/b4ea3de6-839e-4ad1-ae78-c78e5c0cdc06/v2.0/"
kb = KeyBundle(JWK2["keys"])
kj = KeyJar()
kj.issuer_keys[ISSUER] = [kb]
kj.issuer_keys[""] = []
authz_resp = AuthorizationResponse().from_urlencoded(
"id_token=eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsIng1dCI6Ik1uQ19WWmNBVGZNNXBPWWlKSE1iYTlnb0VLWSIsImtpZCI6Ik1u"
"Q19WWmNBVGZNNXBPWWlKSE1iYTlnb0VLWSJ9.eyJhdWQiOiIwMTZlZDBlNC1mYzUyLTRlYjgtOWVhYy1lODg1MmM4MjEwNTUiLCJpc3Mi"
"OiJodHRwczovL2xvZ2luLm1pY3Jvc29mdG9ubGluZS5jb20vYjRlYTNkZTYtODM5ZS00YWQxLWFlNzgtYzc4ZTVjMGNkYzA2L3YyLjAvI"
"iwiaWF0IjoxNDM5OTIzNDY5LCJuYmYiOjE0Mzk5MjM0NjksImV4cCI6MTQzOTkyNzM2OSwidmVyIjoiMi4wIiwidGlkIjoiYjRlYTNkZT"
"YtODM5ZS00YWQxLWFlNzgtYzc4ZTVjMGNkYzA2Iiwib2lkIjoiNDJjMzliNWUtYmQwNS00YTlhLTlhNWUtMTY5ZDc2N2ZlZjJmIiwicHJ"
"lZmVycmVkX3VzZXJuYW1lIjoiaW50ZXJvcEBrYXV0aS5vbm1pY3Jvc29mdC5jb20iLCJzdWIiOiJFWGlaVldjakpsREN1LXZzOUxNb1V3"
"ZGRNNEJZZ2ZISzBJNk40dWpXZkRFIiwibmFtZSI6ImludGVyb3AiLCJub25jZSI6IlpkSHRxQWwzR3c4QiJ9.tH4FKM4H9YCHX2XF4V64"
"SsLaKh31c0oLpEVlFxFHw8jxL5HujUthZJDUMwngXZ2mPU_1G152ybKiRCV9DKaBh1rFSlZxTDBp0SV_YTwOkGYOt-sOzFUJyvVCjGmRh"
"vFkOF1kiT3IYjDoRh72U8pMchj1duWSytLczdOc4LJmg24ya5jwqApuyQu7gVqoDH1kEqBAuhBj3a7ZDwxIt-bTKZklsht0RutZjv4Ckg"
"8qJpzWnY7rIjSKFKfEpAAfk_LqWvTktvDMKTHXLxEPVZymoskE1LthtC8AYoNmtVPxgxf87yGCqYZBsuAnVChdnsItXP7tPeqUjC8Lm3J"
"jabV-5g&id_token_expires_in=3599&state=6o3FmQ0QZl1zifsE&session_state=d2c97e8a-497c-4ce1-bb10-5058501164eb"
)
try:
authz_resp.verify(keyjar=kj, skew=100000000)
except MissingSigningKey:
authz_resp.verify(keyjar=kj, sender=ISSUER, skew=100000000)
def __init__(
self,
name,
sdb,
cdb,
userinfo,
client_authn,
urlmap=None,
ca_certs="",
keyjar=None,
hostname="",
dist_claims_mode=None,
):
Provider.__init__(
self, name, sdb, cdb, None, userinfo, None, client_authn, "", urlmap, ca_certs, keyjar, hostname
)
if keyjar is None:
keyjar = KeyJar(ca_certs)
for cid, _dic in cdb.items():
try:
keyjar.add_symmetric(cid, _dic["client_secret"], ["sig", "ver"])
except KeyError:
pass
self.srvmethod = OICCServer(keyjar=keyjar)
self.dist_claims_mode = dist_claims_mode
self.info_store = {}
self.claims_userinfo_endpoint = ""
def init_keyjar():
# Keys that are kept by the AS
kb = KeyBundle()
kb.do_keys(JWKS["keys"])
keyjar = KeyJar()
keyjar.add_kb('', kb)
return keyjar
def test_verify_id_token_at_hash_and_chash():
token = 'AccessTokenWhichCouldBeASignedJWT'
at_hash = left_hash(token)
code = 'AccessCode1'
c_hash = left_hash(code)
idt = IdToken(**{
"sub": "553df2bcf909104751cfd8b2",
"aud": [
"5542958437706128204e0000",
"554295ce3770612820620000"
],
"auth_time": 1441364872,
"azp": "554295ce3770612820620000",
"at_hash": at_hash,
'c_hash': c_hash
})
kj = KeyJar()
kj.add_symmetric("", 'dYMmrcQksKaPkhdgRNYk3zzh5l7ewdDJ', ['sig'])
kj.add_symmetric("https://sso.qa.7pass.ctf.prosiebensat1.com",
'dYMmrcQksKaPkhdgRNYk3zzh5l7ewdDJ', ['sig'])
packer = JWT(kj, sign_alg='HS256',
iss="https://sso.qa.7pass.ctf.prosiebensat1.com",
lifetime=3600)
_jws = packer.pack(**idt.to_dict())
msg = AuthorizationResponse(access_token=token, id_token=_jws, code=code)
verify_id_token(msg, check_hash=True, keyjar=kj,
iss="https://sso.qa.7pass.ctf.prosiebensat1.com",
client_id="554295ce3770612820620000")
def create_token(self):
kb = KeyBundle(JWKS["keys"])
kj = KeyJar()
kj.issuer_keys[''] = [kb]
self.access_token = JWTToken(
'T', keyjar=kj, iss='https://example.com/as', sign_alg='RS256')
def test_get_inactive_ver(self):
ks = KeyJar()
ks['http://example.com'] = KeyBundle([{"kty": "oct", "key": "a1b2c3d4", "use": "sig"},
{"kty": "oct", "key": "a1b2c3d4", "use": "ver"}])
ks['http://example.com'][0]._keys[1].inactive_since = 1
key = ks.get_verify_key(owner='http://example.com')
assert len(key) == 2
def test_verify_id_token_missing_c_hash():
code = 'AccessCode1'
idt = IdToken(**{
"sub": "553df2bcf909104751cfd8b2",
"aud": [
"5542958437706128204e0000",
"554295ce3770612820620000"
],
"auth_time": 1441364872,
"azp": "554295ce3770612820620000",
})
kj = KeyJar()
kj.add_symmetric("", 'dYMmrcQksKaPkhdgRNYk3zzh5l7ewdDJ', ['sig'])
kj.add_symmetric("https://sso.qa.7pass.ctf.prosiebensat1.com",
'dYMmrcQksKaPkhdgRNYk3zzh5l7ewdDJ', ['sig'])
packer = JWT(kj, sign_alg='HS256',
iss="https://sso.qa.7pass.ctf.prosiebensat1.com",
lifetime=3600)
_jws = packer.pack(**idt.to_dict())
msg = AuthorizationResponse(code=code, id_token=_jws)
with pytest.raises(MissingRequiredAttribute):
verify_id_token(msg, check_hash=True, keyjar=kj,
iss="https://sso.qa.7pass.ctf.prosiebensat1.com",
client_id="554295ce3770612820620000")
def test_verify_id_token_at_hash_fail():
token = 'AccessTokenWhichCouldBeASignedJWT'
token2 = 'ACompletelyOtherAccessToken'
lhsh = left_hash(token)
idt = IdToken(**{
"sub": "553df2bcf909104751cfd8b2",
"aud": [
"5542958437706128204e0000",
"554295ce3770612820620000"
],
"auth_time": 1441364872,
"azp": "554295ce3770612820620000",
"at_hash": lhsh
})
kj = KeyJar()
kj.add_symmetric("", 'dYMmrcQksKaPkhdgRNYk3zzh5l7ewdDJ', ['sig'])
kj.add_symmetric("https://sso.qa.7pass.ctf.prosiebensat1.com",
'dYMmrcQksKaPkhdgRNYk3zzh5l7ewdDJ', ['sig'])
packer = JWT(kj, sign_alg='HS256',
iss="https://sso.qa.7pass.ctf.prosiebensat1.com",
lifetime=3600)
_jws = packer.pack(**idt.to_dict())
msg = AuthorizationResponse(access_token=token2, id_token=_jws)
with pytest.raises(AtHashError):
verify_id_token(msg, check_hash=True, keyjar=kj,
iss="https://sso.qa.7pass.ctf.prosiebensat1.com",
client_id="554295ce3770612820620000")
def test_pkce_token():
kb = KeyBundle(JWKS["keys"])
kj = KeyJar()
kj.issuer_keys[''] = [kb]
constructor = JWTToken('A', keyjar=kj, lt_pattern={'': 900},
iss='https://example.com/as', sign_alg='RS256',
encrypt=True)
sid = rndstr(32)
session_info = {
'sub': 'subject_id',
'client_id': 'https://example.com/rp',
'response_type': ['code'],
'authzreq': '{}'
}
_cli = Client(config={'code_challenge': {'method': 'S512', 'length': 96}})
args, cv = _cli.add_code_challenge()
access_grant = constructor(
sid, sinfo=session_info, kid='sign1',
code_challenge=args['code_challenge'],
code_challenge_method=args['code_challenge_method'])
_info = constructor.get_info(access_grant)
assert _info['code_challenge_method'] == args['code_challenge_method']
assert _info['code_challenge'] == args['code_challenge']
def create_sdb(self):
kb = KeyBundle(JWKS["keys"])
kj = KeyJar()
kj.issuer_keys[''] = [kb]
self.token = JWTToken('T', {'code': 3600, 'token': 900},
'https://example.com/as', 'RS256', kj)
def _create_op(self, issuer, endpoint_baseurl, jwks_uri):
"""
Create the necessary Provider instance.
:type issuer: str
:type endpoint_baseurl: str
:type jwks_uri: str
:param issuer: issuer URL for the OP
:param endpoint_baseurl: baseurl to build endpoint URL from
:param jwks_uri: URL to where the JWKS will be published
"""
kj = KeyJar()
signing_key = KeyBundle(source="file://{}".format(self.conf["signing_key_path"]),
fileformat="der", keyusage=["sig"])
kj.add_kb("", signing_key)
capabilities = {
"response_types_supported": ["id_token"],
"id_token_signing_alg_values_supported": [self.sign_alg],
"response_modes_supported": ["fragment", "query"],
"subject_types_supported": ["public", "pairwise"],
"grant_types_supported": ["implicit"],
"claim_types_supported": ["normal"],
"claims_parameter_supported": True,
"request_parameter_supported": False,
"request_uri_parameter_supported": False,
}
if "client_db_path" in self.conf:
cdb = shelve_wrapper.open(self.conf["client_db_path"])
else:
cdb = {} # client db in memory only
self.provider = Provider(issuer, None, cdb, None, None, None, None, None, keyjar=kj,
capabilities=capabilities, jwks_uri=jwks_uri)
self.provider.baseurl = endpoint_baseurl
self.provider.endp = [RegistrationEndpoint, AuthorizationEndpoint]
def create_token(self):
kb = KeyBundle(JWKS["keys"])
kj = KeyJar()
kj.issuer_keys[''] = [kb]
self.access_token = JWTToken('T', keyjar=kj,
lt_pattern={'code': 3600, 'token': 900},
iss='https://example.com/as', encrypt=True)
def test_kid_usage():
kb = keybundle_from_local_file("file://jwk.json", "jwk", ["ver", "sig"])
kj = KeyJar()
kj.issuer_keys["https://example.com"] = [kb]
_key = kj.get_key_by_kid("abc", "https://example.com")
assert _key
assert _key.kid == "abc"
def create_token(self):
kb = KeyBundle(JWKS["keys"])
kj = KeyJar()
kj.issuer_keys[""] = [kb]
self.token = JWTToken(
"T", keyjar=kj, lifetime={"code": 3600, "token": 900}, iss="https://example.com/as", sign_alg="RS256"
)
def test_get_inactive_sig_for_ver(self):
"""get_verify_key can return inactive `sig` key."""
ks = KeyJar()
ks['http://example.com'] = KeyBundle([{"kty": "oct", "key": "a1b2c3d4", "use": "sig"}])
ks['http://example.com'][0]._keys[0].inactive_since = 1
key = ks.get_verify_key(owner='http://example.com')
assert len(key) == 1
def test_provider(self):
provider_info = {
"jwks_uri": "https://connect-op.herokuapp.com/jwks.json",
}
ks = KeyJar()
ks.load_keys(provider_info, "https://connect-op.heroku.com")
assert ks["https://connect-op.heroku.com"][0].keys()
def test_local_jwk_file():
kb = keybundle_from_local_file("file://jwk.json", "jwk", ["ver", "sig"])
assert len(kb) == 1
kj = KeyJar()
kj.issuer_keys[""] = [kb]
keys = kj.get_signing_key()
assert len(keys) == 1
key = keys[0]
assert isinstance(key, RSAKey)
assert key.kid == "abc"
def create_sdb(self):
kb = KeyBundle(JWKS["keys"])
kj = KeyJar()
kj.issuer_keys[""] = [kb]
self.sdb = SessionDB(
"https://example.com/",
token_factory=JWTToken(
"T", keyjar=kj, lifetime={"code": 3600, "token": 900}, iss="https://example.com/as", sign_alg="RS256"
),
refresh_token_factory=JWTToken("R", keyjar=kj, lifetime={"": 24 * 3600}, iss="https://example.com/as"),
)
def create_sdb(self):
kb = KeyBundle(JWKS["keys"])
kj = KeyJar()
kj.issuer_keys[''] = [kb]
self.sdb = SessionDB(
"https://example.com/",
token_factory=JWTToken('T', {'code': 3600, 'token': 900},
'https://example.com/as', 'RS256', kj),
refresh_token_factory=JWTToken(
'R', {'': 24*3600}, 'https://example.com/as', 'RS256', kj)
)
def test_signing():
kb = keybundle_from_local_file("file://jwk.json", "jwk", ["ver", "sig"])
assert len(kb) == 1
kj = KeyJar()
kj.issuer_keys[""] = [kb]
keys = kj.get_signing_key()
payload = "Please take a moment to register today"
_jws = JWS(payload, alg="RS512")
try:
_jwt = _jws.sign_compact(keys)
assert False
except (NoSuitableSigningKeys, WrongTypeOfKey):
assert True
def create_provider(self):
kb = KeyBundle(JWKS["keys"])
kj = KeyJar()
kj.issuer_keys[""] = [kb]
_sdb = SessionDB(
"https://example.com/",
token_factory=JWTToken(
"T", keyjar=kj, lifetime={"code": 3600, "token": 900}, iss="https://example.com/as", sign_alg="RS256"
),
refresh_token_factory=JWTToken("R", keyjar=kj, lifetime={"": 24 * 3600}, iss="https://example.com/as"),
)
# name, sdb, cdb, authn_broker, authz, client_authn,
self.provider = Provider("as", _sdb, CDB, AUTHN_BROKER, AUTHZ, verify_client, baseurl="https://example.com/as")
def test_keyjar_pairkeys():
ks = KeyJar()
ks[""] = KeyBundle([{"kty": "oct", "key": "a1b2c3d4", "use": "sig"},
{"kty": "oct", "key": "a1b2c3d4", "use": "ver"}])
ks["http://www.example.org"] = KeyBundle([
{"kty": "oct", "key": "e5f6g7h8", "use": "sig"},
{"kty": "oct", "key": "e5f6g7h8", "use": "ver"}])
ks["http://www.example.org"].append(
keybundle_from_local_file(RSAKEY, "rsa", ["ver", "sig"]))
collection = ks.verify_keys("http://www.example.org")
assert len(collection) == 3
assert len([k for k in collection if k.kty == "oct"]) == 2
assert len([k for k in collection if k.kty == "RSA"]) == 1
def test_keyjar_pairkeys():
ks = KeyJar()
ks[""] = KeyBundle({"hmac": "a1b2c3d4"}, usage=["sig", "ver"])
ks["http://www.example.org"] = KeyBundle({"hmac": "e5f6g7h8"},
usage=["sig", "ver"])
ks["http://www.example.org"].append(KeyBundle({"rsa": "-rsa-key-"},
usage=["enc", "dec"]))
ks["http://www.example.org"].append(KeyBundle({"rsa": "i9j10k11l12"},
usage=["sig", "ver"]))
collection = ks.verify_keys("http://www.example.org")
assert _eq(collection.keys(), ["hmac", "rsa"])
def test_signing():
# Signing is only possible if key is a private RSA key
kb = keybundle_from_local_file("rsa.key", "rsa", ["ver", "sig"])
assert len(kb) == 2
kj = KeyJar()
kj.issuer_keys[""] = [kb]
keys = kj.get_signing_key()
payload = "Please take a moment to register today"
_jws = JWS(payload, alg="RS512")
try:
_jwt = _jws.sign_compact(keys)
assert True
except (NoSuitableSigningKeys, WrongTypeOfKey):
assert False
def test_keyjar_group_keys(self):
ks = KeyJar()
ks[""] = KeyBundle([{"kty": "oct", "key": "a1b2c3d4", "use": "sig"},
{"kty": "oct", "key": "a1b2c3d4", "use": "ver"}])
ks["http://www.example.org"] = KeyBundle([
{"kty": "oct", "key": "e5f6g7h8", "use": "sig"},
{"kty": "oct", "key": "e5f6g7h8", "use": "ver"}])
ks["http://www.example.org"].append(
keybundle_from_local_file(RSAKEY, "rsa", ["ver", "sig"]))
verified_keys = ks.verify_keys("http://www.example.org")
assert len(verified_keys) == 3
assert len([k for k in verified_keys if k.kty == "oct"]) == 2
assert len([k for k in verified_keys if k.kty == "RSA"]) == 1
def test_dump_own_keys():
kb = keybundle_from_local_file("file://jwk.json", "jwk", ["ver", "sig"])
assert len(kb) == 1
kj = KeyJar()
kj.issuer_keys[""] = [kb]
res = kj.dump_issuer_keys("")
assert len(res) == 1
assert res[0] == {
'use': u'sig',
'e': u'AQAB',
'kty': u'RSA',
'alg': u'RS256',
'n': u'pKybs0WaHU_y4cHxWbm8Wzj66HtcyFn7Fh3n-99qTXu5yNa30MRYIYfSDwe9JVc1JUoGw41yq2StdGBJ40HxichjE-Yopfu3B58QlgJvToUbWD4gmTDGgMGxQxtv1En2yedaynQ73sDpIK-12JJDY55pvf-PCiSQ9OjxZLiVGKlClDus44_uv2370b9IN2JiEOF-a7JBqaTEYLPpXaoKWDSnJNonr79tL0T7iuJmO1l705oO3Y0TQ-INLY6jnKG_RpsvyvGNnwP9pMvcP1phKsWZ10ofuuhJGRp8IxQL9RfzT87OvF0RBSO1U73h09YP-corWDsnKIi6TbzRpN5YDw',
'kid': u'abc'}
def create_sdb(self):
kb = KeyBundle(JWKS["keys"])
kj = KeyJar()
kj.issuer_keys[''] = [kb]
self.sdb = SessionDB(
"https://example.com/",
token_factory=JWTToken('T', keyjar=kj,
lt_pattern={'code': 3600, 'token': 900},
iss='https://example.com/as',
sign_alg='RS256'),
refresh_token_factory=JWTToken(
'R', keyjar=kj, lt_pattern={'': 24 * 3600},
iss='https://example.com/as')
)
def export_keys(keys):
kbl = []
keyjar = KeyJar()
for typ, info in keys.items():
kb = KeyBundle(source="file://%s" % info["key"], fileformat="der",
keytype=typ)
keyjar.add_kb("", kb)
kbl.append(kb)
try:
new_name = "static/jwks.json"
dump_jwks(kbl, new_name)
except KeyError:
pass
return keyjar
def rotate_jwks(self):
# type: () -> None
"""Replace the current JWKS with a fresh one."""
self.jwks = KeyJar()
kb = KeyBundle(keyusage=["enc", "sig"])
kb.append(RSAKey(key=RSA.generate(1024), kid=self._create_kid()))
self.jwks.add_kb("", kb)
def __init__(
self,
name,
sdb,
cdb,
authn_broker,
authz,
client_authn,
symkey="",
urlmap=None,
iv=0,
default_scope="",
ca_bundle=None,
seed=b"",
client_authn_methods=None,
authn_at_registration="",
client_info_url="",
secret_lifetime=86400,
jwks_uri="",
keyjar=None,
capabilities=None,
verify_ssl=True,
baseurl="",
hostname="",
):
if not name.endswith("/"):
name += "/"
provider.Provider.__init__(
self, name, sdb, cdb, authn_broker, authz, client_authn, symkey, urlmap, iv, default_scope, ca_bundle
)
self.endp.extend([RegistrationEndpoint, ClientInfoEndpoint])
# dictionary of client authentication methods
self.client_authn_methods = client_authn_methods
if authn_at_registration:
if authn_at_registration not in client_authn_methods:
raise UnknownAuthnMethod(authn_at_registration)
self.authn_at_registration = authn_at_registration
self.seed = seed
self.client_info_url = client_info_url
self.secret_lifetime = secret_lifetime
self.jwks_uri = jwks_uri
self.verify_ssl = verify_ssl
self.keyjar = keyjar
if self.keyjar is None:
self.keyjar = KeyJar(verify_ssl=self.verify_ssl)
if capabilities:
self.verify_capabilities(capabilities)
self.capabilities = ProviderConfigurationResponse(**capabilities)
else:
self.capabilities = self.provider_features()
self.baseurl = baseurl
self.hostname = hostname or gethostname()
self.kid = {"sig": {}, "enc": {}}
def fo_keyjar(*args):
_kj = KeyJar()
for fo in args:
_kj.import_jwks(fo.jwks, fo.iss)
return _kj
class Operator(object):
def __init__(self,
keyjar=None,
fo_keyjar=None,
httpcli=None,
iss=None,
jwks_file='',
jwks=None):
"""
:param keyjar: Contains the operators signing keys
:param fo_keyjar: Contains the federation operators signing key
for all the federations this instance wants to talk to
:param httpcli: A http client to use when information has to be
fetched from somewhere else
:param iss: Issuer ID
"""
if keyjar:
self.keyjar = keyjar
elif jwks_file:
try:
fp = open(jwks_file, 'r')
except Exception:
self.keyjar = None
else:
self.keyjar = KeyJar()
self.keyjar.import_jwks(json.load(fp), '')
fp.close()
elif jwks:
self.keyjar = KeyJar()
self.keyjar.import_jwks(jwks, '')
self.jwks = jwks
else:
self.keyjar = None
self.fo_keyjar = fo_keyjar
self.httpcli = httpcli
self.iss = iss
self.failed = {}
def unpack_metadata_statement(self,
json_ms=None,
jwt_ms='',
keyjar=None,
cls=ClientMetadataStatement):
"""
:param json_ms: Metadata statement as a JSON document
:param jwt_ms: Metadata statement as JWT
:param keyjar: Keys that should be used to verify the signature of the
document
:param cls: What type (Class) of metadata statement this is
:return: Unpacked and verified metadata statement
"""
if keyjar is None:
_keyjar = self.fo_keyjar
else:
_keyjar = keyjar
if jwt_ms:
try:
json_ms = unfurl(jwt_ms)
except JWSException:
raise
else:
msl = []
if 'metadata_statements' in json_ms:
msl = []
for meta_s in json_ms['metadata_statements']:
try:
_ms = self.unpack_metadata_statement(
jwt_ms=meta_s, keyjar=_keyjar, cls=cls)
except (JWSException, BadSignature, MissingSigningKey):
pass
else:
msl.append(_ms)
for _ms in msl:
_keyjar.import_jwks(_ms['signing_keys'], '')
elif 'metadata_statement_uris' in json_ms:
pass
try:
_ms = cls().from_jwt(jwt_ms, keyjar=_keyjar)
except MissingSigningKey:
raise
if msl:
_ms['metadata_statements'] = [x.to_json() for x in msl]
return _ms
if json_ms:
msl = []
if 'metadata_statements' in json_ms:
for ms in json_ms['metadata_statements']:
try:
res = self.unpack_metadata_statement(jwt_ms=ms,
keyjar=keyjar,
cls=cls)
except (JWSException, BadSignature):
pass
else:
msl.append(res)
if 'metadata_statement_uris' in json_ms:
if self.httpcli:
for iss, url in json_ms['metadata_statement_uris'].items():
if iss not in keyjar: # FO I don't know about
continue
else:
_jwt = self.httpcli.http_request(url)
try:
_res = self.unpack_metadata_statement(
jwt_ms=_jwt, keyjar=keyjar, cls=cls)
except JWSException as err:
logger.error(err)
else:
msl.append(_res)
if msl:
json_ms['metadata_statements'] = [x.to_json() for x in msl]
return json_ms
else:
raise AttributeError('Need one of json_ms or jwt_ms')
def pack_metadata_statement(self,
metadata,
keyjar=None,
iss=None,
alg='',
**kwargs):
"""
:param metas: Original metadata statement as a MetadataStatement
instance
:param keyjar: KeyJar in which the necessary keys should reside
:param alg: Which signing algorithm to use
:param kwargs: Additional metadata statement attribute values
:return: A JWT
"""
if iss is None:
iss = self.iss
if keyjar is None:
keyjar = self.keyjar
# Own copy
_metadata = copy.deepcopy(metadata)
_metadata.update(kwargs)
_jwt = JWT(keyjar, iss=iss, msgtype=_metadata.__class__)
if alg:
_jwt.sign_alg = alg
return _jwt.pack(cls_instance=_metadata)
def evaluate_metadata_statement(self, metadata):
"""
Computes the resulting metadata statement from a compounded metadata
statement.
If something goes wrong during the evaluation an exception is raised
:param metadata: The compounded metadata statement
:return: The resulting metadata statement
"""
# start from the innermost metadata statement and work outwards
res = dict([(k, v) for k, v in metadata.items()
if k not in IgnoreKeys])
if 'metadata_statements' in metadata:
cres = {}
for ms in metadata['metadata_statements']:
_msd = self.evaluate_metadata_statement(json.loads(ms))
for _iss, kw in _msd.items():
_break = False
_ci = {}
for k, v in kw.items():
if k in res:
if is_lesser(res[k], v):
_ci[k] = v
else:
self.failed['iss'] = (
'Value of {}: {} not <= {}'.format(
k, res[k], v))
_break = True
break
else:
_ci[k] = v
if _break:
break
if _break:
continue
for k, v in res.items():
if k not in _ci:
_ci[k] = v
cres[_iss] = _ci
return cres
else: # this is the innermost
_iss = metadata['iss'] # The issuer == FO is interesting
return {_iss: res}
class Provider(provider.Provider):
"""A OAuth2 RP that knows all the OAuth2 extensions I've implemented."""
def __init__(self,
name,
sdb,
cdb,
authn_broker,
authz,
client_authn,
symkey=None,
urlmap=None,
iv=0,
default_scope="",
ca_bundle=None,
seed=b"",
client_authn_methods=None,
authn_at_registration="",
client_info_url="",
secret_lifetime=86400,
jwks_uri="",
keyjar=None,
capabilities=None,
verify_ssl=True,
baseurl="",
hostname="",
config=None,
behavior=None,
lifetime_policy=None,
message_factory=ExtensionMessageFactory,
**kwargs):
if not name.endswith("/"):
name += "/"
try:
args = {"server_cls": kwargs["server_cls"]}
except KeyError:
args = {}
super().__init__(name,
sdb,
cdb,
authn_broker,
authz,
client_authn,
symkey,
urlmap,
iv,
default_scope,
ca_bundle,
message_factory=message_factory,
**args)
self.endp.extend([
RegistrationEndpoint,
ClientInfoEndpoint,
RevocationEndpoint,
IntrospectionEndpoint,
])
# dictionary of client authentication methods
self.client_authn_methods = client_authn_methods
if authn_at_registration:
if authn_at_registration not in client_authn_methods:
raise UnknownAuthnMethod(authn_at_registration)
self.authn_at_registration = authn_at_registration
self.seed = seed
self.client_info_url = client_info_url
self.secret_lifetime = secret_lifetime
self.jwks_uri = jwks_uri
self.verify_ssl = verify_ssl
self.scopes.extend(kwargs.get("scopes", []))
self.keyjar = keyjar # type: KeyJar
if self.keyjar is None:
self.keyjar = KeyJar(verify_ssl=self.verify_ssl)
if capabilities:
self.capabilities = self.provider_features(
provider_config=capabilities)
else:
self.capabilities = self.provider_features()
self.baseurl = baseurl or name
self.hostname = hostname or socket.gethostname()
self.kid = {"sig": {}, "enc": {}} # type: Dict[str, Dict[str, str]]
self.config = config or {}
self.behavior = behavior or {}
self.token_policy = {
"access_token": {},
"refresh_token": {},
} # type: Dict[str, Dict[str, Dict[str, int]]]
if lifetime_policy is None:
self.lifetime_policy = {
"access_token": {
"code": 600,
"token": 120,
"implicit": 120,
"authorization_code": 600,
"client_credentials": 600,
"password": 600,
},
"refresh_token": {
"code": 3600,
"token": 3600,
"implicit": 3600,
"authorization_code": 3600,
"client_credentials": 3600,
"password": 3600,
},
}
else:
self.lifetime_policy = lifetime_policy
self.token_handler = TokenHandler(self.baseurl,
self.token_policy,
keyjar=self.keyjar)
@staticmethod
def _uris_to_tuples(uris):
tup = []
for uri in uris:
base, query = splitquery(uri)
if query:
tup.append((base, query))
else:
tup.append((base, ""))
return tup
@staticmethod
def _tuples_to_uris(items):
_uri = []
for url, query in items:
if query:
_uri.append("%s?%s" % (url, query))
else:
_uri.append(url)
return _uri
def load_keys(self, request, client_id, client_secret):
try:
self.keyjar.load_keys(request, client_id)
try:
n_keys = len(self.keyjar[client_id])
msg = "Found {} keys for client_id={}"
logger.debug(msg.format(n_keys, client_id))
except KeyError:
pass
except Exception as err:
msg = "Failed to load client keys: {}"
logger.error(msg.format(sanitize(request.to_dict())))
logger.error("%s", err)
error = ClientRegistrationError(
error="invalid_configuration_parameter",
error_description="%s" % err)
return Response(
error.to_json(),
content="application/json",
status_code="400 Bad Request",
)
# Add the client_secret as a symmetric key to the keyjar
_kc = KeyBundle([
{
"kty": "oct",
"key": client_secret,
"use": "ver"
},
{
"kty": "oct",
"key": client_secret,
"use": "sig"
},
])
try:
self.keyjar[client_id].append(_kc)
except KeyError:
self.keyjar[client_id] = [_kc]
@staticmethod
def verify_correct(cinfo, restrictions):
for fname, arg in restrictions.items():
func = restrict.factory(fname)
res = func(arg, cinfo)
if res:
raise RestrictionError(res)
def set_token_policy(self, cid, cinfo):
for ttyp in ["access_token", "refresh_token"]:
pol = {}
for rgtyp in ["response_type", "grant_type"]:
try:
rtyp = cinfo[rgtyp]
except KeyError:
pass
else:
for typ in rtyp:
try:
pol[typ] = self.lifetime_policy[ttyp][typ]
except KeyError:
pass
self.token_policy[ttyp][cid] = pol
def create_new_client(self, request, restrictions):
"""
Create new client based on request and restrictions.
:param request: The Client registration request
:param restrictions: Restrictions on the client
:return: The client_id
"""
_cinfo = request.to_dict()
self.match_client_request(_cinfo)
# create new id and secret
_id = rndstr(12)
while _id in self.cdb:
_id = rndstr(12)
_cinfo["client_id"] = _id
_cinfo["client_secret"] = secret(self.seed, _id)
_cinfo["client_id_issued_at"] = utc_time_sans_frac()
_cinfo["client_secret_expires_at"] = utc_time_sans_frac(
) + self.secret_lifetime
# If I support client info endpoint
if ClientInfoEndpoint in self.endp:
_cinfo["registration_access_token"] = rndstr(32)
_cinfo["registration_client_uri"] = "%s%s%s?client_id=%s" % (
self.name,
self.client_info_url,
ClientInfoEndpoint.etype,
_id,
)
if "redirect_uris" in request:
_cinfo["redirect_uris"] = self._uris_to_tuples(
request["redirect_uris"])
self.load_keys(request, _id, _cinfo["client_secret"])
try:
_behav = self.behavior["client_registration"]
except KeyError:
pass
else:
self.verify_correct(_cinfo, _behav)
self.set_token_policy(_id, _cinfo)
self.cdb[_id] = _cinfo
return _id
def match_client_request(self, request):
for _pref, _prov in PREFERENCE2PROVIDER.items():
if _pref in request:
if _pref == "response_types":
for val in request[_pref]:
match = False
p = set(val.split(" "))
for cv in self.capabilities[_prov]:
if p == set(cv.split(" ")):
match = True
break
if not match:
raise CapabilitiesMisMatch(
"Not allowed {}".format(_pref))
else:
if isinstance(request[_pref], str):
if request[_pref] not in self.capabilities[_prov]:
raise CapabilitiesMisMatch(
"Not allowed {}".format(_pref))
else:
if not set(request[_pref]).issubset(
set(self.capabilities[_prov])):
raise CapabilitiesMisMatch(
"Not allowed {}".format(_pref))
def client_info(self, client_id):
_cinfo = self.cdb[client_id].copy()
if not valid_client_info(_cinfo):
err = ErrorResponse(error="invalid_client",
error_description="Invalid client secret")
return BadRequest(err.to_json(), content="application/json")
try:
_cinfo["redirect_uris"] = self._tuples_to_uris(
_cinfo["redirect_uris"])
except KeyError:
pass
msg = self.server.message_factory.get_response_type("update_endpoint")(
**_cinfo)
return Response(msg.to_json(), content="application/json")
def client_info_update(self, client_id, request):
_cinfo = self.cdb[client_id].copy()
try:
_cinfo["redirect_uris"] = self._tuples_to_uris(
_cinfo["redirect_uris"])
except KeyError:
pass
for key, value in request.items():
if key in ["client_secret", "client_id"]:
# assure it's the same
if value != _cinfo[key]:
raise ModificationForbidden("Not allowed to change")
else:
_cinfo[key] = value
for key in list(_cinfo.keys()):
if key in [
"client_id_issued_at",
"client_secret_expires_at",
"registration_access_token",
"registration_client_uri",
]:
continue
if key not in request:
del _cinfo[key]
if "redirect_uris" in request:
_cinfo["redirect_uris"] = self._uris_to_tuples(
request["redirect_uris"])
self.cdb[client_id] = _cinfo
def verify_client(self, environ, areq, authn_method, client_id=""):
"""
Verify the client based on credentials.
:param environ: WSGI environ
:param areq: The request
:param authn_method: client authentication method
:return:
"""
if not client_id:
client_id = get_client_id(self.cdb, areq,
environ["HTTP_AUTHORIZATION"])
try:
method = self.client_authn_methods[authn_method]
except KeyError:
raise UnSupported()
return method(self).verify(environ, client_id=client_id)
def consume_software_statement(self, software_statement):
return {}
def registration_endpoint(self, **kwargs):
"""
Perform dynamic client registration.
:param request: The request
:param authn: Client authentication information
:param kwargs: extra keyword arguments
:return: A Response instance
"""
_request = self.server.message_factory.get_request_type(
"registration_endpoint")().deserialize(kwargs["request"], "json")
try:
_request.verify(keyjar=self.keyjar)
except InvalidRedirectUri as err:
msg = ClientRegistrationError(error="invalid_redirect_uri",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
except (MissingPage, VerificationError) as err:
msg = ClientRegistrationError(error="invalid_client_metadata",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
# If authentication is necessary at registration
if self.authn_at_registration:
try:
self.verify_client(kwargs["environ"], _request,
self.authn_at_registration)
except (AuthnFailure, UnknownAssertionType):
return Unauthorized()
client_restrictions = {} # type: ignore
if "parsed_software_statement" in _request:
for ss in _request["parsed_software_statement"]:
client_restrictions.update(self.consume_software_statement(ss))
del _request["software_statement"]
del _request["parsed_software_statement"]
try:
client_id = self.create_new_client(_request, client_restrictions)
except CapabilitiesMisMatch as err:
msg = ClientRegistrationError(error="invalid_client_metadata",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
except RestrictionError as err:
msg = ClientRegistrationError(error="invalid_client_metadata",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
return self.client_info(client_id)
def client_info_endpoint(self, method="GET", **kwargs):
"""
Operations on this endpoint are switched through the use of different HTTP methods.
:param method: HTTP method used for the request
:param kwargs: keyword arguments
:return: A Response instance
"""
_query = compact(parse_qs(kwargs["query"]))
try:
_id = _query["client_id"]
except KeyError:
return BadRequest("Missing query component")
if _id not in self.cdb:
return Unauthorized()
# authenticated client
try:
self.verify_client(kwargs["environ"],
kwargs["request"],
"bearer_header",
client_id=_id)
except (AuthnFailure, UnknownAssertionType):
return Unauthorized()
if method == "GET":
return self.client_info(_id)
elif method == "PUT":
try:
_request = self.server.message_factory.get_request_type(
"update_endpoint")().from_json(kwargs["request"])
except ValueError as err:
return BadRequest(str(err))
try:
_request.verify()
except InvalidRedirectUri as err:
msg = ClientRegistrationError(error="invalid_redirect_uri",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
except (MissingPage, VerificationError) as err:
msg = ClientRegistrationError(error="invalid_client_metadata",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
try:
self.client_info_update(_id, _request)
return self.client_info(_id)
except ModificationForbidden:
return Forbidden()
elif method == "DELETE":
try:
del self.cdb[_id]
except KeyError:
return Unauthorized()
else:
return NoContent()
@staticmethod
def verify_code_challenge(code_verifier,
code_challenge,
code_challenge_method="S256"):
"""
Verify a PKCE (RFC7636) code challenge.
:param code_verifier: The origin
:param code_challenge: The transformed verifier used as challenge
:return:
"""
_h = CC_METHOD[code_challenge_method](
code_verifier.encode("ascii")).digest()
_cc = b64e(_h)
if _cc.decode("ascii") != code_challenge:
logger.error("PCKE Code Challenge check failed")
err = TokenErrorResponse(error="invalid_request",
error_description="PCKE check failed")
return Response(err.to_json(),
content="application/json",
status_code=401)
return True
def do_access_token_response(self,
access_token,
atinfo,
state,
refresh_token=None):
_tinfo = {
"access_token": access_token,
"expires_in": atinfo["exp"],
"token_type": "bearer",
"state": state,
}
try:
_tinfo["scope"] = atinfo["scope"]
except KeyError:
pass
if refresh_token:
_tinfo["refresh_token"] = refresh_token
atr_class = self.server.message_factory.get_response_type(
"token_endpoint")
return atr_class(**by_schema(atr_class, **_tinfo))
def code_grant_type(self, areq):
# assert that the code is valid
try:
_info = self.sdb[areq["code"]]
except KeyError:
err = TokenErrorResponse(error="invalid_grant",
error_description="Unknown access grant")
return Response(err.to_json(),
content="application/json",
status="401 Unauthorized")
authzreq = json.loads(_info["authzreq"])
if "code_verifier" in areq:
try:
_method = authzreq["code_challenge_method"]
except KeyError:
_method = "S256"
resp = self.verify_code_challenge(areq["code_verifier"],
authzreq["code_challenge"],
_method)
if resp:
return resp
if "state" in areq:
if self.sdb[areq["code"]]["state"] != areq["state"]:
logger.error("State value mismatch")
err = TokenErrorResponse(error="unauthorized_client")
return Unauthorized(err.to_json(), content="application/json")
resp = self.token_scope_check(areq, _info)
if resp:
return resp
# If redirect_uri was in the initial authorization request
# verify that the one given here is the correct one.
if "redirect_uri" in _info and areq["redirect_uri"] != _info[
"redirect_uri"]:
logger.error("Redirect_uri mismatch")
err = TokenErrorResponse(error="unauthorized_client")
return Unauthorized(err.to_json(), content="application/json")
issue_refresh = False
if "scope" in authzreq and "offline_access" in authzreq["scope"]:
if authzreq["response_type"] == "code":
issue_refresh = True
try:
_tinfo = self.sdb.upgrade_to_token(areq["code"],
issue_refresh=issue_refresh)
except AccessCodeUsed:
err = TokenErrorResponse(error="invalid_grant",
error_description="Access grant used")
return Response(err.to_json(),
content="application/json",
status="401 Unauthorized")
logger.debug("_tinfo: %s" % _tinfo)
atr_class = self.server.message_factory.get_response_type(
"token_endpoint")
atr = atr_class(**by_schema(atr_class, **_tinfo))
logger.debug("AccessTokenResponse: %s" % atr)
return Response(atr.to_json(),
content="application/json",
headers=OAUTH2_NOCACHE_HEADERS)
def client_credentials_grant_type(self, areq):
_at = self.token_handler.get_access_token(
areq["client_id"],
scope=areq["scope"],
grant_type="client_credentials")
_info = self.token_handler.token_factory.get_info(_at)
try:
_rt = self.token_handler.get_refresh_token(self.baseurl,
_info["access_token"],
"client_credentials")
except NotAllowed:
atr = self.do_access_token_response(_at, _info, areq["state"])
else:
atr = self.do_access_token_response(_at, _info, areq["state"], _rt)
return Response(atr.to_json(), content="application/json")
def password_grant_type(self, areq):
"""
Token authorization using Resource owner password credentials.
RFC6749 section 4.3
"""
# `Any` comparison tries a first broker, so we either hit an IndexError or get a method
try:
authn, authn_class_ref = self.pick_auth(areq, "any")
except IndexError:
err = TokenErrorResponse(error="invalid_grant")
return Unauthorized(err.to_json(), content="application/json")
identity, _ts = authn.authenticated_as(username=areq["username"],
password=areq["password"])
if identity is None:
err = TokenErrorResponse(error="invalid_grant")
return Unauthorized(err.to_json(), content="application/json")
# We are returning a token
areq["response_type"] = ["token"]
authn_event = AuthnEvent(
identity["uid"],
identity.get("salt", ""),
authn_info=authn_class_ref,
time_stamp=_ts,
)
sid = self.setup_session(areq, authn_event,
self.cdb[areq["client_id"]])
_at = self.sdb.upgrade_to_token(self.sdb[sid]["code"],
issue_refresh=True)
atr_class = self.server.message_factory.get_response_type(
"token_endpoint")
atr = atr_class(**by_schema(atr_class, **_at))
return Response(atr.to_json(),
content="application/json",
headers=OAUTH2_NOCACHE_HEADERS)
def refresh_token_grant_type(self, areq):
at = self.token_handler.refresh_access_token(self.baseurl,
areq["access_token"],
"refresh_token")
atr_class = self.server.message_factory.get_response_type(
"token_endpoint")
atr = atr_class(**by_schema(atr_class, **at))
return Response(atr.to_json(), content="application/json")
@staticmethod
def token_access(endpoint, client_id, token_info):
# simple rules: if client_id in azp or aud it's allow to introspect
# to revoke it has to be in azr
allow = False
if endpoint == "revocation_endpoint":
if "azr" in token_info and client_id == token_info["azr"]:
allow = True
elif len(token_info["aud"]) == 1 and token_info["aud"] == [
client_id
]:
allow = True
else: # has to be introspection endpoint
if "azr" in token_info and client_id == token_info["azr"]:
allow = True
elif "aud" in token_info:
if client_id in token_info["aud"]:
allow = True
return allow
def get_token_info(self, authn, req, endpoint):
"""
Parse token for information.
:param authn:
:param req:
:return:
"""
try:
client_id = self.client_authn(self, req, authn)
except FailedAuthentication as err:
logger.error(err)
error = TokenErrorResponse(error="unauthorized_client",
error_description="%s" % err)
return Response(error.to_json(),
content="application/json",
status="401 Unauthorized")
logger.debug("{}: {} requesting {}".format(endpoint, client_id,
req.to_dict()))
try:
token_type = req["token_type_hint"]
except KeyError:
try:
_info = self.sdb.token_factory["access_token"].get_info(
req["token"])
except Exception:
try:
_info = self.sdb.token_factory["refresh_token"].get_info(
req["token"])
except Exception:
return self._return_inactive()
else:
token_type = "refresh_token" # nosec
else:
token_type = "access_token" # nosec
else:
try:
_info = self.sdb.token_factory[token_type].get_info(
req["token"])
except Exception:
return self._return_inactive()
if not self.token_access(endpoint, client_id, _info):
return BadRequest()
return client_id, token_type, _info
def _return_inactive(self):
ir = self.server.message_factory.get_response_type(
"introspection_endpoint")(active=False)
return Response(ir.to_json(), content="application/json")
def revocation_endpoint(self, authn="", request=None, **kwargs):
"""
Implement RFC7009 allows a client to invalidate an access or refresh token.
:param authn: Client Authentication information
:param request: The revocation request
:param kwargs:
:return:
"""
trr = self.server.message_factory.get_request_type(
"revocation_endpoint")().deserialize(request, "urlencoded")
resp = self.get_token_info(authn, trr, "revocation_endpoint")
if isinstance(resp, Response):
return resp
else:
client_id, token_type, _info = resp
logger.info("{} token revocation: {}".format(client_id, trr.to_dict()))
try:
self.sdb.token_factory[token_type].invalidate(trr["token"])
except KeyError:
return BadRequest()
else:
return Response("OK")
def introspection_endpoint(self, authn="", request=None, **kwargs):
"""
Implement RFC7662.
:param authn: Client Authentication information
:param request: The introspection request
:param kwargs:
:return:
"""
tir = self.server.message_factory.get_request_type(
"introspection_endpoint")().deserialize(request, "urlencoded")
resp = self.get_token_info(authn, tir, "introspection_endpoint")
if isinstance(resp, Response):
return resp
else:
client_id, token_type, _info = resp
logger.info("{} token introspection: {}".format(
client_id, tir.to_dict()))
ir = self.server.message_factory.get_response_type(
"introspection_endpoint")(
active=self.sdb.token_factory[token_type].is_valid(_info),
**_info.to_dict())
ir.weed()
return Response(ir.to_json(), content="application/json")
def test_load_spomky_keys():
kj = KeyJar()
kj.import_jwks(JWKS_SPO, "")
assert len(kj.get_issuer_keys("")) == 4
def test_load_unknown_keytype():
kj = KeyJar()
kj.import_jwks(JWK_UK, "")
assert len(kj.get_issuer_keys("")) == 1
class Client(PBase):
_endpoints = ENDPOINTS
def __init__(self, client_id=None, ca_certs=None, client_authn_method=None,
keyjar=None, verify_ssl=True):
"""
:param client_id: The client identifier
:param ca_certs: Certificates used to verify HTTPS certificates
:param client_authn_method: Methods that this client can use to
authenticate itself. It's a dictionary with method names as
keys and method classes as values.
:param verify_ssl: Whether the SSL certificate should be verfied.
:return: Client instance
"""
PBase.__init__(self, ca_certs, verify_ssl=verify_ssl)
self.client_id = client_id
self.client_authn_method = client_authn_method
self.keyjar = keyjar or KeyJar(verify_ssl=verify_ssl)
self.verify_ssl = verify_ssl
#self.secret_type = "basic "
self.state = None
self.nonce = None
self.grant = {}
# own endpoint
self.redirect_uris = [None]
# service endpoints
self.authorization_endpoint = None
self.token_endpoint = None
self.token_revocation_endpoint = None
self.request2endpoint = REQUEST2ENDPOINT
self.response2error = RESPONSE2ERROR
self.grant_class = Grant
self.token_class = Token
self.provider_info = {}
self._c_secret = None
def get_client_secret(self):
return self._c_secret
def set_client_secret(self, val):
if not val:
self._c_secret = ""
else:
self._c_secret = val
# client uses it for signing
# Server might also use it for signing which means the
# client uses it for verifying server signatures
if self.keyjar is None:
self.keyjar = KeyJar()
self.keyjar.add_symmetric("", str(val), ["sig"])
client_secret = property(get_client_secret, set_client_secret)
def reset(self):
self.state = None
self.nonce = None
self.grant = {}
self.authorization_endpoint = None
self.token_endpoint = None
self.redirect_uris = None
def grant_from_state(self, state):
for key, grant in self.grant.items():
if key == state:
return grant
return None
def _parse_args(self, request, **kwargs):
ar_args = kwargs.copy()
for prop in request.c_param.keys():
if prop in ar_args:
continue
else:
if prop == "redirect_uri":
_val = getattr(self, "redirect_uris", [None])[0]
if _val:
ar_args[prop] = _val
else:
_val = getattr(self, prop, None)
if _val:
ar_args[prop] = _val
return ar_args
def _endpoint(self, endpoint, **kwargs):
try:
uri = kwargs[endpoint]
if uri:
del kwargs[endpoint]
except KeyError:
uri = ""
if not uri:
try:
uri = getattr(self, endpoint)
except Exception:
raise Exception("No '%s' specified" % endpoint)
if not uri:
raise Exception("No '%s' specified" % endpoint)
return uri
def get_grant(self, **kwargs):
try:
_state = kwargs["state"]
if not _state:
_state = self.state
except KeyError:
_state = self.state
try:
return self.grant[_state]
except:
raise Exception("No grant found for state:'%s'" % _state)
def get_token(self, also_expired=False, **kwargs):
try:
return kwargs["token"]
except KeyError:
grant = self.get_grant(**kwargs)
try:
token = grant.get_token(kwargs["scope"])
except KeyError:
token = grant.get_token("")
if not token:
try:
token = self.grant[kwargs["state"]].get_token("")
except KeyError:
raise Exception("No token found for scope")
if token is None:
raise Exception("No suitable token found")
if also_expired:
return token
elif token.is_valid():
return token
else:
raise ExpiredToken()
def construct_request(self, request, request_args=None, extra_args=None):
if request_args is None:
request_args = {}
#logger.debug("request_args: %s" % request_args)
kwargs = self._parse_args(request, **request_args)
if extra_args:
kwargs.update(extra_args)
#logger.debug("kwargs: %s" % kwargs)
#logger.debug("request: %s" % request)
return request(**kwargs)
def construct_Message(self, request=Message, request_args=None,
extra_args=None, **kwargs):
return self.construct_request(request, request_args, extra_args)
#noinspection PyUnusedLocal
def construct_AuthorizationRequest(self, request=AuthorizationRequest,
request_args=None, extra_args=None,
**kwargs):
if request_args is not None:
try: # change default
new = request_args["redirect_uri"]
if new:
self.redirect_uris = [new]
except KeyError:
pass
else:
request_args = {}
if "client_id" not in request_args:
request_args["client_id"] = self.client_id
elif not request_args["client_id"]:
request_args["client_id"] = self.client_id
return self.construct_request(request, request_args, extra_args)
#noinspection PyUnusedLocal
def construct_AccessTokenRequest(self,
request=AccessTokenRequest,
request_args=None, extra_args=None,
**kwargs):
grant = self.get_grant(**kwargs)
if not grant.is_valid():
raise GrantExpired("Authorization Code to old %s > %s" % (
utc_time_sans_frac(),
grant.grant_expiration_time))
if request_args is None:
request_args = {}
request_args["code"] = grant.code
if "grant_type" not in request_args:
request_args["grant_type"] = "authorization_code"
if "client_id" not in request_args:
request_args["client_id"] = self.client_id
elif not request_args["client_id"]:
request_args["client_id"] = self.client_id
return self.construct_request(request, request_args, extra_args)
def construct_RefreshAccessTokenRequest(self,
request=RefreshAccessTokenRequest,
request_args=None, extra_args=None,
**kwargs):
if request_args is None:
request_args = {}
token = self.get_token(also_expired=True, **kwargs)
request_args["refresh_token"] = token.refresh_token
try:
request_args["scope"] = token.scope
except AttributeError:
pass
return self.construct_request(request, request_args, extra_args)
def construct_TokenRevocationRequest(self,
request=TokenRevocationRequest,
request_args=None, extra_args=None,
**kwargs):
if request_args is None:
request_args = {}
token = self.get_token(**kwargs)
request_args["token"] = token.access_token
return self.construct_request(request, request_args, extra_args)
def construct_ResourceRequest(self, request=ResourceRequest,
request_args=None, extra_args=None,
**kwargs):
if request_args is None:
request_args = {}
token = self.get_token(**kwargs)
request_args["access_token"] = token.access_token
return self.construct_request(request, request_args, extra_args)
def get_or_post(self, uri, method, req,
content_type=DEFAULT_POST_CONTENT_TYPE, **kwargs):
if method == "GET":
_qp = req.to_urlencoded()
if _qp:
path = uri + '?' + _qp
else:
path = uri
body = None
elif method == "POST":
path = uri
if content_type == URL_ENCODED:
body = req.to_urlencoded()
elif content_type == JSON_ENCODED:
body = req.to_json()
else:
raise UnSupported(
"Unsupported content type: '%s'" % content_type)
header_ext = {"content-type": content_type}
if "headers" in kwargs.keys():
kwargs["headers"].update(header_ext)
else:
kwargs["headers"] = header_ext
else:
raise Exception("Unsupported HTTP method: '%s'" % method)
return path, body, kwargs
def uri_and_body(self, reqmsg, cis, method="POST", request_args=None,
**kwargs):
if "endpoint" in kwargs and kwargs["endpoint"]:
uri = kwargs["endpoint"]
else:
uri = self._endpoint(self.request2endpoint[reqmsg.__name__],
**request_args)
uri, body, kwargs = self.get_or_post(uri, method, cis, **kwargs)
try:
h_args = {"headers": kwargs["headers"]}
except KeyError:
h_args = {}
return uri, body, h_args, cis
def request_info(self, request, method="POST", request_args=None,
extra_args=None, **kwargs):
if request_args is None:
request_args = {}
try:
cls = getattr(self, "construct_%s" % request.__name__)
cis = cls(request_args=request_args, extra_args=extra_args,
**kwargs)
except AttributeError:
cis = self.construct_request(request, request_args, extra_args)
if "authn_method" in kwargs:
h_arg = self.init_authentication_method(cis,
request_args=request_args,
**kwargs)
else:
h_arg = None
if h_arg:
if "headers" in kwargs.keys():
kwargs["headers"].update(h_arg["headers"])
else:
kwargs["headers"] = h_arg["headers"]
return self.uri_and_body(request, cis, method, request_args,
**kwargs)
def authorization_request_info(self, request_args=None, extra_args=None,
**kwargs):
return self.request_info(AuthorizationRequest, "GET",
request_args, extra_args, **kwargs)
def parse_response(self, response, info="", sformat="json", state="",
**kwargs):
"""
Parse a response
:param response: Response type
:param info: The response, can be either in a JSON or an urlencoded
format
:param sformat: Which serialization that was used
:param state:
:param kwargs: Extra key word arguments
:return: The parsed and to some extend verified response
"""
_r2e = self.response2error
if sformat == "urlencoded":
if '?' in info or '#' in info:
parts = urlparse.urlparse(info)
scheme, netloc, path, params, query, fragment = parts[:6]
# either query of fragment
if query:
info = query
else:
info = fragment
err = None
try:
resp = response().deserialize(info, sformat, **kwargs)
if "error" in resp and not isinstance(resp, ErrorResponse):
resp = None
try:
errmsgs = _r2e[response.__name__]
except KeyError:
errmsgs = [ErrorResponse]
try:
for errmsg in errmsgs:
try:
resp = errmsg().deserialize(info, sformat)
resp.verify()
break
except Exception, aerr:
resp = None
err = aerr
except KeyError:
pass
elif resp.only_extras():
resp = None
else:
verf = resp.verify(**kwargs)
if not verf:
raise PyoidcError("Verification of the response failed")
if resp.type() == "AuthorizationResponse" and \
"scope" not in resp:
try:
resp["scope"] = kwargs["scope"]
except KeyError:
pass
except Exception, derr:
resp = None
err = derr
if not resp:
if err:
raise err
else:
raise ResponseError("Missing or faulty response")
if resp.type() in ["AuthorizationResponse", "AccessTokenResponse"]:
try:
_state = resp["state"]
except (AttributeError, KeyError):
_state = ""
if not _state:
_state = state
try:
self.grant[_state].update(resp)
except KeyError:
self.grant[_state] = self.grant_class(resp=resp)
return resp
def test_load_null_jwks():
kj = KeyJar()
with pytest.raises(JWKSError):
kj.import_jwks({"keys": [None, None]}, "")
def __init__(self, name, sdb, cdb, authn_broker, authz, client_authn,
symkey="", urlmap=None, iv=0, default_scope="",
ca_bundle=None, seed=b"", client_authn_methods=None,
authn_at_registration="", client_info_url="",
secret_lifetime=86400, jwks_uri='', keyjar=None,
capabilities=None, verify_ssl=True, baseurl='', hostname='',
config=None, behavior=None, lifetime_policy=None, **kwargs):
if not name.endswith("/"):
name += "/"
try:
args = {'server_cls': kwargs['server_cls']}
except KeyError:
args = {}
provider.Provider.__init__(self, name, sdb, cdb, authn_broker, authz,
client_authn, symkey, urlmap, iv,
default_scope, ca_bundle, **args)
self.endp.extend([RegistrationEndpoint, ClientInfoEndpoint,
RevocationEndpoint, IntrospectionEndpoint])
# dictionary of client authentication methods
self.client_authn_methods = client_authn_methods
if authn_at_registration:
if authn_at_registration not in client_authn_methods:
raise UnknownAuthnMethod(authn_at_registration)
self.authn_at_registration = authn_at_registration
self.seed = seed
self.client_info_url = client_info_url
self.secret_lifetime = secret_lifetime
self.jwks_uri = jwks_uri
self.verify_ssl = verify_ssl
try:
self.scopes = kwargs['scopes']
except KeyError:
self.scopes = ['offline_access']
self.keyjar = keyjar
if self.keyjar is None:
self.keyjar = KeyJar(verify_ssl=self.verify_ssl)
if capabilities:
self.capabilities = self.provider_features(
provider_config=capabilities)
else:
self.capabilities = self.provider_features()
self.baseurl = baseurl or name
self.hostname = hostname or socket.gethostname()
self.kid = {"sig": {}, "enc": {}}
self.config = config or {}
self.behavior = behavior or {}
self.token_policy = {'access_token': {}, 'refresh_token': {}}
if lifetime_policy is None:
self.lifetime_policy = {
'access_token': {
'code': 600,
'token': 120,
'implicit': 120,
'authorization_code': 600,
'client_credentials': 600,
'password': 600
},
'refresh_token': {
'code': 3600,
'token': 3600,
'implicit': 3600,
'authorization_code': 3600,
'client_credentials': 3600,
'password': 3600
}
}
else:
self.lifetime_policy = lifetime_policy
self.token_handler = TokenHandler(self.baseurl, self.token_policy,
keyjar=self.keyjar)
def __init__(self,
name,
sdb,
cdb,
authn_broker,
authz,
client_authn,
symkey=None,
urlmap=None,
iv=0,
default_scope="",
ca_bundle=None,
seed=b"",
client_authn_methods=None,
authn_at_registration="",
client_info_url="",
secret_lifetime=86400,
jwks_uri="",
keyjar=None,
capabilities=None,
verify_ssl=True,
baseurl="",
hostname="",
config=None,
behavior=None,
lifetime_policy=None,
message_factory=ExtensionMessageFactory,
**kwargs):
if not name.endswith("/"):
name += "/"
try:
args = {"server_cls": kwargs["server_cls"]}
except KeyError:
args = {}
super().__init__(name,
sdb,
cdb,
authn_broker,
authz,
client_authn,
symkey,
urlmap,
iv,
default_scope,
ca_bundle,
message_factory=message_factory,
**args)
self.endp.extend([
RegistrationEndpoint,
ClientInfoEndpoint,
RevocationEndpoint,
IntrospectionEndpoint,
])
# dictionary of client authentication methods
self.client_authn_methods = client_authn_methods
if authn_at_registration:
if authn_at_registration not in client_authn_methods:
raise UnknownAuthnMethod(authn_at_registration)
self.authn_at_registration = authn_at_registration
self.seed = seed
self.client_info_url = client_info_url
self.secret_lifetime = secret_lifetime
self.jwks_uri = jwks_uri
self.verify_ssl = verify_ssl
self.scopes.extend(kwargs.get("scopes", []))
self.keyjar = keyjar # type: KeyJar
if self.keyjar is None:
self.keyjar = KeyJar(verify_ssl=self.verify_ssl)
if capabilities:
self.capabilities = self.provider_features(
provider_config=capabilities)
else:
self.capabilities = self.provider_features()
self.baseurl = baseurl or name
self.hostname = hostname or socket.gethostname()
self.kid = {"sig": {}, "enc": {}} # type: Dict[str, Dict[str, str]]
self.config = config or {}
self.behavior = behavior or {}
self.token_policy = {
"access_token": {},
"refresh_token": {},
} # type: Dict[str, Dict[str, Dict[str, int]]]
if lifetime_policy is None:
self.lifetime_policy = {
"access_token": {
"code": 600,
"token": 120,
"implicit": 120,
"authorization_code": 600,
"client_credentials": 600,
"password": 600,
},
"refresh_token": {
"code": 3600,
"token": 3600,
"implicit": 3600,
"authorization_code": 3600,
"client_credentials": 3600,
"password": 3600,
},
}
else:
self.lifetime_policy = lifetime_policy
self.token_handler = TokenHandler(self.baseurl,
self.token_policy,
keyjar=self.keyjar)
class Provider(provider.Provider):
"""
A OAuth2 RP that knows all the OAuth2 extensions I've implemented
"""
def __init__(self, name, sdb, cdb, authn_broker, authz, client_authn,
symkey="", urlmap=None, iv=0, default_scope="",
ca_bundle=None, seed=b"", client_authn_methods=None,
authn_at_registration="", client_info_url="",
secret_lifetime=86400, jwks_uri='', keyjar=None,
capabilities=None, verify_ssl=True, baseurl='', hostname='',
config=None, behavior=None, lifetime_policy=None, **kwargs):
if not name.endswith("/"):
name += "/"
try:
args = {'server_cls': kwargs['server_cls']}
except KeyError:
args = {}
provider.Provider.__init__(self, name, sdb, cdb, authn_broker, authz,
client_authn, symkey, urlmap, iv,
default_scope, ca_bundle, **args)
self.endp.extend([RegistrationEndpoint, ClientInfoEndpoint,
RevocationEndpoint, IntrospectionEndpoint])
# dictionary of client authentication methods
self.client_authn_methods = client_authn_methods
if authn_at_registration:
if authn_at_registration not in client_authn_methods:
raise UnknownAuthnMethod(authn_at_registration)
self.authn_at_registration = authn_at_registration
self.seed = seed
self.client_info_url = client_info_url
self.secret_lifetime = secret_lifetime
self.jwks_uri = jwks_uri
self.verify_ssl = verify_ssl
try:
self.scopes = kwargs['scopes']
except KeyError:
self.scopes = ['offline_access']
self.keyjar = keyjar
if self.keyjar is None:
self.keyjar = KeyJar(verify_ssl=self.verify_ssl)
if capabilities:
self.capabilities = self.provider_features(
provider_config=capabilities)
else:
self.capabilities = self.provider_features()
self.baseurl = baseurl or name
self.hostname = hostname or socket.gethostname()
self.kid = {"sig": {}, "enc": {}}
self.config = config or {}
self.behavior = behavior or {}
self.token_policy = {'access_token': {}, 'refresh_token': {}}
if lifetime_policy is None:
self.lifetime_policy = {
'access_token': {
'code': 600,
'token': 120,
'implicit': 120,
'authorization_code': 600,
'client_credentials': 600,
'password': 600
},
'refresh_token': {
'code': 3600,
'token': 3600,
'implicit': 3600,
'authorization_code': 3600,
'client_credentials': 3600,
'password': 3600
}
}
else:
self.lifetime_policy = lifetime_policy
self.token_handler = TokenHandler(self.baseurl, self.token_policy,
keyjar=self.keyjar)
@staticmethod
def _uris_to_tuples(uris):
tup = []
for uri in uris:
base, query = splitquery(uri)
if query:
tup.append((base, query))
else:
tup.append((base, ""))
return tup
@staticmethod
def _tuples_to_uris(items):
_uri = []
for url, query in items:
if query:
_uri.append("%s?%s" % (url, query))
else:
_uri.append(url)
return _uri
def load_keys(self, request, client_id, client_secret):
try:
self.keyjar.load_keys(request, client_id)
try:
n_keys = len(self.keyjar[client_id])
msg = "Found {} keys for client_id={}"
logger.debug(msg.format(n_keys, client_id))
except KeyError:
pass
except Exception as err:
msg = "Failed to load client keys: {}"
logger.error(msg.format(sanitize(request.to_dict())))
logger.error("%s", err)
err = ClientRegistrationError(
error="invalid_configuration_parameter",
error_description="%s" % err)
return Response(err.to_json(), content="application/json",
status="400 Bad Request")
# Add the client_secret as a symmetric key to the keyjar
_kc = KeyBundle([{"kty": "oct", "key": client_secret,
"use": "ver"},
{"kty": "oct", "key": client_secret,
"use": "sig"}])
try:
self.keyjar[client_id].append(_kc)
except KeyError:
self.keyjar[client_id] = [_kc]
@staticmethod
def verify_correct(cinfo, restrictions):
for fname, arg in restrictions.items():
func = restrict.factory(fname)
res = func(arg, cinfo)
if res:
raise RestrictionError(res)
def set_token_policy(self, cid, cinfo):
for ttyp in ['access_token', 'refresh_token']:
pol = {}
for rgtyp in ['response_type', 'grant_type']:
try:
rtyp = cinfo[rgtyp]
except KeyError:
pass
else:
for typ in rtyp:
try:
pol[typ] = self.lifetime_policy[ttyp][typ]
except KeyError:
pass
self.token_policy[ttyp][cid] = pol
def create_new_client(self, request, restrictions):
"""
:param request: The Client registration request
:param restrictions: Restrictions on the client
:return: The client_id
"""
_cinfo = request.to_dict()
self.match_client_request(_cinfo)
# create new id and secret
_id = rndstr(12)
while _id in self.cdb:
_id = rndstr(12)
_cinfo["client_id"] = _id
_cinfo["client_secret"] = secret(self.seed, _id)
_cinfo["client_id_issued_at"] = utc_time_sans_frac()
_cinfo["client_secret_expires_at"] = utc_time_sans_frac() + self.secret_lifetime
# If I support client info endpoint
if ClientInfoEndpoint in self.endp:
_cinfo["registration_access_token"] = rndstr(32)
_cinfo["registration_client_uri"] = "%s%s%s?client_id=%s" % (
self.name, self.client_info_url, ClientInfoEndpoint.etype,
_id)
if "redirect_uris" in request:
_cinfo["redirect_uris"] = self._uris_to_tuples(
request["redirect_uris"])
self.load_keys(request, _id, _cinfo["client_secret"])
try:
_behav = self.behavior['client_registration']
except KeyError:
pass
else:
self.verify_correct(_cinfo, _behav)
self.set_token_policy(_id, _cinfo)
self.cdb[_id] = _cinfo
return _id
def match_client_request(self, request):
for _pref, _prov in PREFERENCE2PROVIDER.items():
if _pref in request:
if _pref == "response_types":
for val in request[_pref]:
match = False
p = set(val.split(" "))
for cv in self.capabilities[_prov]:
if p == set(cv.split(' ')):
match = True
break
if not match:
raise CapabilitiesMisMatch(
'Not allowed {}'.format(_pref))
else:
if isinstance(request[_pref], six.string_types):
if request[_pref] not in self.capabilities[_prov]:
raise CapabilitiesMisMatch(
'Not allowed {}'.format(_pref))
else:
if not set(request[_pref]).issubset(
set(self.capabilities[_prov])):
raise CapabilitiesMisMatch(
'Not allowed {}'.format(_pref))
def client_info(self, client_id):
_cinfo = self.cdb[client_id].copy()
if not valid_client_info(_cinfo):
err = ErrorResponse(
error="invalid_client",
error_description="Invalid client secret")
return BadRequest(err.to_json(), content="application/json")
try:
_cinfo["redirect_uris"] = self._tuples_to_uris(
_cinfo["redirect_uris"])
except KeyError:
pass
msg = ClientInfoResponse(**_cinfo)
return Response(msg.to_json(), content="application/json")
def client_info_update(self, client_id, request):
_cinfo = self.cdb[client_id].copy()
try:
_cinfo["redirect_uris"] = self._tuples_to_uris(
_cinfo["redirect_uris"])
except KeyError:
pass
for key, value in request.items():
if key in ["client_secret", "client_id"]:
# assure it's the same
try:
assert value == _cinfo[key]
except AssertionError:
raise ModificationForbidden("Not allowed to change")
else:
_cinfo[key] = value
for key in list(_cinfo.keys()):
if key in ["client_id_issued_at", "client_secret_expires_at",
"registration_access_token", "registration_client_uri"]:
continue
if key not in request:
del _cinfo[key]
if "redirect_uris" in request:
_cinfo["redirect_uris"] = self._uris_to_tuples(
request["redirect_uris"])
self.cdb[client_id] = _cinfo
def verify_client(self, environ, areq, authn_method, client_id=""):
"""
:param environ: WSGI environ
:param areq: The request
:param authn_method: client authentication method
:return:
"""
if not client_id:
client_id = get_client_id(self.cdb, areq,
environ["HTTP_AUTHORIZATION"])
try:
method = self.client_authn_methods[authn_method]
except KeyError:
raise UnSupported()
return method(self).verify(environ, client_id=client_id)
def consume_software_statement(self, software_statement):
return {}
def registration_endpoint(self, **kwargs):
"""
:param request: The request
:param authn: Client authentication information
:param kwargs: extra keyword arguments
:return: A Response instance
"""
_request = RegistrationRequest().deserialize(kwargs['request'], "json")
try:
_request.verify(keyjar=self.keyjar)
except InvalidRedirectUri as err:
msg = ClientRegistrationError(error="invalid_redirect_uri",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
except (MissingPage, VerificationError) as err:
msg = ClientRegistrationError(error="invalid_client_metadata",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
# If authentication is necessary at registration
if self.authn_at_registration:
try:
self.verify_client(kwargs['environ'], _request,
self.authn_at_registration)
except (AuthnFailure, UnknownAssertionType):
return Unauthorized()
client_restrictions = {}
if 'parsed_software_statement' in _request:
for ss in _request['parsed_software_statement']:
client_restrictions.update(self.consume_software_statement(ss))
del _request['software_statement']
del _request['parsed_software_statement']
try:
client_id = self.create_new_client(_request, client_restrictions)
except CapabilitiesMisMatch as err:
msg = ClientRegistrationError(error="invalid_client_metadata",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
except RestrictionError as err:
msg = ClientRegistrationError(error="invalid_client_metadata",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
return self.client_info(client_id)
def client_info_endpoint(self, method="GET", **kwargs):
"""
Operations on this endpoint are switched through the use of different
HTTP methods
:param method: HTTP method used for the request
:param kwargs: keyword arguments
:return: A Response instance
"""
_query = compact(parse_qs(kwargs['query']))
try:
_id = _query["client_id"]
except KeyError:
return BadRequest("Missing query component")
try:
assert _id in self.cdb
except AssertionError:
return Unauthorized()
# authenticated client
try:
self.verify_client(kwargs['environ'], kwargs['request'],
"bearer_header", client_id=_id)
except (AuthnFailure, UnknownAssertionType):
return Unauthorized()
if method == "GET":
return self.client_info(_id)
elif method == "PUT":
try:
_request = ClientUpdateRequest().from_json(kwargs['request'])
except ValueError as err:
return BadRequest(str(err))
try:
_request.verify()
except InvalidRedirectUri as err:
msg = ClientRegistrationError(error="invalid_redirect_uri",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
except (MissingPage, VerificationError) as err:
msg = ClientRegistrationError(error="invalid_client_metadata",
error_description="%s" % err)
return BadRequest(msg.to_json(), content="application/json")
try:
self.client_info_update(_id, _request)
return self.client_info(_id)
except ModificationForbidden:
return Forbidden()
elif method == "DELETE":
try:
del self.cdb[_id]
except KeyError:
return Unauthorized()
else:
return NoContent()
def provider_features(self, pcr_class=ServerMetadata, provider_config=None):
"""
Specifies what the server capabilities are.
:param pcr_class:
:return: ProviderConfigurationResponse instance
"""
_provider_info = pcr_class(**CAPABILITIES)
_provider_info["scopes_supported"] = self.scopes
sign_algs = list(jws.SIGNER_ALGS.keys())
sign_algs.remove('none')
sign_algs = sorted(sign_algs, key=cmp_to_key(sort_sign_alg))
_pat1 = "{}_endpoint_auth_signing_alg_values_supported"
_pat2 = "{}_endpoint_auth_methods_supported"
for typ in ["token", "revocation", "introspection"]:
_provider_info[_pat1.format(typ)] = sign_algs
_provider_info[_pat2.format(typ)] = AUTH_METHODS_SUPPORTED
if provider_config:
_provider_info.update(provider_config)
return _provider_info
def verify_capabilities(self, capabilities):
"""
Verify that what the admin wants the server to do actually
can be done by this implementation.
:param capabilities: The asked for capabilities as a dictionary
or a ProviderConfigurationResponse instance. The later can be
treated as a dictionary.
:return: True or False
"""
_pinfo = self.provider_features()
for key, val in capabilities.items():
if isinstance(val, six.string_types):
try:
if val in _pinfo[key]:
continue
else:
return False
except KeyError:
return False
return True
def create_providerinfo(self, pcr_class=ASConfigurationResponse,
setup=None):
"""
Dynamically create the provider info response
:param pcr_class:
:param setup:
:return:
"""
_provider_info = self.capabilities
if self.jwks_uri and self.keyjar:
_provider_info["jwks_uri"] = self.jwks_uri
for endp in self.endp:
# _log_info("# %s, %s" % (endp, endp.name))
_provider_info['{}_endpoint'.format(endp.etype)] = os.path.join(
self.baseurl, endp.url)
if setup and isinstance(setup, dict):
for key in pcr_class.c_param.keys():
if key in setup:
_provider_info[key] = setup[key]
_provider_info["issuer"] = self.baseurl
_provider_info["version"] = "3.0"
return _provider_info
def providerinfo_endpoint(self, **kwargs):
_log_info = logger.info
_log_info("@providerinfo_endpoint")
try:
_response = self.create_providerinfo()
_log_info("provider_info_response: %s" % (_response.to_dict(),))
headers = [("Cache-Control", "no-store"), ("x-ffo", "bar")]
if 'handle' in kwargs:
(key, timestamp) = kwargs['handle']
if key.startswith(STR) and key.endswith(STR):
cookie = self.cookie_func(key, self.cookie_name, "pinfo",
self.sso_ttl)
headers.append(cookie)
resp = Response(_response.to_json(), content="application/json",
headers=headers)
except Exception:
message = traceback.format_exception(*sys.exc_info())
logger.error(message)
resp = Response(message, content="html/text")
return resp
@staticmethod
def verify_code_challenge(code_verifier, code_challenge,
code_challenge_method='S256'):
"""
Verify a PKCE (RFC7636) code challenge
:param code_verifier: The origin
:param code_challenge: The transformed verifier used as challenge
:return:
"""
_h = CC_METHOD[code_challenge_method](
code_verifier.encode()).hexdigest()
_cc = b64e(_h.encode())
if _cc.decode() != code_challenge:
logger.error('PCKE Code Challenge check failed')
err = TokenErrorResponse(error="invalid_request",
error_description="PCKE check failed")
return Response(err.to_json(), content="application/json",
status="401 Unauthorized")
return True
def do_access_token_response(self, access_token, atinfo, state,
refresh_token=None):
_tinfo = {'access_token': access_token, 'expires_in': atinfo['exp'],
'token_type': 'bearer', 'state': state}
try:
_tinfo['scope'] = atinfo['scope']
except KeyError:
pass
if refresh_token:
_tinfo['refresh_token'] = refresh_token
return AccessTokenResponse(**by_schema(AccessTokenResponse, **_tinfo))
def code_grant_type(self, areq):
# assert that the code is valid
try:
_info = self.sdb[areq["code"]]
except KeyError:
err = TokenErrorResponse(error="invalid_grant",
error_description="Unknown access grant")
return Response(err.to_json(), content="application/json",
status="401 Unauthorized")
authzreq = json.loads(_info['authzreq'])
if 'code_verifier' in areq:
try:
_method = authzreq['code_challenge_method']
except KeyError:
_method = 'S256'
resp = self.verify_code_challenge(areq['code_verifier'],
authzreq['code_challenge'],
_method)
if resp:
return resp
if 'state' in areq:
if self.sdb[areq['code']]['state'] != areq['state']:
logger.error('State value mismatch')
err = TokenErrorResponse(error="unauthorized_client")
return Unauthorized(err.to_json(), content="application/json")
resp = self.token_scope_check(areq, _info)
if resp:
return resp
# If redirect_uri was in the initial authorization request
# verify that the one given here is the correct one.
if "redirect_uri" in _info:
assert areq["redirect_uri"] == _info["redirect_uri"]
issue_refresh = False
if 'scope' in authzreq and 'offline_access' in authzreq['scope']:
if authzreq['response_type'] == 'code':
issue_refresh = True
try:
_tinfo = self.sdb.upgrade_to_token(areq["code"],
issue_refresh=issue_refresh)
except AccessCodeUsed:
err = TokenErrorResponse(error="invalid_grant",
error_description="Access grant used")
return Response(err.to_json(), content="application/json",
status="401 Unauthorized")
logger.debug("_tinfo: %s" % _tinfo)
atr = AccessTokenResponse(**by_schema(AccessTokenResponse, **_tinfo))
logger.debug("AccessTokenResponse: %s" % atr)
return Response(atr.to_json(), content="application/json")
def client_credentials_grant_type(self, areq):
_at = self.token_handler.get_access_token(areq['client_id'],
scope=areq['scope'],
grant_type='client_credentials')
_info = self.token_handler.token_factory.get_info(_at)
try:
_rt = self.token_handler.get_refresh_token(
self.baseurl, _info['access_token'], 'client_credentials')
except NotAllowed:
atr = self.do_access_token_response(_at, _info, areq['state'])
else:
atr = self.do_access_token_response(_at, _info, areq['state'], _rt)
return Response(atr.to_json(), content="application/json")
def password_grant_type(self, areq):
_at = self.token_handler.get_access_token(areq['client_id'],
scope=areq['scope'],
grant_type='password')
_info = self.token_handler.token_factory.get_info(_at)
try:
_rt = self.token_handler.get_refresh_token(
self.baseurl, _info['access_token'], 'password')
except NotAllowed:
atr = self.do_access_token_response(_at, _info, areq['state'])
else:
atr = self.do_access_token_response(_at, _info, areq['state'], _rt)
return Response(atr.to_json(), content="application/json")
def refresh_token_grant_type(self, areq):
at = self.token_handler.refresh_access_token(
self.baseurl, areq['access_token'], 'refresh_token')
atr = AccessTokenResponse(**by_schema(AccessTokenResponse, **at))
return Response(atr.to_json(), content="application/json")
def token_endpoint(self, authn="", **kwargs):
"""
This is where clients come to get their access tokens
"""
logger.debug("- token -")
body = kwargs["request"]
logger.debug("body: %s" % body)
areq = AccessTokenRequest().deserialize(body, "urlencoded")
try:
self.client_authn(self, areq, authn)
except FailedAuthentication as err:
logger.error(err)
err = TokenErrorResponse(error="unauthorized_client",
error_description="%s" % err)
return Response(err.to_json(), content="application/json",
status="401 Unauthorized")
logger.debug("AccessTokenRequest: %s" % areq)
_grant_type = areq["grant_type"]
if _grant_type == "authorization_code":
return self.code_grant_type(areq)
elif _grant_type == 'client_credentials':
return self.client_credentials_grant_type(areq)
elif _grant_type == 'password':
return self.password_grant_type(areq)
elif _grant_type == 'refresh_token':
return self.refresh_token_grant_type(areq)
else:
raise UnSupported('grant_type: {}'.format(_grant_type))
def key_setup(self, local_path, vault="keys", sig=None, enc=None):
"""
my keys
:param local_path: The path to where the JWKs should be stored
:param vault: Where the private key will be stored
:param sig: Key for signature
:param enc: Key for encryption
:return: A URL the RP can use to download the key.
"""
self.jwks_uri = key_export(self.baseurl, local_path, vault, self.keyjar,
fqdn=self.hostname, sig=sig, enc=enc)
@staticmethod
def token_access(endpoint, client_id, token_info):
# simple rules: if client_id in azp or aud it's allow to introspect
# to revoke it has to be in azr
allow = False
if endpoint == 'revocation_endpoint':
if 'azr' in token_info and client_id == token_info['azr']:
allow = True
elif len(token_info['aud']) == 1 and token_info['aud'] == [client_id]:
allow = True
else: # has to be introspection endpoint
if 'azr' in token_info and client_id == token_info['azr']:
allow = True
elif 'aud' in token_info:
if client_id in token_info['aud']:
allow = True
return allow
def get_token_info(self, authn, req, endpoint):
"""
:param authn:
:param req:
:return:
"""
try:
client_id = self.client_authn(self, req, authn)
except FailedAuthentication as err:
logger.error(err)
err = TokenErrorResponse(error="unauthorized_client",
error_description="%s" % err)
return Response(err.to_json(), content="application/json",
status="401 Unauthorized")
logger.debug('{}: {} requesting {}'.format(endpoint, client_id,
req.to_dict()))
try:
token_type = req['token_type_hint']
except KeyError:
try:
_info = self.sdb.token_factory['access_token'].info(
req['token'])
except KeyError:
try:
_info = self.sdb.token_factory['refresh_token'].get_info(
req['token'])
except KeyError:
raise
else:
token_type = 'refresh_token'
else:
token_type = 'access_token'
else:
try:
_info = self.sdb.token_factory[token_type].get_info(
req['token'])
except KeyError:
raise
if not self.token_access(endpoint, client_id, _info):
return BadRequest()
return client_id, token_type, _info
def revocation_endpoint(self, authn='', request=None, **kwargs):
"""
Implements RFC7009 allows a client to invalidate an access or refresh
token.
:param authn: Client Authentication information
:param request: The revocation request
:param kwargs:
:return:
"""
trr = TokenRevocationRequest().deserialize(request, "urlencoded")
resp = self.get_token_info(authn, trr, 'revocation_endpoint')
if isinstance(resp, Response):
return resp
else:
client_id, token_type, _info = resp
logger.info('{} token revocation: {}'.format(client_id, trr.to_dict()))
try:
self.sdb.token_factory[token_type].invalidate(trr['token'])
except KeyError:
return BadRequest()
else:
return Response('OK')
def introspection_endpoint(self, authn='', request=None, **kwargs):
"""
Implements RFC7662
:param authn: Client Authentication information
:param request: The introspection request
:param kwargs:
:return:
"""
tir = TokenIntrospectionRequest().deserialize(request, "urlencoded")
resp = self.get_token_info(authn, tir, 'introspection_endpoint')
if isinstance(resp, Response):
return resp
else:
client_id, token_type, _info = resp
logger.info('{} token introspection: {}'.format(client_id,
tir.to_dict()))
ir = TokenIntrospectionResponse(
active=self.sdb.token_factory[token_type].is_valid(_info),
**_info.to_dict())
ir.weed()
return Response(ir.to_json(), content="application/json")
@staticmethod
def get_instance():
"""
Returns an instance of the singleton class.
"""
if not TestConfiguration._instance:
TestConfiguration._instance = TestConfiguration()
return TestConfiguration._instance
CLIENT_ID = "client_1"
_, idp_key_file = FileGenerator.get_instance().generate_cert("idp")
KC_RSA = keybundle_from_local_file(idp_key_file.name, "RSA", ["ver", "sig"],
"op_sign")
KEYJAR = KeyJar()
KEYJAR[CLIENT_ID] = [KC_RSA]
KEYJAR[""] = KC_RSA
JWKS = KEYJAR.export_jwks()
CDB = {
CLIENT_ID: {
"client_secret":
"client_secret",
"redirect_uris":
[("%sauthz" % TestConfiguration.get_instance().rp_base, None)],
"client_salt":
"salted",
"response_types": ["code", "token"]
}
}
import argparse
import json
import os
from oic.utils.keyio import KeyJar
from fedoidc import MetadataStatement
from fedoidc.signing_service import InternalSigningService
parser = argparse.ArgumentParser()
parser.add_argument('-r', dest='request')
parser.add_argument('-a', dest='alg', default='RS256')
parser.add_argument(dest="nickname")
args = parser.parse_args()
if not os.path.isdir(args.nickname):
print('No such entity')
exit(-1)
kj = KeyJar()
iss = open(os.path.join(args.nickname, 'iss')).read()
jwks = open(os.path.join(args.nickname, 'jwks')).read()
kj.import_jwks(jwks=json.loads(jwks), issuer=iss)
sigserv = InternalSigningService(iss=iss, signing_keys=kj, alg=args.alg)
msg = MetadataStatement()
msg.from_json(open(args.request).read())
print(sigserv(msg))
class Client(oauth2.Client):
def __init__(self,
client_id=None,
ca_certs=None,
client_authn_method=None,
keyjar=None,
verify_ssl=True):
oauth2.Client.__init__(self,
client_id=client_id,
ca_certs=ca_certs,
client_authn_method=client_authn_method,
keyjar=keyjar,
verify_ssl=verify_ssl)
self.allow = {}
self.request2endpoint.update({
"RegistrationRequest":
"registration_endpoint",
"ClientUpdateRequest":
"clientinfo_endpoint"
})
self.registration_response = None
def construct_RegistrationRequest(self,
request=RegistrationRequest,
request_args=None,
extra_args=None,
**kwargs):
if request_args is None:
request_args = {}
return self.construct_request(request, request_args, extra_args)
def construct_ClientUpdateRequest(self,
request=ClientUpdateRequest,
request_args=None,
extra_args=None,
**kwargs):
if request_args is None:
request_args = {}
return self.construct_request(request, request_args, extra_args)
def do_client_registration(self,
request=RegistrationRequest,
body_type="",
method="GET",
request_args=None,
extra_args=None,
http_args=None,
response_cls=ClientInfoResponse,
**kwargs):
url, body, ht_args, csi = self.request_info(request, method,
request_args, extra_args,
**kwargs)
if http_args is None:
http_args = ht_args
else:
http_args.update(http_args)
resp = self.request_and_return(url,
response_cls,
method,
body,
body_type,
http_args=http_args)
return resp
def do_client_read_request(self,
request=ClientUpdateRequest,
body_type="",
method="GET",
request_args=None,
extra_args=None,
http_args=None,
response_cls=ClientInfoResponse,
**kwargs):
url, body, ht_args, csi = self.request_info(request, method,
request_args, extra_args,
**kwargs)
if http_args is None:
http_args = ht_args
else:
http_args.update(http_args)
resp = self.request_and_return(url,
response_cls,
method,
body,
body_type,
http_args=http_args)
return resp
def do_client_update_request(self,
request=ClientUpdateRequest,
body_type="",
method="PUT",
request_args=None,
extra_args=None,
http_args=None,
response_cls=ClientInfoResponse,
**kwargs):
url, body, ht_args, csi = self.request_info(request, method,
request_args, extra_args,
**kwargs)
if http_args is None:
http_args = ht_args
else:
http_args.update(http_args)
resp = self.request_and_return(url,
response_cls,
method,
body,
body_type,
http_args=http_args)
return resp
def do_client_delete_request(self,
request=ClientUpdateRequest,
body_type="",
method="DELETE",
request_args=None,
extra_args=None,
http_args=None,
response_cls=ClientInfoResponse,
**kwargs):
url, body, ht_args, csi = self.request_info(request, method,
request_args, extra_args,
**kwargs)
if http_args is None:
http_args = ht_args
else:
http_args.update(http_args)
resp = self.request_and_return(url,
response_cls,
method,
body,
body_type,
http_args=http_args)
return resp
def handle_provider_config(self, pcr, issuer, keys=True, endpoints=True):
"""
Deal with Provider Config Response
:param pcr: The ProviderConfigResponse instance
:param issuer: The one I thought should be the issuer of the config
:param keys: Should I deal with keys
:param endpoints: Should I deal with endpoints, that is store them
as attributes in self.
"""
if "issuer" in pcr:
_pcr_issuer = pcr["issuer"]
if pcr["issuer"].endswith("/"):
if issuer.endswith("/"):
_issuer = issuer
else:
_issuer = issuer + "/"
else:
if issuer.endswith("/"):
_issuer = issuer[:-1]
else:
_issuer = issuer
try:
_ = self.allow["issuer_mismatch"]
except KeyError:
try:
assert _issuer == _pcr_issuer
except AssertionError:
raise PyoidcError(
"provider info issuer mismatch '%s' != '%s'" %
(_issuer, _pcr_issuer))
self.provider_info = pcr
else:
_pcr_issuer = issuer
if endpoints:
for key, val in pcr.items():
if key.endswith("_endpoint"):
setattr(self, key, val)
if keys:
if self.keyjar is None:
self.keyjar = KeyJar()
self.keyjar.load_keys(pcr, _pcr_issuer)
def provider_config(self,
issuer,
keys=True,
endpoints=True,
response_cls=ProviderConfigurationResponse,
serv_pattern=OIDCONF_PATTERN):
if issuer.endswith("/"):
_issuer = issuer[:-1]
else:
_issuer = issuer
url = serv_pattern % _issuer
pcr = None
r = self.http_request(url)
if r.status_code == 200:
pcr = response_cls().from_json(r.text)
elif r.status_code == 302:
while r.status_code == 302:
r = self.http_request(r.headers["location"])
if r.status_code == 200:
pcr = response_cls().from_json(r.text)
break
if pcr is None:
raise PyoidcError("Trying '%s', status %s" % (url, r.status_code))
self.handle_provider_config(pcr, issuer, keys, endpoints)
return pcr
def store_registration_info(self, reginfo):
self.registration_response = reginfo
self.client_secret = reginfo["client_secret"]
self.client_id = reginfo["client_id"]
self.redirect_uris = reginfo["redirect_uris"]
def handle_registration_info(self, response):
if response.status_code in [200, 201]:
resp = ClientInfoResponse().deserialize(response.text, "json")
self.store_registration_info(resp)
else:
err = ErrorResponse().deserialize(response.text, "json")
raise PyoidcError("Registration failed: %s" % err.to_json())
return resp
def register(self, url, **kwargs):
"""
Register the client at an OP
:param url: The OPs registration endpoint
:param kwargs: parameters to the registration request
:return:
"""
req = self.construct_RegistrationRequest(request_args=kwargs)
headers = {"content-type": "application/json"}
rsp = self.http_request(url,
"POST",
data=req.to_json(),
headers=headers)
return self.handle_registration_info(rsp)
def parse_authz_response(self, query):
aresp = self.parse_response(AuthorizationResponse,
info=query,
sformat="urlencoded",
keyjar=self.keyjar)
if aresp.type() == "ErrorResponse":
logger.info("ErrorResponse: %s" % aresp)
raise AuthzError(aresp.error)
logger.info("Aresp: %s" % aresp)
return aresp
def test_no_use(self):
kb = KeyBundle(JWK0["keys"])
kj = KeyJar()
kj.issuer_keys["abcdefgh"] = [kb]
enc_key = kj.get_encrypt_key("RSA", "abcdefgh")
assert enc_key != []
class Client(PBase):
_endpoints = ENDPOINTS
def __init__(self, client_id=None, ca_certs=None, client_authn_method=None,
keyjar=None, verify_ssl=True, config=None, client_cert=None):
"""
:param client_id: The client identifier
:param ca_certs: Certificates used to verify HTTPS certificates
:param client_authn_method: Methods that this client can use to
authenticate itself. It's a dictionary with method names as
keys and method classes as values.
:param verify_ssl: Whether the SSL certificate should be verified.
:return: Client instance
"""
PBase.__init__(self, ca_certs, verify_ssl=verify_ssl,
client_cert=client_cert, keyjar=keyjar)
self.client_id = client_id
self.client_authn_method = client_authn_method
self.verify_ssl = verify_ssl
# self.secret_type = "basic "
# self.state = None
self.nonce = None
self.grant = {}
self.state2nonce = {}
# own endpoint
self.redirect_uris = [None]
# service endpoints
self.authorization_endpoint = None
self.token_endpoint = None
self.token_revocation_endpoint = None
self.request2endpoint = REQUEST2ENDPOINT
self.response2error = RESPONSE2ERROR
self.grant_class = Grant
self.token_class = Token
self.provider_info = {}
self._c_secret = None
self.kid = {"sig": {}, "enc": {}}
self.authz_req = None
# the OAuth issuer is the URL of the authorization server's
# configuration information location
self.config = config or {}
try:
self.issuer = self.config['issuer']
except KeyError:
self.issuer = ''
self.allow = {}
self.provider_info = {}
def store_response(self, clinst, text):
pass
def get_client_secret(self):
return self._c_secret
def set_client_secret(self, val):
if not val:
self._c_secret = ""
else:
self._c_secret = val
# client uses it for signing
# Server might also use it for signing which means the
# client uses it for verifying server signatures
if self.keyjar is None:
self.keyjar = KeyJar()
self.keyjar.add_symmetric("", str(val))
client_secret = property(get_client_secret, set_client_secret)
def reset(self):
# self.state = None
self.nonce = None
self.grant = {}
self.authorization_endpoint = None
self.token_endpoint = None
self.redirect_uris = None
def grant_from_state(self, state):
for key, grant in self.grant.items():
if key == state:
return grant
return None
def _parse_args(self, request, **kwargs):
ar_args = kwargs.copy()
for prop in request.c_param.keys():
if prop in ar_args:
continue
else:
if prop == "redirect_uri":
_val = getattr(self, "redirect_uris", [None])[0]
if _val:
ar_args[prop] = _val
else:
_val = getattr(self, prop, None)
if _val:
ar_args[prop] = _val
return ar_args
def _endpoint(self, endpoint, **kwargs):
try:
uri = kwargs[endpoint]
if uri:
del kwargs[endpoint]
except KeyError:
uri = ""
if not uri:
try:
uri = getattr(self, endpoint)
except Exception:
raise MissingEndpoint("No '%s' specified" % endpoint)
if not uri:
raise MissingEndpoint("No '%s' specified" % endpoint)
return uri
def get_grant(self, state, **kwargs):
# try:
# _state = kwargs["state"]
# if not _state:
# _state = self.state
# except KeyError:
# _state = self.state
try:
return self.grant[state]
except KeyError:
raise GrantError("No grant found for state:'%s'" % state)
def get_token(self, also_expired=False, **kwargs):
try:
return kwargs["token"]
except KeyError:
grant = self.get_grant(**kwargs)
try:
token = grant.get_token(kwargs["scope"])
except KeyError:
token = grant.get_token("")
if not token:
try:
token = self.grant[kwargs["state"]].get_token("")
except KeyError:
raise TokenError("No token found for scope")
if token is None:
raise TokenError("No suitable token found")
if also_expired:
return token
elif token.is_valid():
return token
else:
raise TokenError("Token has expired")
def construct_request(self, request, request_args=None, extra_args=None):
if request_args is None:
request_args = {}
# logger.debug("request_args: %s" % sanitize(request_args))
kwargs = self._parse_args(request, **request_args)
if extra_args:
kwargs.update(extra_args)
# logger.debug("kwargs: %s" % sanitize(kwargs))
# logger.debug("request: %s" % sanitize(request))
return request(**kwargs)
def construct_Message(self, request=Message, request_args=None,
extra_args=None, **kwargs):
return self.construct_request(request, request_args, extra_args)
def construct_AuthorizationRequest(self, request=AuthorizationRequest,
request_args=None, extra_args=None,
**kwargs):
if request_args is not None:
try: # change default
new = request_args["redirect_uri"]
if new:
self.redirect_uris = [new]
except KeyError:
pass
else:
request_args = {}
if "client_id" not in request_args:
request_args["client_id"] = self.client_id
elif not request_args["client_id"]:
request_args["client_id"] = self.client_id
return self.construct_request(request, request_args, extra_args)
def construct_AccessTokenRequest(self,
request=AccessTokenRequest,
request_args=None, extra_args=None,
**kwargs):
if request_args is None:
request_args = {}
if request is not ROPCAccessTokenRequest:
grant = self.get_grant(**kwargs)
if not grant.is_valid():
raise GrantExpired("Authorization Code to old %s > %s" % (
utc_time_sans_frac(),
grant.grant_expiration_time))
request_args["code"] = grant.code
try:
request_args['state'] = kwargs['state']
except KeyError:
pass
if "grant_type" not in request_args:
request_args["grant_type"] = "authorization_code"
if "client_id" not in request_args:
request_args["client_id"] = self.client_id
elif not request_args["client_id"]:
request_args["client_id"] = self.client_id
return self.construct_request(request, request_args, extra_args)
def construct_RefreshAccessTokenRequest(self,
request=RefreshAccessTokenRequest,
request_args=None, extra_args=None,
**kwargs):
if request_args is None:
request_args = {}
token = self.get_token(also_expired=True, **kwargs)
request_args["refresh_token"] = token.refresh_token
try:
request_args["scope"] = token.scope
except AttributeError:
pass
return self.construct_request(request, request_args, extra_args)
# def construct_TokenRevocationRequest(self,
# request=TokenRevocationRequest,
# request_args=None, extra_args=None,
# **kwargs):
#
# if request_args is None:
# request_args = {}
#
# token = self.get_token(**kwargs)
#
# request_args["token"] = token.access_token
# return self.construct_request(request, request_args, extra_args)
def construct_ResourceRequest(self, request=ResourceRequest,
request_args=None, extra_args=None,
**kwargs):
if request_args is None:
request_args = {}
token = self.get_token(**kwargs)
request_args["access_token"] = token.access_token
return self.construct_request(request, request_args, extra_args)
def uri_and_body(self, reqmsg, cis, method="POST", request_args=None,
**kwargs):
if "endpoint" in kwargs and kwargs["endpoint"]:
uri = kwargs["endpoint"]
else:
uri = self._endpoint(self.request2endpoint[reqmsg.__name__],
**request_args)
uri, body, kwargs = get_or_post(uri, method, cis, **kwargs)
try:
h_args = {"headers": kwargs["headers"]}
except KeyError:
h_args = {}
return uri, body, h_args, cis
def request_info(self, request, method="POST", request_args=None,
extra_args=None, lax=False, **kwargs):
if request_args is None:
request_args = {}
try:
cls = getattr(self, "construct_%s" % request.__name__)
cis = cls(request_args=request_args, extra_args=extra_args,
**kwargs)
except AttributeError:
cis = self.construct_request(request, request_args, extra_args)
if self.events:
self.events.store('Protocol request', cis)
if 'nonce' in cis and 'state' in cis:
self.state2nonce[cis['state']] = cis['nonce']
cis.lax = lax
if "authn_method" in kwargs:
h_arg = self.init_authentication_method(cis,
request_args=request_args,
**kwargs)
else:
h_arg = None
if h_arg:
if "headers" in kwargs.keys():
kwargs["headers"].update(h_arg["headers"])
else:
kwargs["headers"] = h_arg["headers"]
return self.uri_and_body(request, cis, method, request_args,
**kwargs)
def authorization_request_info(self, request_args=None, extra_args=None,
**kwargs):
return self.request_info(AuthorizationRequest, "GET",
request_args, extra_args, **kwargs)
def get_urlinfo(self, info):
if '?' in info or '#' in info:
parts = urlparse(info)
scheme, netloc, path, params, query, fragment = parts[:6]
# either query of fragment
if query:
info = query
else:
info = fragment
return info
def parse_response(self, response, info="", sformat="json", state="",
**kwargs):
"""
Parse a response
:param response: Response type
:param info: The response, can be either in a JSON or an urlencoded
format
:param sformat: Which serialization that was used
:param state: The state
:param kwargs: Extra key word arguments
:return: The parsed and to some extend verified response
"""
_r2e = self.response2error
if sformat == "urlencoded":
info = self.get_urlinfo(info)
# if self.events:
# self.events.store('Response', info)
resp = response().deserialize(info, sformat, **kwargs)
msg = 'Initial response parsing => "{}"'
logger.debug(msg.format(sanitize(resp.to_dict())))
if self.events:
self.events.store('Response', resp.to_dict())
if "error" in resp and not isinstance(resp, ErrorResponse):
resp = None
try:
errmsgs = _r2e[response.__name__]
except KeyError:
errmsgs = [ErrorResponse]
try:
for errmsg in errmsgs:
try:
resp = errmsg().deserialize(info, sformat)
resp.verify()
break
except Exception:
resp = None
except KeyError:
pass
elif resp.only_extras():
resp = None
else:
kwargs["client_id"] = self.client_id
try:
kwargs['iss'] = self.provider_info['issuer']
except (KeyError, AttributeError):
if self.issuer:
kwargs['iss'] = self.issuer
if "key" not in kwargs and "keyjar" not in kwargs:
kwargs["keyjar"] = self.keyjar
logger.debug("Verify response with {}".format(sanitize(kwargs)))
verf = resp.verify(**kwargs)
if not verf:
logger.error('Verification of the response failed')
raise PyoidcError("Verification of the response failed")
if resp.type() == "AuthorizationResponse" and "scope" not in resp:
try:
resp["scope"] = kwargs["scope"]
except KeyError:
pass
if not resp:
logger.error('Missing or faulty response')
raise ResponseError("Missing or faulty response")
self.store_response(resp, info)
if resp.type() in ["AuthorizationResponse", "AccessTokenResponse"]:
try:
_state = resp["state"]
except (AttributeError, KeyError):
_state = ""
if not _state:
_state = state
try:
self.grant[_state].update(resp)
except KeyError:
self.grant[_state] = self.grant_class(resp=resp)
return resp
def init_authentication_method(self, cis, authn_method, request_args=None,
http_args=None, **kwargs):
if http_args is None:
http_args = {}
if request_args is None:
request_args = {}
if authn_method:
return self.client_authn_method[authn_method](self).construct(
cis, request_args, http_args, **kwargs)
else:
return http_args
def parse_request_response(self, reqresp, response, body_type, state="",
**kwargs):
if reqresp.status_code in SUCCESSFUL:
body_type = verify_header(reqresp, body_type)
elif reqresp.status_code in [302, 303]: # redirect
return reqresp
elif reqresp.status_code == 500:
logger.error("(%d) %s" % (reqresp.status_code,
sanitize(reqresp.text)))
raise ParseError("ERROR: Something went wrong: %s" % reqresp.text)
elif reqresp.status_code in [400, 401]:
# expecting an error response
if issubclass(response, ErrorResponse):
pass
else:
logger.error("(%d) %s" % (reqresp.status_code,
sanitize(reqresp.text)))
raise HttpError("HTTP ERROR: %s [%s] on %s" % (
reqresp.text, reqresp.status_code, reqresp.url))
if response:
if body_type == 'txt':
# no meaning trying to parse unstructured text
return reqresp.text
return self.parse_response(response, reqresp.text, body_type,
state, **kwargs)
# could be an error response
if reqresp.status_code in [200, 400, 401]:
if body_type == 'txt':
body_type = 'urlencoded'
try:
err = ErrorResponse().deserialize(reqresp.message,
method=body_type)
try:
err.verify()
except PyoidcError:
pass
else:
return err
except Exception:
pass
return reqresp
def request_and_return(self, url, response=None, method="GET", body=None,
body_type="json", state="", http_args=None,
**kwargs):
"""
:param url: The URL to which the request should be sent
:param response: Response type
:param method: Which HTTP method to use
:param body: A message body if any
:param body_type: The format of the body of the return message
:param http_args: Arguments for the HTTP client
:return: A cls or ErrorResponse instance or the HTTP response
instance if no response body was expected.
"""
if http_args is None:
http_args = {}
try:
resp = self.http_request(url, method, data=body, **http_args)
except Exception:
raise
if "keyjar" not in kwargs:
kwargs["keyjar"] = self.keyjar
return self.parse_request_response(resp, response, body_type, state,
**kwargs)
def do_authorization_request(self, request=AuthorizationRequest,
state="", body_type="", method="GET",
request_args=None, extra_args=None,
http_args=None,
response_cls=AuthorizationResponse,
**kwargs):
if state:
try:
request_args["state"] = state
except TypeError:
request_args = {"state": state}
kwargs['authn_endpoint'] = 'authorization'
url, body, ht_args, csi = self.request_info(request, method,
request_args, extra_args,
**kwargs)
try:
self.authz_req[request_args["state"]] = csi
except TypeError:
pass
if http_args is None:
http_args = ht_args
else:
http_args.update(ht_args)
try:
algs = kwargs["algs"]
except KeyError:
algs = {}
resp = self.request_and_return(url, response_cls, method, body,
body_type, state=state,
http_args=http_args, algs=algs)
if isinstance(resp, Message):
if resp.type() in RESPONSE2ERROR["AuthorizationResponse"]:
resp.state = csi.state
return resp
def do_access_token_request(self, request=AccessTokenRequest,
scope="", state="", body_type="json",
method="POST", request_args=None,
extra_args=None, http_args=None,
response_cls=AccessTokenResponse,
authn_method="", **kwargs):
kwargs['authn_endpoint'] = 'token'
# method is default POST
url, body, ht_args, csi = self.request_info(request, method=method,
request_args=request_args,
extra_args=extra_args,
scope=scope, state=state,
authn_method=authn_method,
**kwargs)
if http_args is None:
http_args = ht_args
else:
http_args.update(ht_args)
if self.events is not None:
self.events.store('request_url', url)
self.events.store('request_http_args', http_args)
self.events.store('Request', body)
logger.debug("<do_access_token> URL: %s, Body: %s" % (url,
sanitize(body)))
logger.debug("<do_access_token> response_cls: %s" % response_cls)
return self.request_and_return(url, response_cls, method, body,
body_type, state=state,
http_args=http_args, **kwargs)
def do_access_token_refresh(self, request=RefreshAccessTokenRequest,
state="", body_type="json", method="POST",
request_args=None, extra_args=None,
http_args=None,
response_cls=AccessTokenResponse,
authn_method="", **kwargs):
token = self.get_token(also_expired=True, state=state, **kwargs)
kwargs['authn_endpoint'] = 'refresh'
url, body, ht_args, csi = self.request_info(request, method=method,
request_args=request_args,
extra_args=extra_args,
token=token,
authn_method=authn_method)
if http_args is None:
http_args = ht_args
else:
http_args.update(ht_args)
return self.request_and_return(url, response_cls, method, body,
body_type, state=state,
http_args=http_args)
# def do_revocate_token(self, request=TokenRevocationRequest,
# scope="", state="", body_type="json", method="POST",
# request_args=None, extra_args=None, http_args=None,
# response_cls=None, authn_method=""):
#
# url, body, ht_args, csi = self.request_info(request, method=method,
# request_args=request_args,
# extra_args=extra_args,
# scope=scope, state=state,
# authn_method=authn_method)
#
# if http_args is None:
# http_args = ht_args
# else:
# http_args.update(ht_args)
#
# return self.request_and_return(url, response_cls, method, body,
# body_type, state=state,
# http_args=http_args)
def do_any(self, request, endpoint="", scope="", state="", body_type="json",
method="POST", request_args=None, extra_args=None,
http_args=None, response=None, authn_method=""):
url, body, ht_args, csi = self.request_info(request, method=method,
request_args=request_args,
extra_args=extra_args,
scope=scope, state=state,
authn_method=authn_method,
endpoint=endpoint)
if http_args is None:
http_args = ht_args
else:
http_args.update(ht_args)
return self.request_and_return(url, response, method, body, body_type,
state=state, http_args=http_args)
def fetch_protected_resource(self, uri, method="GET", headers=None,
state="", **kwargs):
if "token" in kwargs and kwargs["token"]:
token = kwargs["token"]
request_args = {"access_token": token}
else:
try:
token = self.get_token(state=state, **kwargs)
except ExpiredToken:
# The token is to old, refresh
self.do_access_token_refresh()
token = self.get_token(state=state, **kwargs)
request_args = {"access_token": token.access_token}
if headers is None:
headers = {}
if "authn_method" in kwargs:
http_args = self.init_authentication_method(
request_args=request_args, **kwargs)
else:
# If nothing defined this is the default
http_args = self.client_authn_method[
"bearer_header"](self).construct(request_args=request_args)
headers.update(http_args["headers"])
logger.debug("Fetch URI: %s" % uri)
return self.http_request(uri, method, headers=headers)
def add_code_challenge(self):
"""
PKCE RFC 7636 support
:return:
"""
try:
cv_len = self.config['code_challenge']['length']
except KeyError:
cv_len = 64 # Use default
code_verifier = unreserved(cv_len)
_cv = code_verifier.encode()
try:
_method = self.config['code_challenge']['method']
except KeyError:
_method = 'S256'
try:
_h = CC_METHOD[_method](_cv).hexdigest()
code_challenge = b64e(_h.encode()).decode()
except KeyError:
raise Unsupported(
'PKCE Transformation method:{}'.format(_method))
# TODO store code_verifier
return {"code_challenge": code_challenge,
"code_challenge_method": _method}, code_verifier
def handle_provider_config(self, pcr, issuer, keys=True, endpoints=True):
"""
Deal with Provider Config Response
:param pcr: The ProviderConfigResponse instance
:param issuer: The one I thought should be the issuer of the config
:param keys: Should I deal with keys
:param endpoints: Should I deal with endpoints, that is store them
as attributes in self.
"""
if "issuer" in pcr:
_pcr_issuer = pcr["issuer"]
if pcr["issuer"].endswith("/"):
if issuer.endswith("/"):
_issuer = issuer
else:
_issuer = issuer + "/"
else:
if issuer.endswith("/"):
_issuer = issuer[:-1]
else:
_issuer = issuer
try:
self.allow["issuer_mismatch"]
except KeyError:
try:
assert _issuer == _pcr_issuer
except AssertionError:
raise PyoidcError(
"provider info issuer mismatch '%s' != '%s'" % (
_issuer, _pcr_issuer))
self.provider_info = pcr
else:
_pcr_issuer = issuer
self.issuer = _pcr_issuer
if endpoints:
for key, val in pcr.items():
if key.endswith("_endpoint"):
setattr(self, key, val)
if keys:
if self.keyjar is None:
self.keyjar = KeyJar()
self.keyjar.load_keys(pcr, _pcr_issuer)
def provider_config(self, issuer, keys=True, endpoints=True,
response_cls=ASConfigurationResponse,
serv_pattern=OIDCONF_PATTERN):
if issuer.endswith("/"):
_issuer = issuer[:-1]
else:
_issuer = issuer
url = serv_pattern % _issuer
pcr = None
r = self.http_request(url)
if r.status_code == 200:
pcr = response_cls().from_json(r.text)
elif r.status_code == 302:
while r.status_code == 302:
r = self.http_request(r.headers["location"])
if r.status_code == 200:
pcr = response_cls().from_json(r.text)
break
if pcr is None:
raise PyoidcError("Trying '%s', status %s" % (url, r.status_code))
self.handle_provider_config(pcr, issuer, keys, endpoints)
return pcr
"-zuZqds6_NVlk2Ge4_IAA3TZ9tvIfM5FZVTOQsExu3_LX8FGCspWC1R"
"-zDqT45Y9bpaCwxekluO7Q",
"kid":
"sign1",
},
{
"k":
b"YTEyZjBlMDgxMGI4YWU4Y2JjZDFiYTFlZTBjYzljNDU3YWM0ZWNiNzhmNmFlYTNkNTY0NzMzYjE",
"kty": "oct",
"use": "sig",
},
]
}
kb = KeyBundle(JWKS["keys"])
KEYJAR = KeyJar()
KEYJAR.issuer_keys[""] = [kb]
class TestTokenHandler(object):
@pytest.fixture(autouse=True)
def create_handler(self):
self.th = TokenHandler(
"https://example.com/as",
{
"access_token": {
"https://example.org/rp": {
"client_credentials": 1200
}
},
"refresh_token": {
class Client(oauth2.Client):
def __init__(self,
client_id=None,
client_authn_method=None,
keyjar=None,
verify_ssl=True,
config=None):
oauth2.Client.__init__(self,
client_id=client_id,
client_authn_method=client_authn_method,
keyjar=keyjar,
verify_ssl=verify_ssl,
config=config)
self.allow = {}
self.request2endpoint.update({
"RegistrationRequest":
"registration_endpoint",
"ClientUpdateRequest":
"clientinfo_endpoint",
'TokenIntrospectionRequest':
'introspection_endpoint',
'TokenRevocationRequest':
'revocation_endpoint'
})
self.registration_response = None
def construct_RegistrationRequest(self,
request=RegistrationRequest,
request_args=None,
extra_args=None,
**kwargs):
if request_args is None:
request_args = {}
return self.construct_request(request, request_args, extra_args)
def construct_ClientUpdateRequest(self,
request=ClientUpdateRequest,
request_args=None,
extra_args=None,
**kwargs):
if request_args is None:
request_args = {}
return self.construct_request(request, request_args, extra_args)
def _token_interaction_setup(self, request_args=None, **kwargs):
if request_args is None or 'token' not in request_args:
token = self.get_token(**kwargs)
try:
_token_type_hint = kwargs['token_type_hint']
except KeyError:
_token_type_hint = 'access_token'
request_args = {
'token_type_hint': _token_type_hint,
'token': getattr(token, _token_type_hint)
}
if "client_id" not in request_args:
request_args["client_id"] = self.client_id
elif not request_args["client_id"]:
request_args["client_id"] = self.client_id
return request_args
def construct_TokenIntrospectionRequest(self,
request=TokenIntrospectionRequest,
request_args=None,
extra_args=None,
**kwargs):
request_args = self._token_interaction_setup(request_args, **kwargs)
return self.construct_request(request, request_args, extra_args)
def construct_TokenRevocationRequest(self,
request=TokenRevocationRequest,
request_args=None,
extra_args=None,
**kwargs):
request_args = self._token_interaction_setup(request_args, **kwargs)
return self.construct_request(request, request_args, extra_args)
def do_op(self,
request,
body_type='',
method='GET',
request_args=None,
extra_args=None,
http_args=None,
response_cls=None,
**kwargs):
url, body, ht_args, csi = self.request_info(request, method,
request_args, extra_args,
**kwargs)
if http_args is None:
http_args = ht_args
else:
http_args.update(http_args)
resp = self.request_and_return(url,
response_cls,
method,
body,
body_type,
http_args=http_args)
return resp
def do_client_registration(self,
request=RegistrationRequest,
body_type="",
method="GET",
request_args=None,
extra_args=None,
http_args=None,
response_cls=ClientInfoResponse,
**kwargs):
return self.do_op(request=request,
body_type=body_type,
method=method,
request_args=request_args,
extra_args=extra_args,
http_args=http_args,
response_cls=response_cls,
**kwargs)
def do_client_read_request(self,
request=ClientUpdateRequest,
body_type="",
method="GET",
request_args=None,
extra_args=None,
http_args=None,
response_cls=ClientInfoResponse,
**kwargs):
return self.do_op(request=request,
body_type=body_type,
method=method,
request_args=request_args,
extra_args=extra_args,
http_args=http_args,
response_cls=response_cls,
**kwargs)
def do_client_update_request(self,
request=ClientUpdateRequest,
body_type="",
method="PUT",
request_args=None,
extra_args=None,
http_args=None,
response_cls=ClientInfoResponse,
**kwargs):
return self.do_op(request=request,
body_type=body_type,
method=method,
request_args=request_args,
extra_args=extra_args,
http_args=http_args,
response_cls=response_cls,
**kwargs)
def do_client_delete_request(self,
request=ClientUpdateRequest,
body_type="",
method="DELETE",
request_args=None,
extra_args=None,
http_args=None,
response_cls=ClientInfoResponse,
**kwargs):
return self.do_op(request=request,
body_type=body_type,
method=method,
request_args=request_args,
extra_args=extra_args,
http_args=http_args,
response_cls=response_cls,
**kwargs)
def do_token_introspection(self,
request=TokenIntrospectionRequest,
body_type="json",
method="POST",
request_args=None,
extra_args=None,
http_args=None,
response_cls=TokenIntrospectionResponse,
**kwargs):
return self.do_op(request=request,
body_type=body_type,
method=method,
request_args=request_args,
extra_args=extra_args,
http_args=http_args,
response_cls=response_cls,
**kwargs)
def do_token_revocation(self,
request=TokenRevocationRequest,
body_type="",
method="POST",
request_args=None,
extra_args=None,
http_args=None,
response_cls=None,
**kwargs):
return self.do_op(request=request,
body_type=body_type,
method=method,
request_args=request_args,
extra_args=extra_args,
http_args=http_args,
response_cls=response_cls,
**kwargs)
def add_code_challenge(self):
try:
cv_len = self.config['code_challenge']['length']
except KeyError:
cv_len = 64 # Use default
code_verifier = unreserved(cv_len)
_cv = code_verifier.encode()
try:
_method = self.config['code_challenge']['method']
except KeyError:
_method = 'S256'
try:
_h = CC_METHOD[_method](_cv).hexdigest()
code_challenge = b64e(_h.encode()).decode()
except KeyError:
raise Unsupported('PKCE Transformation method:{}'.format(_method))
# TODO store code_verifier
return {
"code_challenge": code_challenge,
"code_challenge_method": _method
}, code_verifier
def do_authorization_request(self,
request=AuthorizationRequest,
state="",
body_type="",
method="GET",
request_args=None,
extra_args=None,
http_args=None,
response_cls=AuthorizationResponse,
**kwargs):
if 'code_challenge' in self.config and self.config['code_challenge']:
_args, code_verifier = self.add_code_challenge()
request_args.update(_args)
oauth2.Client.do_authorization_request(self,
request=request,
state=state,
body_type=body_type,
method=method,
request_args=request_args,
extra_args=extra_args,
http_args=http_args,
response_cls=response_cls,
**kwargs)
def handle_provider_config(self, pcr, issuer, keys=True, endpoints=True):
"""
Deal with Provider Config Response
:param pcr: The ProviderConfigResponse instance
:param issuer: The one I thought should be the issuer of the config
:param keys: Should I deal with keys
:param endpoints: Should I deal with endpoints, that is store them
as attributes in self.
"""
if "issuer" in pcr:
_pcr_issuer = pcr["issuer"]
if pcr["issuer"].endswith("/"):
if issuer.endswith("/"):
_issuer = issuer
else:
_issuer = issuer + "/"
else:
if issuer.endswith("/"):
_issuer = issuer[:-1]
else:
_issuer = issuer
if not self.allow.get("issuer_mismatch",
False) and _issuer != _pcr_issuer:
raise PyoidcError(
"provider info issuer mismatch '%s' != '%s'" %
(_issuer, _pcr_issuer))
self.provider_info = pcr
else:
_pcr_issuer = issuer
if endpoints:
for key, val in pcr.items():
if key.endswith("_endpoint"):
setattr(self, key, val)
if keys:
if self.keyjar is None:
self.keyjar = KeyJar()
self.keyjar.load_keys(pcr, _pcr_issuer)
def provider_config(self,
issuer,
keys=True,
endpoints=True,
response_cls=ASConfigurationResponse,
serv_pattern=OIDCONF_PATTERN):
if issuer.endswith("/"):
_issuer = issuer[:-1]
else:
_issuer = issuer
url = serv_pattern % _issuer
pcr = None
r = self.http_request(url)
if self.events:
self.events.store('HTTP response header', r.headers)
if r.status_code == 200:
pcr = response_cls().from_json(r.text)
elif r.status_code == 302:
while r.status_code == 302:
r = self.http_request(r.headers["location"])
if r.status_code == 200:
pcr = response_cls().from_json(r.text)
break
if pcr is None:
raise PyoidcError("Trying '%s', status %s" % (url, r.status_code))
self.handle_provider_config(pcr, issuer, keys, endpoints)
return pcr
def store_registration_info(self, reginfo):
self.registration_response = reginfo
self.client_secret = reginfo["client_secret"]
self.client_id = reginfo["client_id"]
self.redirect_uris = reginfo["redirect_uris"]
def handle_registration_info(self, response):
if response.status_code in SUCCESSFUL:
resp = ClientInfoResponse().deserialize(response.text, "json")
self.store_response(resp, response.text)
self.store_registration_info(resp)
else:
resp = ErrorResponse().deserialize(response.text, "json")
try:
resp.verify()
self.store_response(resp, response.text)
except Exception:
raise PyoidcError('Registration failed: {}'.format(
response.text))
return resp
def register(self, url, **kwargs):
"""
Register the client at an OP
:param url: The OPs registration endpoint
:param kwargs: parameters to the registration request
:return:
"""
req = self.construct_RegistrationRequest(request_args=kwargs)
headers = {"content-type": "application/json"}
rsp = self.http_request(url,
"POST",
data=req.to_json(),
headers=headers)
return self.handle_registration_info(rsp)
def parse_authz_response(self, query):
aresp = self.parse_response(AuthorizationResponse,
info=query,
sformat="urlencoded",
keyjar=self.keyjar)
if aresp.type() == "ErrorResponse":
logger.info("ErrorResponse: %s" % sanitize(aresp))
raise AuthzError(aresp.error)
logger.info("Aresp: %s" % sanitize(aresp))
return aresp
print('Registration Request published by RP')
print(70 * "-")
print_lines(
json.dumps(rere.to_dict(),
sort_keys=True,
indent=2,
separators=(',', ': ')))
# ### ======================================================================
# # On the OP
# ### ======================================================================
print('The OP chooses which federation it will work under - SWAMID of course')
op_keyjar = KeyJar()
op_keyjar.add_kb(swamid_issuer, KeyBundle(swamid_jwks['keys']))
# -----------------------------------------------------------------------------
# Unpacking the russian doll (= the software_statement)
# -----------------------------------------------------------------------------
msgs = []
# Only one software statement
_rp_jwt = factory(rp_swamid_sost)
_rp_sost = json.loads(_rp_jwt.jwt.part[1].decode('utf8'))
# Only one Software Statement within the signed
sost = _rp_sost['software_statements'][0]
def __init__(self,
base,
sdb,
cdb,
authn_broker,
userinfo,
authz,
client_authn,
symkey,
urlmap=None,
keyjar=None,
hostname="",
configuration=None,
ca_certs="",
template_lookup=None,
verify_login_template=None,
base_url=""):
UmaAS.__init__(self, configuration, baseurl=base_url)
self.sdb = sdb
if keyjar:
self.keyjar = keyjar
else:
self.keyjar = KeyJar()
self.cookie_name = self.__class__.__name__
self.hostname = hostname or socket.gethostname
self.jwks_uri = []
self.endp = UmaAS.endp[:]
self.srv = {
"oidc":
OIDCProvider(base, sdb, cdb, authn_broker, userinfo, authz,
client_authn, symkey, urlmap, ca_certs, keyjar,
hostname, template_lookup, verify_login_template),
"dyn_reg":
dynreg.Provider(base,
sdb,
cdb,
authn_broker,
authz,
client_authn,
symkey,
urlmap,
client_authn_methods=CLIENT_AUTHN_METHOD),
"oauth":
OAUTH2Provider(base,
sdb,
cdb,
authn_broker,
authz,
client_authn,
symkey,
urlmap,
ca_bundle=ca_certs,
client_authn_methods=CLIENT_AUTHN_METHOD)
}
self.endp.extend(self.srv["oidc"].endp)
self.endp = list(set(self.endp))
self.srv["oidc"].jwks_uri = self.jwks_uri
self.srv["oidc"].baseurl = base
self.request2endpoint = dict([
(e.__class__.__name__, "%s_endpoint" % e.etype) for e in self.endp
])
self.kid = {"sig": {}, "enc": {}}
def test_import_jwks():
kj = KeyJar()
kj.import_jwks(JWK1, '')
assert len(kj.get_issuer_keys('')) == 2
def run_key_server(server_url, host, script_path="", wdir=""):
kj = KeyJar()
_ = key_export(server_url % host, keyjar=kj, **KEY_EXPORT_ARGS)
return start_key_server(server_url % host, wdir, script_path)
from oic.utils.keyio import KeyJar
from oic.utils.keyio import keybundle_from_local_file
from oic.utils.sdb import SessionDB
from oic.utils.time_util import utc_time_sans_frac
__author__ = 'rohe0002'
KC_SYM_VS = KeyBundle({"kty": "oct", "key": "abcdefghijklmnop", "use": "ver"})
KC_SYM_S = KeyBundle({"kty": "oct", "key": "abcdefghijklmnop", "use": "sig"})
BASE_PATH = os.path.abspath(
os.path.join(os.path.dirname(__file__), "data/keys"))
KC_RSA = keybundle_from_local_file(os.path.join(BASE_PATH, "rsa.key"), "rsa",
["ver", "sig"])
SRVKEYS = KeyJar()
SRVKEYS[""] = [KC_RSA]
SRVKEYS["client_1"] = [KC_SYM_VS, KC_RSA]
CLIKEYS = KeyJar()
CLIKEYS["http://localhost:8088"] = [KC_RSA]
CLIKEYS[""] = [KC_RSA, KC_SYM_VS]
CLIKEYS["http://example.com"] = [KC_RSA]
SERVER_INFO = {
"version": "3.0",
"issuer": "https://localhost:8088",
"authorization_endpoint": "http://localhost:8088/authorization",
"token_endpoint": "http://localhost:8088/token",
"userinfo_endpoint": "http://localhost:8088/userinfo",
"flows_supported": ["code", "token"],
import json import requests from jwkest import as_unicode from jwkest.jws import JWS from oic.utils.keyio import KeyJar url = 'https://localhost:8080/bundle' r = requests.get(url, verify = False) assert r.status_code == 200 _bundle = r.text url = 'https://localhost:8080/bundle/sigkey' r = requests.get(url, verify = False) assert r.status_code == 200 _sigkey_jwks = json.loads(as_unicode(r.text)) kj = KeyJar() kj.import_jwks(_sigkey_jwks, '') _ver_bundle = JWS().verify_compact(_bundle, kj.get_verify_key()) print(_ver_bundle)
def test_load_jwks_wrong_argtype():
kj = KeyJar()
with pytest.raises(JWKSError):
kj.import_jwks(JWKS_ERR_1, "")
__author__ = "rohe0002"
KC_SYM_S = KeyBundle(
{
"kty": "oct",
"key": "abcdefghijklmnop".encode("utf-8"),
"use": "sig",
"alg": "HS256",
}
)
BASE_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "data/keys"))
RSA_KEY = rsa_load(os.path.join(BASE_PATH, "rsa.key"))
KC_RSA = KeyBundle({"key": RSA_KEY, "kty": "RSA", "use": "sig"})
KEYJ = KeyJar()
KEYJ[""] = [KC_RSA, KC_SYM_S]
KEYJ["client_1"] = [KC_RSA, KC_SYM_S]
CLIENT_ID = "client_1"
IDTOKEN = IdToken(
iss="http://oic.example.org/",
sub="sub",
aud=CLIENT_ID,
exp=utc_time_sans_frac() + 86400,
nonce="N0nce",
iat=time.time(),
)
def _eq(l1, l2):
class Client(PBase):
_endpoints = ENDPOINTS
def __init__(
self,
client_id=None,
client_authn_method=None,
keyjar=None,
verify_ssl=True,
config=None,
client_cert=None,
timeout=5,
message_factory: Type[MessageFactory] = OauthMessageFactory,
):
"""
Initialize the instance.
:param client_id: The client identifier
:param client_authn_method: Methods that this client can use to
authenticate itself. It's a dictionary with method names as
keys and method classes as values.
:param keyjar: The keyjar for this client.
:param verify_ssl: Whether the SSL certificate should be verified.
:param client_cert: A client certificate to use.
:param timeout: Timeout for requests library. Can be specified either as
a single integer or as a tuple of integers. For more details, refer to
``requests`` documentation.
:param: message_factory: Factory for message classes, should inherit from OauthMessageFactory
:return: Client instance
"""
PBase.__init__(
self,
verify_ssl=verify_ssl,
keyjar=keyjar,
client_cert=client_cert,
timeout=timeout,
)
self.client_id = client_id
self.client_authn_method = client_authn_method
self.nonce = None
self.message_factory = message_factory
self.grant = {} # type: Dict[str, Grant]
self.state2nonce = {} # type: Dict[str, str]
# own endpoint
self.redirect_uris = [] # type: List[str]
# service endpoints
self.authorization_endpoint = None # type: Optional[str]
self.token_endpoint = None # type: Optional[str]
self.token_revocation_endpoint = None # type: Optional[str]
self.request2endpoint = REQUEST2ENDPOINT
self.response2error = RESPONSE2ERROR # type: Dict[str, List]
self.grant_class = Grant
self.token_class = Token
self.provider_info = ASConfigurationResponse() # type: Message
self._c_secret = "" # type: str
self.kid = {"sig": {}, "enc": {}} # type: Dict[str, Dict]
self.authz_req = {} # type: Dict[str, Message]
# the OAuth issuer is the URL of the authorization server's
# configuration information location
self.config = config or {}
try:
self.issuer = self.config["issuer"]
except KeyError:
self.issuer = ""
self.allow = {} # type: Dict[str, Any]
def store_response(self, clinst, text):
pass
def get_client_secret(self) -> str:
return self._c_secret
def set_client_secret(self, val: str):
if not val:
self._c_secret = ""
else:
self._c_secret = val
# client uses it for signing
# Server might also use it for signing which means the
# client uses it for verifying server signatures
if self.keyjar is None:
self.keyjar = KeyJar()
self.keyjar.add_symmetric("", str(val))
client_secret = property(get_client_secret, set_client_secret)
def reset(self) -> None:
self.nonce = None
self.grant = {}
self.authorization_endpoint = None
self.token_endpoint = None
self.redirect_uris = []
def grant_from_state(self, state: str) -> Optional[Grant]:
for key, grant in self.grant.items():
if key == state:
return grant
return None
def _parse_args(self, request: Type[Message], **kwargs) -> Dict:
ar_args = kwargs.copy()
for prop in request.c_param.keys():
if prop in ar_args:
continue
else:
if prop == "redirect_uri":
_val = getattr(self, "redirect_uris", [None])[0]
if _val:
ar_args[prop] = _val
else:
_val = getattr(self, prop, None)
if _val:
ar_args[prop] = _val
return ar_args
def _endpoint(self, endpoint: str, **kwargs) -> str:
try:
uri = kwargs[endpoint]
if uri:
del kwargs[endpoint]
except KeyError:
uri = ""
if not uri:
try:
uri = getattr(self, endpoint)
except Exception:
raise MissingEndpoint("No '%s' specified" % endpoint)
if not uri:
raise MissingEndpoint("No '%s' specified" % endpoint)
return uri
def get_grant(self, state: str, **kwargs) -> Grant:
try:
return self.grant[state]
except KeyError:
raise GrantError("No grant found for state:'%s'" % state)
def get_token(self, also_expired: bool = False, **kwargs) -> Token:
try:
return kwargs["token"]
except KeyError:
grant = self.get_grant(**kwargs)
try:
token = grant.get_token(kwargs["scope"])
except KeyError:
token = grant.get_token("")
if not token:
try:
token = self.grant[kwargs["state"]].get_token("")
except KeyError:
raise TokenError("No token found for scope")
if token is None:
raise TokenError("No suitable token found")
if also_expired:
return token
elif token.is_valid():
return token
else:
raise TokenError("Token has expired")
def clean_tokens(self) -> None:
"""Clean replaced and invalid tokens."""
for state in self.grant:
grant = self.get_grant(state)
for token in grant.tokens:
if token.replaced or not token.is_valid():
grant.delete_token(token)
def construct_request(self,
request: Type[Message],
request_args=None,
extra_args=None):
if request_args is None:
request_args = {}
kwargs = self._parse_args(request, **request_args)
if extra_args:
kwargs.update(extra_args)
logger.debug("request: %s" % sanitize(request))
return request(**kwargs)
def construct_Message(self,
request: Type[Message] = Message,
request_args=None,
extra_args=None,
**kwargs) -> Message:
return self.construct_request(request, request_args, extra_args)
def construct_AuthorizationRequest(
self,
request: Type[AuthorizationRequest] = None,
request_args=None,
extra_args=None,
**kwargs) -> AuthorizationRequest:
if request is None:
request = self.message_factory.get_request_type(
"authorization_endpoint")
if request_args is not None:
try: # change default
new = request_args["redirect_uri"]
if new:
self.redirect_uris = [new]
except KeyError:
pass
else:
request_args = {}
if "client_id" not in request_args:
request_args["client_id"] = self.client_id
elif not request_args["client_id"]:
request_args["client_id"] = self.client_id
return self.construct_request(request, request_args, extra_args)
def construct_AccessTokenRequest(self,
request: Type[AccessTokenRequest] = None,
request_args=None,
extra_args=None,
**kwargs) -> AccessTokenRequest:
if request is None:
request = self.message_factory.get_request_type("token_endpoint")
if request_args is None:
request_args = {}
if request is not ROPCAccessTokenRequest:
grant = self.get_grant(**kwargs)
if not grant.is_valid():
raise GrantExpired(
"Authorization Code to old %s > %s" %
(utc_time_sans_frac(), grant.grant_expiration_time))
request_args["code"] = grant.code
try:
request_args["state"] = kwargs["state"]
except KeyError:
pass
if "grant_type" not in request_args:
request_args["grant_type"] = "authorization_code"
if "client_id" not in request_args:
request_args["client_id"] = self.client_id
elif not request_args["client_id"]:
request_args["client_id"] = self.client_id
return self.construct_request(request, request_args, extra_args)
def construct_RefreshAccessTokenRequest(
self,
request: Type[RefreshAccessTokenRequest] = None,
request_args=None,
extra_args=None,
**kwargs) -> RefreshAccessTokenRequest:
if request is None:
request = self.message_factory.get_request_type("refresh_endpoint")
if request_args is None:
request_args = {}
token = self.get_token(also_expired=True, **kwargs)
request_args["refresh_token"] = token.refresh_token
try:
request_args["scope"] = token.scope
except AttributeError:
pass
return self.construct_request(request, request_args, extra_args)
def construct_ResourceRequest(self,
request: Type[ResourceRequest] = None,
request_args=None,
extra_args=None,
**kwargs) -> ResourceRequest:
if request is None:
request = self.message_factory.get_request_type(
"resource_endpoint")
if request_args is None:
request_args = {}
token = self.get_token(**kwargs)
request_args["access_token"] = token.access_token
return self.construct_request(request, request_args, extra_args)
def uri_and_body(self,
reqmsg: Type[Message],
cis: Message,
method="POST",
request_args=None,
**kwargs) -> Tuple[str, str, Dict, Message]:
if "endpoint" in kwargs and kwargs["endpoint"]:
uri = kwargs["endpoint"]
else:
uri = self._endpoint(self.request2endpoint[reqmsg.__name__],
**request_args)
uri, body, kwargs = get_or_post(uri, method, cis, **kwargs)
try:
h_args = {"headers": kwargs["headers"]}
except KeyError:
h_args = {}
return uri, body, h_args, cis
def request_info(self,
request: Type[Message],
method="POST",
request_args=None,
extra_args=None,
lax=False,
**kwargs) -> Tuple[str, str, Dict, Message]:
if request_args is None:
request_args = {}
try:
cls = getattr(self, "construct_%s" % request.__name__)
cis = cls(request_args=request_args,
extra_args=extra_args,
**kwargs)
except AttributeError:
cis = self.construct_request(request, request_args, extra_args)
if self.events:
self.events.store("Protocol request", cis)
if "nonce" in cis and "state" in cis:
self.state2nonce[cis["state"]] = cis["nonce"]
cis.lax = lax
if "authn_method" in kwargs:
h_arg = self.init_authentication_method(cis,
request_args=request_args,
**kwargs)
else:
h_arg = None
if h_arg:
if "headers" in kwargs.keys():
kwargs["headers"].update(h_arg["headers"])
else:
kwargs["headers"] = h_arg["headers"]
return self.uri_and_body(request, cis, method, request_args, **kwargs)
def authorization_request_info(self,
request_args=None,
extra_args=None,
**kwargs):
return self.request_info(
self.message_factory.get_request_type("authorization_endpoint"),
"GET", request_args, extra_args, **kwargs)
@staticmethod
def get_urlinfo(info: str) -> str:
if "?" in info or "#" in info:
parts = urlparse(info)
scheme, netloc, path, params, query, fragment = parts[:6]
# either query of fragment
if query:
info = query
else:
info = fragment
return info
def parse_response(self,
response: Type[Message],
info: str = "",
sformat: ENCODINGS = "json",
state: str = "",
**kwargs) -> Message:
"""
Parse a response.
:param response: Response type
:param info: The response, can be either in a JSON or an urlencoded
format
:param sformat: Which serialization that was used
:param state: The state
:param kwargs: Extra key word arguments
:return: The parsed and to some extend verified response
"""
_r2e = self.response2error
if sformat == "urlencoded":
info = self.get_urlinfo(info)
resp = response().deserialize(info, sformat, **kwargs)
msg = 'Initial response parsing => "{}"'
logger.debug(msg.format(sanitize(resp.to_dict())))
if self.events:
self.events.store("Response", resp.to_dict())
if "error" in resp and not isinstance(resp, ErrorResponse):
resp = None
errmsgs = [] # type: List[Any]
try:
errmsgs = _r2e[response.__name__]
except KeyError:
errmsgs = [ErrorResponse]
try:
for errmsg in errmsgs:
try:
resp = errmsg().deserialize(info, sformat)
resp.verify()
break
except Exception:
resp = None
except KeyError:
pass
elif resp.only_extras():
resp = None
else:
kwargs["client_id"] = self.client_id
try:
kwargs["iss"] = self.provider_info["issuer"]
except (KeyError, AttributeError):
if self.issuer:
kwargs["iss"] = self.issuer
if "key" not in kwargs and "keyjar" not in kwargs:
kwargs["keyjar"] = self.keyjar
logger.debug("Verify response with {}".format(sanitize(kwargs)))
verf = resp.verify(**kwargs)
if not verf:
logger.error("Verification of the response failed")
raise PyoidcError("Verification of the response failed")
if resp.type() == "AuthorizationResponse" and "scope" not in resp:
try:
resp["scope"] = kwargs["scope"]
except KeyError:
pass
if not resp:
logger.error("Missing or faulty response")
raise ResponseError("Missing or faulty response")
self.store_response(resp, info)
if isinstance(resp, (AuthorizationResponse, AccessTokenResponse)):
try:
_state = resp["state"]
except (AttributeError, KeyError):
_state = ""
if not _state:
_state = state
try:
self.grant[_state].update(resp)
except KeyError:
self.grant[_state] = self.grant_class(resp=resp)
return resp
def init_authentication_method(self,
cis,
authn_method,
request_args=None,
http_args=None,
**kwargs):
if http_args is None:
http_args = {}
if request_args is None:
request_args = {}
if authn_method:
return self.client_authn_method[authn_method](self).construct(
cis, request_args, http_args, **kwargs)
else:
return http_args
def parse_request_response(self,
reqresp,
response,
body_type,
state="",
**kwargs):
if reqresp.status_code in SUCCESSFUL:
body_type = verify_header(reqresp, body_type)
elif reqresp.status_code in [302, 303]: # redirect
return reqresp
elif reqresp.status_code == 500:
logger.error("(%d) %s" %
(reqresp.status_code, sanitize(reqresp.text)))
raise ParseError("ERROR: Something went wrong: %s" % reqresp.text)
elif reqresp.status_code in [400, 401]:
# expecting an error response
if issubclass(response, ErrorResponse):
pass
else:
logger.error("(%d) %s" %
(reqresp.status_code, sanitize(reqresp.text)))
raise HttpError("HTTP ERROR: %s [%s] on %s" %
(reqresp.text, reqresp.status_code, reqresp.url))
if response:
if body_type == "txt":
# no meaning trying to parse unstructured text
return reqresp.text
return self.parse_response(response, reqresp.text, body_type,
state, **kwargs)
# could be an error response
if reqresp.status_code in [200, 400, 401]:
if body_type == "txt":
body_type = "urlencoded"
try:
err = ErrorResponse().deserialize(reqresp.message,
method=body_type)
try:
err.verify()
except PyoidcError:
pass
else:
return err
except Exception:
pass
return reqresp
def request_and_return(self,
url: str,
response: Type[Message] = None,
method="GET",
body=None,
body_type: ENCODINGS = "json",
state: str = "",
http_args=None,
**kwargs):
"""
Perform a request and return the response.
:param url: The URL to which the request should be sent
:param response: Response type
:param method: Which HTTP method to use
:param body: A message body if any
:param body_type: The format of the body of the return message
:param http_args: Arguments for the HTTP client
:return: A cls or ErrorResponse instance or the HTTP response instance if no response body was expected.
"""
# FIXME: Cannot annotate return value as Message since it disrupts all other methods
if http_args is None:
http_args = {}
try:
resp = self.http_request(url, method, data=body, **http_args)
except Exception:
raise
if "keyjar" not in kwargs:
kwargs["keyjar"] = self.keyjar
return self.parse_request_response(resp, response, body_type, state,
**kwargs)
def do_authorization_request(self,
state="",
body_type="",
method="GET",
request_args=None,
extra_args=None,
http_args=None,
**kwargs) -> AuthorizationResponse:
request = self.message_factory.get_request_type(
"authorization_endpoint")
response_cls = self.message_factory.get_response_type(
"authorization_endpoint")
if state:
try:
request_args["state"] = state
except TypeError:
request_args = {"state": state}
kwargs["authn_endpoint"] = "authorization"
url, body, ht_args, csi = self.request_info(request, method,
request_args, extra_args,
**kwargs)
try:
self.authz_req[request_args["state"]] = csi
except TypeError:
pass
if http_args is None:
http_args = ht_args
else:
http_args.update(ht_args)
try:
algs = kwargs["algs"]
except KeyError:
algs = {}
resp = self.request_and_return(
url,
response_cls,
method,
body,
body_type,
state=state,
http_args=http_args,
algs=algs,
)
if isinstance(resp, Message):
# FIXME: The Message classes do not have classical attrs
if resp.type(
) in RESPONSE2ERROR["AuthorizationResponse"]: # type: ignore
resp.state = csi.state # type: ignore
return resp
def do_access_token_request(self,
scope: str = "",
state: str = "",
body_type: ENCODINGS = "json",
method="POST",
request_args=None,
extra_args=None,
http_args=None,
authn_method="",
**kwargs) -> AccessTokenResponse:
request = self.message_factory.get_request_type("token_endpoint")
response_cls = self.message_factory.get_response_type("token_endpoint")
kwargs["authn_endpoint"] = "token"
# method is default POST
url, body, ht_args, csi = self.request_info(request,
method=method,
request_args=request_args,
extra_args=extra_args,
scope=scope,
state=state,
authn_method=authn_method,
**kwargs)
if http_args is None:
http_args = ht_args
else:
http_args.update(ht_args)
if self.events is not None:
self.events.store("request_url", url)
self.events.store("request_http_args", http_args)
self.events.store("Request", body)
logger.debug("<do_access_token> URL: %s, Body: %s" %
(url, sanitize(body)))
logger.debug("<do_access_token> response_cls: %s" % response_cls)
return self.request_and_return(url,
response_cls,
method,
body,
body_type,
state=state,
http_args=http_args,
**kwargs)
def do_access_token_refresh(self,
state: str = "",
body_type: ENCODINGS = "json",
method="POST",
request_args=None,
extra_args=None,
http_args=None,
authn_method="",
**kwargs) -> AccessTokenResponse:
request = self.message_factory.get_request_type("refresh_endpoint")
response_cls = self.message_factory.get_response_type(
"refresh_endpoint")
token = self.get_token(also_expired=True, state=state, **kwargs)
kwargs["authn_endpoint"] = "refresh"
url, body, ht_args, csi = self.request_info(
request,
method=method,
request_args=request_args,
extra_args=extra_args,
token=token,
authn_method=authn_method,
)
if http_args is None:
http_args = ht_args
else:
http_args.update(ht_args)
response = self.request_and_return(url,
response_cls,
method,
body,
body_type,
state=state,
http_args=http_args)
if token.replaced:
grant = self.get_grant(state)
grant.delete_token(token)
return response
def do_any(
self,
request: Type[Message],
endpoint="",
scope="",
state="",
body_type="json",
method="POST",
request_args=None,
extra_args=None,
http_args=None,
response: Type[Message] = None,
authn_method="",
) -> Message:
url, body, ht_args, _ = self.request_info(
request,
method=method,
request_args=request_args,
extra_args=extra_args,
scope=scope,
state=state,
authn_method=authn_method,
endpoint=endpoint,
)
if http_args is None:
http_args = ht_args
else:
http_args.update(ht_args)
return self.request_and_return(url,
response,
method,
body,
body_type,
state=state,
http_args=http_args)
def fetch_protected_resource(self,
uri,
method="GET",
headers=None,
state="",
**kwargs):
if "token" in kwargs and kwargs["token"]:
token = kwargs["token"]
request_args = {"access_token": token}
else:
try:
token = self.get_token(state=state, **kwargs)
except ExpiredToken:
# The token is to old, refresh
self.do_access_token_refresh(state=state)
token = self.get_token(state=state, **kwargs)
request_args = {"access_token": token.access_token}
if headers is None:
headers = {}
if "authn_method" in kwargs:
http_args = self.init_authentication_method(
request_args=request_args, **kwargs)
else:
# If nothing defined this is the default
http_args = self.client_authn_method["bearer_header"](
self).construct(request_args=request_args)
headers.update(http_args["headers"])
logger.debug("Fetch URI: %s" % uri)
return self.http_request(uri, method, headers=headers)
def add_code_challenge(self):
"""
PKCE RFC 7636 support.
:return:
"""
try:
cv_len = self.config["code_challenge"]["length"]
except KeyError:
cv_len = 64 # Use default
code_verifier = unreserved(cv_len)
_cv = code_verifier.encode("ascii")
try:
_method = self.config["code_challenge"]["method"]
except KeyError:
_method = "S256"
try:
_h = CC_METHOD[_method](_cv).digest()
code_challenge = b64e(_h).decode("ascii")
except KeyError:
raise Unsupported("PKCE Transformation method:{}".format(_method))
# TODO store code_verifier
return (
{
"code_challenge": code_challenge,
"code_challenge_method": _method
},
code_verifier,
)
def handle_provider_config(
self,
pcr: ASConfigurationResponse,
issuer: str,
keys: bool = True,
endpoints: bool = True,
) -> None:
"""
Deal with Provider Config Response.
:param pcr: The ProviderConfigResponse instance
:param issuer: The one I thought should be the issuer of the config
:param keys: Should I deal with keys
:param endpoints: Should I deal with endpoints, that is store them as attributes in self.
"""
if "issuer" in pcr:
_pcr_issuer = pcr["issuer"]
if pcr["issuer"].endswith("/"):
if issuer.endswith("/"):
_issuer = issuer
else:
_issuer = issuer + "/"
else:
if issuer.endswith("/"):
_issuer = issuer[:-1]
else:
_issuer = issuer
if not self.allow.get("issuer_mismatch",
False) and _issuer != _pcr_issuer:
raise PyoidcError(
"provider info issuer mismatch '%s' != '%s'" %
(_issuer, _pcr_issuer))
self.provider_info = pcr
else:
_pcr_issuer = issuer
self.issuer = _pcr_issuer
if endpoints:
for key, val in pcr.items():
if key.endswith("_endpoint"):
setattr(self, key, val)
if keys:
if self.keyjar is None:
self.keyjar = KeyJar()
self.keyjar.load_keys(pcr, _pcr_issuer)
def provider_config(
self,
issuer: str,
keys: bool = True,
endpoints: bool = True,
serv_pattern: str = OIDCONF_PATTERN,
) -> ASConfigurationResponse:
response_cls = self.message_factory.get_response_type(
"configuration_endpoint")
if issuer.endswith("/"):
_issuer = issuer[:-1]
else:
_issuer = issuer
url = serv_pattern % _issuer
pcr = None
r = self.http_request(url, allow_redirects=True)
if r.status_code == 200:
try:
pcr = response_cls().from_json(r.text)
except Exception as e:
# FIXME: This should catch specific exception from `from_json()`
_err_txt = "Faulty provider config response: {}".format(e)
logger.error(sanitize(_err_txt))
raise ParseError(_err_txt)
else:
raise CommunicationError("Trying '%s', status %s" %
(url, r.status_code))
self.store_response(pcr, r.text)
self.handle_provider_config(pcr, issuer, keys, endpoints)
return pcr
KC_SYM2 = KeyBundle([{
"kty": "oct",
"key": "drickyoughurt",
"use": "sig"
}, {
"kty": "oct",
"key": "drickyoughurt",
"use": "ver"
}])
BASE_PATH = os.path.abspath(
os.path.join(os.path.dirname(__file__), "data/keys"))
KC_RSA = keybundle_from_local_file(os.path.join(BASE_PATH, "rsa.key"), "RSA",
["ver", "sig"])
KEYJAR = KeyJar()
KEYJAR[CLIENT_ID] = [KC_SYM, KC_RSA]
KEYJAR["number5"] = [KC_SYM2, KC_RSA]
KEYJAR[""] = KC_RSA
CDB = {
"number5": {
"password":
"******",
"client_secret":
"drickyoughurt",
"redirect_uris": [("http://localhost:8087/authz", None)],
"post_logout_redirect_uris":
[("https://example.com/post_logout", None)],
"client_salt":
"salted",
def keyjar_from_metadata_statements(iss, msl):
keyjar = KeyJar()
for ms in msl:
keyjar.import_jwks(ms['signing_keys'], iss)
return keyjar
