#!/usr/bin/env python3 """Does the Okta sync sign in as an OAuth service app (private_key_jwt)? - D23 / T13.9. Checks, with a fake Okta (httpx.MockTransport) and freshly made keys: - the token request carries the right form fields and a JWT that VERIFIES against the public key, with iss and sub = client ID, aud = the token endpoint, kid in the header, a short lifetime, and a one-time jti - the users request then uses the Bearer token, not SSWS - every failure raises OktaSyncError and the users endpoint is never called - the key is accepted as JSON and as base64, RSA and EC; a public key is refused - an SSWS API token still works and wins when both are set - the key, the assertion and the token never appear in an error message or the startup line Self-contained: no network, no server, no browser. Exit 0 all passed, 1 a failure. """ import base64 import json import os import sys 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_CLIENT_ID", "OKTA_SYNC_PRIVATE_KEY", "OKTA_SYNC_PROFILE_ATTRIBUTE"): 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 ec, 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 def make_rsa(): pk = rsa.generate_private_key(public_exponent=65537, key_size=2048) jwk = json.loads(jwt.algorithms.RSAAlgorithm.to_jwk(pk)) jwk.update({"kid": "rsa-kid-1", "use": "sig", "alg": "RS256"}) pub = {k: jwk[k] for k in ("kty", "n", "e")} return jwk, jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(pub)), "RS256" def make_ec(): pk = ec.generate_private_key(ec.SECP256R1()) jwk = json.loads(jwt.algorithms.ECAlgorithm.to_jwk(pk)) jwk.update({"kid": "ec-kid-1", "use": "sig", "alg": "ES256"}) pub = {k: jwk[k] for k in ("kty", "crv", "x", "y")} return jwk, jwt.algorithms.ECAlgorithm.from_jwk(json.dumps(pub)), "ES256" class FakeOkta: def __init__(self, pub=None, alg="RS256", token_status=200, token_body=None, user_status=200): self.pub, self.alg = pub, alg self.token_status, self.token_body, self.user_status = token_status, token_body, user_status self.token_calls, self.user_calls, self.seen_auth, self.form, self.verified = 0, 0, [], {}, None def handler(self, req: httpx.Request): if req.url.path == "/oauth2/v1/token": self.token_calls += 1 self.form = {k: v[0] for k, v in parse_qs(req.content.decode()).items()} if self.pub is not None and "client_assertion" in self.form: try: self.verified = jwt.decode(self.form["client_assertion"], self.pub, algorithms=[self.alg], audience="https://example.okta.com/oauth2/v1/token") except Exception as e: # noqa: BLE001 self.verified = e body = self.token_body if self.token_body is not None else { "token_type": "Bearer", "access_token": "ACCESS-TOKEN-VALUE", "expires_in": 3600} return httpx.Response(self.token_status, json=body) if req.url.path == "/api/v1/users": self.user_calls += 1 self.seen_auth.append(req.headers.get("authorization", "")) return httpx.Response(self.user_status, json=[ {"status": "ACTIVE", "profile": {"login": "alice"}}]) return httpx.Response(404) def client(self): return httpx.Client(transport=httpx.MockTransport(self.handler)) def setenv(jwk=None, as_b64=False, client_id="0oaCLIENT"): os.environ["OKTA_SYNC_CLIENT_ID"] = client_id if jwk is None: os.environ.pop("OKTA_SYNC_PRIVATE_KEY", None) else: raw = json.dumps(jwk) os.environ["OKTA_SYNC_PRIVATE_KEY"] = base64.b64encode(raw.encode()).decode() if as_b64 else raw def fetch_err(fake): try: okta_sync.fetch_users(http=fake.client()) return None except OktaSyncError as e: return str(e) # 1. Happy path, RSA, JSON form rsa_jwk, rsa_pub, _ = make_rsa() setenv(rsa_jwk) chk("method is oauth", okta_sync.auth_method() == "oauth") chk("is_configured with client id and key", okta_sync.is_configured()) f = FakeOkta(rsa_pub, "RS256") users = okta_sync.fetch_users(http=f.client()) chk("returns the user", [u.identity for u in users] == ["alice"]) chk("token request fields", f.form.get("grant_type") == "client_credentials" and f.form.get("scope") == "okta.users.read" and f.form.get("client_assertion_type") == "urn:ietf:params:oauth:client-assertion-type:jwt-bearer") v = f.verified chk("assertion verifies against the public key", isinstance(v, dict), repr(v)) if isinstance(v, dict): chk("iss and sub are the client id", v.get("iss") == "0oaCLIENT" and v.get("sub") == "0oaCLIENT") chk("aud is the token endpoint", v.get("aud") == "https://example.okta.com/oauth2/v1/token") chk("lifetime is at most 5 minutes", 0 < v["exp"] - v["iat"] <= 300) chk("jti present", bool(v.get("jti"))) hdr = jwt.get_unverified_header(f.form["client_assertion"]) chk("kid and alg in the header", hdr.get("kid") == "rsa-kid-1" and hdr.get("alg") == "RS256") chk("users call uses Bearer, not SSWS", f.seen_auth == ["Bearer ACCESS-TOKEN-VALUE"], str(f.seen_auth)) f2 = FakeOkta(rsa_pub) okta_sync.fetch_users(http=f2.client()) chk("each assertion has a new jti", f.verified["jti"] != f2.verified["jti"]) # 2. base64 form and EC key setenv(rsa_jwk, as_b64=True) f = FakeOkta(rsa_pub) chk("base64 form works", [u.identity for u in okta_sync.fetch_users(http=f.client())] == ["alice"]) ec_jwk, ec_pub, _ = make_ec() setenv(ec_jwk) f = FakeOkta(ec_pub, "ES256") okta_sync.fetch_users(http=f.client()) chk("EC key works and verifies", isinstance(f.verified, dict), repr(f.verified)) # 3. Failures raise and never reach the users endpoint setenv(rsa_jwk) for label, fake in [ ("token endpoint 401", FakeOkta(token_status=401, token_body={"error": "invalid_client"})), ("token endpoint 400 invalid_scope", FakeOkta(token_status=400, token_body={"error": "invalid_scope"})), ("token endpoint 500", FakeOkta(token_status=500, token_body={})), ("no access_token in body", FakeOkta(token_body={"token_type": "Bearer"})), ("DPoP token type", FakeOkta(token_body={"token_type": "DPoP", "access_token": "x"})), ("body is not an object", FakeOkta(token_body=[1, 2])), ]: err = fetch_err(fake) chk(f"{label}: raises, users never called", err is not None and fake.user_calls == 0, str(err)) e = fetch_err(FakeOkta(token_status=401, token_body={"error": "invalid_client"})) chk("error carries the Okta error code and the status", "401" in e and "invalid_client" in e, e) e = fetch_err(FakeOkta(token_status=400, token_body={"error": ""})) chk("an unsafe error value is dropped", "script" not in e and "400" in e, e) # 4. Bad key material pub_only = {k: rsa_jwk[k] for k in ("kty", "n", "e", "kid")} for label, raw in [("public key only", json.dumps(pub_only)), ("not JSON, not base64", "{{{ not json"), ("base64 of something else", base64.b64encode(b"hello").decode()), ("wrong kty", json.dumps({"kty": "oct", "k": "AAAA"}))]: os.environ["OKTA_SYNC_PRIVATE_KEY"] = raw fake = FakeOkta() err = fetch_err(fake) chk(f"{label}: refused before any call", err is not None and fake.token_calls == 0 and fake.user_calls == 0, str(err)) if label == "public key only": chk("public key: the message says it is a PUBLIC key", err is not None and "PUBLIC" in err, str(err)) chk(f"{label}: message holds no key text", err is not None and rsa_jwk["d"][:12] not in err and "hello" not in err) setenv(rsa_jwk, client_id="") os.environ["OKTA_SYNC_CLIENT_ID"] = "" chk("no client id: not configured", okta_sync.auth_method() == "" and not okta_sync.is_configured()) os.environ["OKTA_SYNC_CLIENT_ID"] = "0oaCLIENT" os.environ.pop("OKTA_SYNC_PRIVATE_KEY") chk("no key: not configured", okta_sync.auth_method() == "") # 5. An SSWS token still works and wins setenv(rsa_jwk) os.environ["OKTA_API_TOKEN"] = "ssws-token-value" chk("method is token when both are set", okta_sync.auth_method() == "token") f = FakeOkta() okta_sync.fetch_users(http=f.client()) chk("SSWS used, no token request made", f.seen_auth == ["SSWS ssws-token-value"] and f.token_calls == 0, str(f.seen_auth)) os.environ.pop("OKTA_API_TOKEN") # 6. Secrets stay out of the startup line setenv(rsa_jwk) line = okta_sync.describe() chk("startup line names the method", "OAuth service app" in line, line) chk("startup line holds no key part", rsa_jwk["d"][:12] not in line and rsa_jwk["n"][:12] not in line) os.environ.pop("OKTA_SYNC_CLIENT_ID"); os.environ.pop("OKTA_SYNC_PRIVATE_KEY") chk("startup line says DISABLED with no credential", "DISABLED" in okta_sync.describe()) print("\nDONE" if fails == 0 else f"\n{fails} FAILED") sys.exit(1 if fails else 0)