Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /Pacalexandre_oidc_pure /examples /keycloak_example.py
| """ | |
| Example usage of the OIDC Pure library with Keycloak. | |
| This example demonstrates: | |
| 1. OIDC Discovery | |
| 2. Authorization Code Flow with PKCE | |
| 3. Token exchange | |
| 4. User info retrieval | |
| 5. Token refresh | |
| 6. Token validation | |
| """ | |
| import webbrowser | |
| from http.server import BaseHTTPRequestHandler, HTTPServer | |
| from urllib.parse import parse_qs, urlparse | |
| from oidc_pure import OIDCClient | |
| # Configuration for Keycloak | |
| KEYCLOAK_URL = "https://keycloak.example.com/realms/myrealm" | |
| CLIENT_ID = "my-client" | |
| CLIENT_SECRET = "your-client-secret" # Optional for public clients | |
| REDIRECT_URI = "http://localhost:8080/callback" | |
| # Global variables to store authorization data | |
| auth_code = None | |
| auth_state = None | |
| class CallbackHandler(BaseHTTPRequestHandler): | |
| """Simple HTTP server to handle OAuth2 callback.""" | |
| def do_GET(self): | |
| """Handle GET request to callback endpoint.""" | |
| global auth_code, auth_state | |
| # Parse query parameters | |
| parsed = urlparse(self.path) | |
| params = parse_qs(parsed.query) | |
| if parsed.path == "/callback": | |
| # Store full URL for processing | |
| full_url = f"http://localhost:8080{self.path}" | |
| # Check for error | |
| if "error" in params: | |
| error = params["error"][0] | |
| error_desc = params.get("error_description", [""])[0] | |
| self.send_response(400) | |
| self.end_headers() | |
| self.wfile.write(f"Error: {error} - {error_desc}".encode()) | |
| return | |
| # Extract code and state | |
| if "code" in params: | |
| auth_code = full_url | |
| auth_state = params.get("state", [None])[0] | |
| self.send_response(200) | |
| self.end_headers() | |
| self.wfile.write(b"Authorization successful! You can close this window.") | |
| else: | |
| self.send_response(400) | |
| self.end_headers() | |
| self.wfile.write(b"Missing authorization code") | |
| else: | |
| self.send_response(404) | |
| self.end_headers() | |
| def log_message(self, format, *args): | |
| """Suppress server logs.""" | |
| pass | |
| def example_authorization_code_flow(): | |
| """ | |
| Example: Authorization Code Flow with PKCE. | |
| This is the recommended flow for web applications and native apps. | |
| """ | |
| print("=" * 60) | |
| print("Example: Authorization Code Flow with PKCE") | |
| print("=" * 60) | |
| # Initialize OIDC client | |
| print(f"\n1. Initializing OIDC client for {KEYCLOAK_URL}...") | |
| with OIDCClient( | |
| issuer_url=KEYCLOAK_URL, | |
| client_id=CLIENT_ID, | |
| client_secret=CLIENT_SECRET, | |
| redirect_uri=REDIRECT_URI, | |
| ) as client: | |
| print(" ✓ Discovery completed") | |
| print(f" - Authorization endpoint: {client.config.authorization_endpoint}") | |
| print(f" - Token endpoint: {client.config.token_endpoint}") | |
| print(f" - Userinfo endpoint: {client.config.userinfo_endpoint}") | |
| # Generate authorization URL | |
| print("\n2. Generating authorization URL...") | |
| auth_url, state, code_verifier = client.get_authorization_url( | |
| scope=["openid", "profile", "email"], | |
| use_pkce=True, | |
| ) | |
| print(" ✓ Authorization URL generated") | |
| print(f" - State: {state[:20]}...") | |
| print(f" - Code verifier: {code_verifier[:20] if code_verifier else 'None'}...") | |
| # Open browser for user authorization | |
| print("\n3. Opening browser for user authorization...") | |
| print(f" URL: {auth_url}") | |
| # Start local server to receive callback | |
| server = HTTPServer(("localhost", 8080), CallbackHandler) | |
| # Open browser | |
| webbrowser.open(auth_url) | |
| print(" Waiting for authorization callback...") | |
| # Wait for callback (handle single request) | |
| server.handle_request() | |
| if not auth_code: | |
| print(" ✗ Authorization failed or was cancelled") | |
| return | |
| print(" ✓ Authorization code received") | |
| # Exchange code for tokens | |
| print("\n4. Exchanging authorization code for tokens...") | |
| try: | |
| token_response = client.handle_authorization_response( | |
| response_url=auth_code, | |
| expected_state=state, | |
| code_verifier=code_verifier, | |
| ) | |
| print(" ✓ Tokens received") | |
| print(f" - Access token: {token_response.access_token[:20]}...") | |
| print(f" - Token type: {token_response.token_type}") | |
| print(f" - Expires in: {token_response.expires_in} seconds") | |
| if token_response.refresh_token: | |
| print(f" - Refresh token: {token_response.refresh_token[:20]}...") | |
| if token_response.id_token: | |
| print(f" - ID token: {token_response.id_token[:20]}...") | |
| # Get user information | |
| print("\n5. Retrieving user information...") | |
| user_info = client.get_user_info(token_response.access_token) | |
| print(" ✓ User info retrieved") | |
| print(f" - Subject: {user_info.sub}") | |
| print(f" - Name: {user_info.name}") | |
| print(f" - Email: {user_info.email}") | |
| print(f" - Username: {user_info.preferred_username}") | |
| if user_info.claims: | |
| print(f" - Additional claims: {list(user_info.claims.keys())}") | |
| # Validate and decode tokens | |
| print("\n6. Validating tokens...") | |
| # Decode ID token (if available) | |
| if token_response.id_token: | |
| id_claims = client.decode_token(token_response.id_token) | |
| print(" ✓ ID token decoded") | |
| print(f" - Subject: {id_claims.get('sub')}") | |
| print(f" - Issued at: {id_claims.get('iat')}") | |
| print(f" - Expires at: {id_claims.get('exp')}") | |
| # Validate access token (basic validation without signature) | |
| access_claims = client.validate_token( | |
| token_response.access_token, | |
| verify_signature=False, # Set to True if using HMAC with client_secret | |
| ) | |
| print(" ✓ Access token validated") | |
| print(f" - Scopes: {access_claims.get('scope', 'N/A')}") | |
| # Refresh token (if available) | |
| if token_response.refresh_token: | |
| print("\n7. Refreshing access token...") | |
| new_token = client.refresh_token(token_response.refresh_token) | |
| print(" ✓ Token refreshed") | |
| print(f" - New access token: {new_token.access_token[:20]}...") | |
| print(f" - Expires in: {new_token.expires_in} seconds") | |
| # Generate logout URL | |
| print("\n8. Generating logout URL...") | |
| logout_url = client.logout_url( | |
| id_token_hint=token_response.id_token, | |
| post_logout_redirect_uri="http://localhost:8080", | |
| ) | |
| if logout_url: | |
| print(" ✓ Logout URL generated") | |
| print(f" - URL: {logout_url}") | |
| else: | |
| print(" - Logout endpoint not available") | |
| print("\n" + "=" * 60) | |
| print("Example completed successfully!") | |
| print("=" * 60) | |
| except Exception as e: | |
| print(f" ✗ Error: {e}") | |
| raise | |
| def example_client_credentials(): | |
| """ | |
| Example: Client Credentials Flow. | |
| Used for machine-to-machine authentication. | |
| """ | |
| print("\n" + "=" * 60) | |
| print("Example: Client Credentials Flow") | |
| print("=" * 60) | |
| print(f"\n1. Initializing OIDC client for {KEYCLOAK_URL}...") | |
| with OIDCClient( | |
| issuer_url=KEYCLOAK_URL, | |
| client_id=CLIENT_ID, | |
| client_secret=CLIENT_SECRET, | |
| ) as client: | |
| print(" ✓ Discovery completed") | |
| # Perform client credentials grant | |
| print("\n2. Performing client credentials grant...") | |
| try: | |
| token_response = client.client_credentials_grant(scope="api:read api:write") | |
| print(" ✓ Access token received") | |
| print(f" - Access token: {token_response.access_token[:20]}...") | |
| print(f" - Token type: {token_response.token_type}") | |
| print(f" - Expires in: {token_response.expires_in} seconds") | |
| # Validate token | |
| print("\n3. Validating access token...") | |
| claims = client.validate_token( | |
| token_response.access_token, | |
| verify_signature=False, | |
| ) | |
| print(" ✓ Token validated") | |
| print(f" - Subject: {claims.get('sub')}") | |
| print(f" - Scopes: {claims.get('scope', 'N/A')}") | |
| print("\n" + "=" * 60) | |
| print("Example completed successfully!") | |
| print("=" * 60) | |
| except Exception as e: | |
| print(f" ✗ Error: {e}") | |
| raise | |
| def example_token_validation(): | |
| """ | |
| Example: Token validation and decoding. | |
| """ | |
| print("\n" + "=" * 60) | |
| print("Example: Token Validation") | |
| print("=" * 60) | |
| # Sample JWT token (replace with real token) | |
| sample_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c" | |
| print("\n1. Initializing token validator...") | |
| with OIDCClient( | |
| issuer_url=KEYCLOAK_URL, | |
| client_id=CLIENT_ID, | |
| client_secret=CLIENT_SECRET, | |
| auto_discover=False, # Skip discovery for this example | |
| ) as client: | |
| print(" ✓ Validator initialized") | |
| # Decode token without validation | |
| print("\n2. Decoding token (without validation)...") | |
| try: | |
| claims = client.decode_token(sample_token) | |
| print(" ✓ Token decoded") | |
| print(f" - Claims: {claims}") | |
| except Exception as e: | |
| print(f" ✗ Error: {e}") | |
| if __name__ == "__main__": | |
| print("\n") | |
| print("╔" + "═" * 58 + "╗") | |
| print("║" + " " * 10 + "OIDC Pure Library - Examples" + " " * 20 + "║") | |
| print("╚" + "═" * 58 + "╝") | |
| print("\nBefore running these examples, configure:") | |
| print("1. KEYCLOAK_URL: Your Keycloak realm URL") | |
| print("2. CLIENT_ID: Your OAuth2 client ID") | |
| print("3. CLIENT_SECRET: Your client secret (if using confidential client)") | |
| print("4. REDIRECT_URI: Callback URL (must be configured in Keycloak)") | |
| print("\n" + "-" * 60) | |
| try: | |
| # Run authorization code flow example | |
| example_authorization_code_flow() | |
| # Uncomment to run other examples: | |
| # example_client_credentials() | |
| # example_token_validation() | |
| except KeyboardInterrupt: | |
| print("\n\nExamples interrupted by user.") | |
| except Exception as e: | |
| print(f"\n\nError running examples: {e}") | |
| import traceback | |
| traceback.print_exc() | |
Xet Storage Details
- Size:
- 11 kB
- Xet hash:
- 52e7b120d2e61a69f9faae9c27044ea87360f712d95f719ee4c1244e6e685b21
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.