T13.10: DPoP for the Okta Management API calls, auto-detected (D24)
This commit is contained in:
277
tests/okta_sync_dpop_check.py
Normal file
277
tests/okta_sync_dpop_check.py
Normal file
@@ -0,0 +1,277 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Does the Okta sync use DPoP correctly? - D24 / T13.10.
|
||||
|
||||
A strict fake Okta (httpx.MockTransport) checks every DPoP proof the way RFC 9449 says a
|
||||
server must: the header (typ dpop+jwt, ES256, a PUBLIC jwk only), the signature against
|
||||
that jwk, htm, htu (no query), iat, a one-time jti, the nonce when the server asked for
|
||||
one, and on an API call the ath hash of the access token and the same key as at the token
|
||||
request. Also: auto mode finds out that DPoP is required, the nonce dance at the token
|
||||
endpoint and at the API, paging, off mode, bounded retries, and no secret in any message.
|
||||
|
||||
Self-contained: no network, no server, no browser. Exit 0 all passed, 1 a failure.
|
||||
"""
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
from urllib.parse import parse_qs
|
||||
|
||||
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
sys.path.insert(0, ROOT)
|
||||
os.environ["DATABASE_URL"] = "sqlite://"
|
||||
for v in ("OKTA_API_TOKEN", "OKTA_SYNC_PROFILE_ATTRIBUTE", "OKTA_SYNC_DPOP"):
|
||||
os.environ.pop(v, None)
|
||||
os.environ["OKTA_ORG_URL"] = "https://example.okta.com"
|
||||
|
||||
import httpx # noqa: E402
|
||||
import jwt # noqa: E402
|
||||
from cryptography.hazmat.primitives.asymmetric import rsa # noqa: E402
|
||||
|
||||
from server import okta_sync # noqa: E402
|
||||
from server.okta_sync import OktaSyncError # noqa: E402
|
||||
|
||||
fails = 0
|
||||
|
||||
|
||||
def chk(label, ok, extra=""):
|
||||
global fails
|
||||
print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else ""))
|
||||
if not ok:
|
||||
fails += 1
|
||||
|
||||
|
||||
pk = rsa.generate_private_key(public_exponent=65537, key_size=2048)
|
||||
CLIENT_JWK = json.loads(jwt.algorithms.RSAAlgorithm.to_jwk(pk))
|
||||
CLIENT_JWK.update({"kid": "k1", "alg": "RS256", "use": "sig"})
|
||||
CLIENT_PUB = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps({k: CLIENT_JWK[k] for k in ("kty", "n", "e")}))
|
||||
os.environ["OKTA_SYNC_CLIENT_ID"] = "0oaCLIENT"
|
||||
os.environ["OKTA_SYNC_PRIVATE_KEY"] = json.dumps(CLIENT_JWK)
|
||||
|
||||
TOKEN_URL = "https://example.okta.com/oauth2/v1/token"
|
||||
USERS_URL = "https://example.okta.com/api/v1/users"
|
||||
ACCESS = "ACCESS-TOKEN-VALUE-123"
|
||||
|
||||
|
||||
def thumb(jwk):
|
||||
return json.dumps({k: jwk[k] for k in ("crv", "kty", "x", "y")}, sort_keys=True, separators=(",", ":"))
|
||||
|
||||
|
||||
class StrictOkta:
|
||||
def __init__(self, require_dpop=False, token_nonce=False, api_nonce=False, always_bad_proof=False,
|
||||
token_type_if_plain="Bearer", pages=1, endless_nonce=False):
|
||||
self.endless_nonce = endless_nonce
|
||||
self.require_dpop, self.token_nonce, self.api_nonce = require_dpop, token_nonce, api_nonce
|
||||
self.always_bad_proof, self.token_type_if_plain, self.pages = always_bad_proof, token_type_if_plain, pages
|
||||
self.token_calls = 0
|
||||
self.api_calls = 0
|
||||
self.problems = [] # anything the strict checks found wrong
|
||||
self.jtis = set()
|
||||
self.assertion_jtis = set()
|
||||
self.token_key = None # thumbprint of the key used at the token request
|
||||
self.api_keys = set()
|
||||
self.dpop_on_token = 0
|
||||
self.dpop_on_api = 0
|
||||
self.issued_nonce = "nonce-" + os.urandom(3).hex()
|
||||
self.api_seen = []
|
||||
|
||||
def _check_proof(self, req, url, method, ath=None, need_nonce=False):
|
||||
proof = req.headers.get("dpop")
|
||||
if not proof:
|
||||
return None, "no proof"
|
||||
try:
|
||||
hdr = jwt.get_unverified_header(proof)
|
||||
except Exception as e: # noqa: BLE001
|
||||
return None, f"unreadable header {type(e).__name__}"
|
||||
if hdr.get("typ") != "dpop+jwt" or hdr.get("alg") != "ES256":
|
||||
self.problems.append(f"bad header typ/alg {hdr.get('typ')} {hdr.get('alg')}")
|
||||
jwk = hdr.get("jwk")
|
||||
if not isinstance(jwk, dict) or "d" in jwk or jwk.get("kty") != "EC":
|
||||
self.problems.append("proof jwk missing or holds private part")
|
||||
return None, "bad jwk"
|
||||
try:
|
||||
claims = jwt.decode(proof, jwt.algorithms.ECAlgorithm.from_jwk(json.dumps(jwk)),
|
||||
algorithms=["ES256"], options={"verify_iat": False})
|
||||
except Exception as e: # noqa: BLE001
|
||||
self.problems.append(f"signature did not verify: {type(e).__name__}")
|
||||
return None, "bad signature"
|
||||
if claims.get("htm") != method:
|
||||
self.problems.append(f"htm {claims.get('htm')} != {method}")
|
||||
if claims.get("htu") != url:
|
||||
self.problems.append(f"htu {claims.get('htu')} != {url}")
|
||||
if abs(time.time() - int(claims.get("iat", 0))) > 60:
|
||||
self.problems.append("iat not current")
|
||||
if claims.get("jti") in self.jtis or not claims.get("jti"):
|
||||
self.problems.append("jti missing or reused")
|
||||
self.jtis.add(claims.get("jti"))
|
||||
if ath is not None and claims.get("ath") != ath:
|
||||
self.problems.append("ath wrong")
|
||||
if ath is None and "ath" in claims:
|
||||
self.problems.append("ath present on a token request")
|
||||
if need_nonce and claims.get("nonce") != self.issued_nonce:
|
||||
return jwk, "nonce"
|
||||
return jwk, None
|
||||
|
||||
def handler(self, req: httpx.Request):
|
||||
if req.url.path == "/oauth2/v1/token":
|
||||
self.token_calls += 1
|
||||
form = {k: v[0] for k, v in parse_qs(req.content.decode()).items()}
|
||||
try:
|
||||
a = jwt.decode(form["client_assertion"], CLIENT_PUB, algorithms=["RS256"], audience=TOKEN_URL)
|
||||
if a["jti"] in self.assertion_jtis:
|
||||
self.problems.append("client assertion jti reused")
|
||||
self.assertion_jtis.add(a["jti"])
|
||||
except Exception as e: # noqa: BLE001
|
||||
self.problems.append(f"client assertion bad: {type(e).__name__}")
|
||||
has = "dpop" in req.headers
|
||||
if has:
|
||||
self.dpop_on_token += 1
|
||||
if self.always_bad_proof:
|
||||
return httpx.Response(400, json={"error": "invalid_dpop_proof"})
|
||||
if self.require_dpop and not has:
|
||||
return httpx.Response(400, json={"error": "invalid_dpop_proof"})
|
||||
if not has:
|
||||
return httpx.Response(200, json={"token_type": self.token_type_if_plain, "access_token": ACCESS})
|
||||
jwk, bad = self._check_proof(req, TOKEN_URL, "POST", need_nonce=self.token_nonce)
|
||||
if bad == "nonce" or (self.endless_nonce and not bad):
|
||||
return httpx.Response(400, json={"error": "use_dpop_nonce"}, headers={"DPoP-Nonce": self.issued_nonce})
|
||||
if bad:
|
||||
return httpx.Response(400, json={"error": "invalid_dpop_proof"})
|
||||
self.token_key = thumb(jwk)
|
||||
return httpx.Response(200, json={"token_type": "DPoP", "access_token": ACCESS})
|
||||
if req.url.path == "/api/v1/users":
|
||||
self.api_calls += 1
|
||||
auth = req.headers.get("authorization", "")
|
||||
self.api_seen.append(auth.split(" ")[0])
|
||||
if auth.startswith("DPoP "):
|
||||
self.dpop_on_api += 1
|
||||
if auth != f"DPoP {ACCESS}":
|
||||
self.problems.append("wrong DPoP access token")
|
||||
ath = base64.urlsafe_b64encode(hashlib.sha256(ACCESS.encode()).digest()).rstrip(b"=").decode()
|
||||
jwk, bad = self._check_proof(req, USERS_URL, "GET", ath=ath, need_nonce=self.api_nonce)
|
||||
if bad == "nonce":
|
||||
return httpx.Response(401, json={"errorCode": "invalid_token"},
|
||||
headers={"DPoP-Nonce": self.issued_nonce,
|
||||
"WWW-Authenticate": 'DPoP error="use_dpop_nonce"'})
|
||||
if bad:
|
||||
return httpx.Response(401, json={})
|
||||
self.api_keys.add(thumb(jwk))
|
||||
if thumb(jwk) != self.token_key:
|
||||
self.problems.append("API proof key differs from the token request key")
|
||||
elif auth == f"Bearer {ACCESS}":
|
||||
if "dpop" in req.headers:
|
||||
self.problems.append("DPoP header sent with a plain Bearer token")
|
||||
else:
|
||||
return httpx.Response(401, json={})
|
||||
page = int(req.url.params.get("after", "0") or 0)
|
||||
body = [{"status": "ACTIVE", "profile": {"login": f"user{page}"}}]
|
||||
headers = {}
|
||||
if page + 1 < self.pages:
|
||||
headers["Link"] = f'<{USERS_URL}?after={page + 1}&limit=200>; rel="next"'
|
||||
return httpx.Response(200, json=body, headers=headers)
|
||||
return httpx.Response(404)
|
||||
|
||||
def client(self):
|
||||
return httpx.Client(transport=httpx.MockTransport(self.handler))
|
||||
|
||||
|
||||
def run(fake, mode=None):
|
||||
if mode is None:
|
||||
os.environ.pop("OKTA_SYNC_DPOP", None)
|
||||
else:
|
||||
os.environ["OKTA_SYNC_DPOP"] = mode
|
||||
try:
|
||||
return okta_sync.fetch_users(http=fake.client()), None
|
||||
except OktaSyncError as e:
|
||||
return None, str(e)
|
||||
|
||||
|
||||
# 1. auto: a plain app needs no DPoP
|
||||
f = StrictOkta()
|
||||
users, err = run(f)
|
||||
chk("auto, app without DPoP: works with one token call, Bearer", users and f.token_calls == 1 and f.dpop_on_token == 0 and f.api_seen == ["Bearer"], str(err))
|
||||
chk("no problems found by the strict checks", not f.problems, str(f.problems))
|
||||
|
||||
# 2. auto: the app requires DPoP (what your tenant answered)
|
||||
f = StrictOkta(require_dpop=True)
|
||||
users, err = run(f)
|
||||
chk("auto, app requires DPoP: plain try, then DPoP try, then users", users and f.token_calls == 2 and f.dpop_on_token == 1, f"{err} calls={f.token_calls}")
|
||||
chk("API calls carry DPoP and the access token", f.api_calls == 1 and f.dpop_on_api == 1 and f.api_seen == ["DPoP"])
|
||||
chk("API proof used the same key as the token request", len(f.api_keys) == 1 and f.api_keys == {f.token_key})
|
||||
chk("every proof and assertion id is unique, no problems", not f.problems, str(f.problems))
|
||||
|
||||
# 3. nonce at the token endpoint
|
||||
f = StrictOkta(require_dpop=True, token_nonce=True)
|
||||
users, err = run(f)
|
||||
chk("token nonce: plain, DPoP without nonce, DPoP with nonce", users and f.token_calls == 3, f"{err} calls={f.token_calls}")
|
||||
chk("token nonce: no problems", not f.problems, str(f.problems))
|
||||
|
||||
# 4. nonce at the API
|
||||
f = StrictOkta(require_dpop=True, api_nonce=True)
|
||||
users, err = run(f)
|
||||
chk("API nonce: the call is repeated once with the nonce", users and f.api_calls == 2 and f.dpop_on_api == 2, f"{err} calls={f.api_calls}")
|
||||
chk("API nonce: no problems", not f.problems, str(f.problems))
|
||||
|
||||
# 5. paging: a new proof for every page, htu without the query
|
||||
f = StrictOkta(require_dpop=True, pages=3)
|
||||
users, err = run(f)
|
||||
chk("3 pages with DPoP: 3 users, 3 API calls", users and len(users) == 3 and f.api_calls == 3, f"{err} {f.api_calls}")
|
||||
chk("3 pages: htu had no query, jti unique, same key", not f.problems, str(f.problems))
|
||||
|
||||
# 6. mode on goes straight to DPoP
|
||||
f = StrictOkta(require_dpop=True)
|
||||
users, err = run(f, "on")
|
||||
chk("mode on: DPoP from the first token call", users and f.token_calls == 1 and f.dpop_on_token == 1, f"{err} {f.token_calls}")
|
||||
f = StrictOkta()
|
||||
users, err = run(f, "true")
|
||||
chk("mode on with an app that does not need it: still works", users is not None and not f.problems, f"{err} {f.problems}")
|
||||
|
||||
# 7. mode off
|
||||
f = StrictOkta(require_dpop=True)
|
||||
users, err = run(f, "off")
|
||||
chk("mode off, app requires DPoP: stops after one call, names the error", users is None and f.token_calls == 1 and "invalid_dpop_proof" in err, str(err))
|
||||
f = StrictOkta(token_type_if_plain="DPoP")
|
||||
users, err = run(f, "off")
|
||||
chk("mode off, DPoP-bound token: clear refusal, users never called", users is None and "DPoP-bound" in err and f.api_calls == 0, str(err))
|
||||
f = StrictOkta(token_type_if_plain="mac")
|
||||
users, err = run(f)
|
||||
chk("unknown token type refused", users is None and "neither" in err, str(err))
|
||||
|
||||
# 8. bounded retries and a hopeless server
|
||||
f = StrictOkta(always_bad_proof=True)
|
||||
users, err = run(f)
|
||||
chk("a server that always rejects the proof: bounded calls, clear error", users is None and f.token_calls <= 4 and "invalid_dpop_proof" in err and "DPoP was used" in err, f"{err} {f.token_calls}")
|
||||
chk("no users call when the token failed", f.api_calls == 0)
|
||||
|
||||
f = StrictOkta(require_dpop=True, token_nonce=True, endless_nonce=True)
|
||||
users, err = run(f)
|
||||
chk("a server that asks for a nonce forever: bounded calls, clear error", users is None and f.token_calls <= 4 and "use_dpop_nonce" in err, f"{err} {f.token_calls}")
|
||||
|
||||
# 9. a new key on each run
|
||||
f1, f2 = StrictOkta(require_dpop=True), StrictOkta(require_dpop=True)
|
||||
run(f1); run(f2)
|
||||
chk("each run makes its own DPoP key", f1.token_key and f2.token_key and f1.token_key != f2.token_key)
|
||||
|
||||
# 10. secrets and startup line
|
||||
f = StrictOkta(always_bad_proof=True)
|
||||
_, err = run(f)
|
||||
chk("error holds no token, key or assertion", ACCESS not in err and CLIENT_JWK["d"][:12] not in err)
|
||||
line = okta_sync.describe()
|
||||
chk("startup line names the DPoP mode", "DPoP auto" in line, line)
|
||||
os.environ["OKTA_SYNC_DPOP"] = "on"
|
||||
chk("startup line follows the setting", "DPoP on" in okta_sync.describe())
|
||||
os.environ.pop("OKTA_SYNC_DPOP")
|
||||
|
||||
# 11. the SSWS token path is untouched
|
||||
os.environ["OKTA_API_TOKEN"] = "ssws-value"
|
||||
f = StrictOkta()
|
||||
def ssws_handler(req):
|
||||
f.api_seen.append(req.headers.get("authorization", ""))
|
||||
return httpx.Response(200, json=[{"status": "ACTIVE", "profile": {"login": "a"}}])
|
||||
users = okta_sync.fetch_users(http=httpx.Client(transport=httpx.MockTransport(ssws_handler)))
|
||||
chk("SSWS path unchanged: SSWS header, no DPoP", f.api_seen == ["SSWS ssws-value"] and users, str(f.api_seen))
|
||||
os.environ.pop("OKTA_API_TOKEN")
|
||||
|
||||
print("\nDONE" if fails == 0 else f"\n{fails} FAILED")
|
||||
sys.exit(1 if fails else 0)
|
||||
Reference in New Issue
Block a user