Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Development

OAuth 2.0 / OIDC Authorization Code with PKCE Flow Visualizer

· Last updated:2026-09-07

Simulate the Authorization Code flow with PKCE end to end: verifier/challenge generation, authorization URL, token exchange, ID Token validation checklist and an interception-attack demo.

Details

What this tool helps you do

A spec-faithful offline simulator: RFC 7636 S256 challenge derivation, the full OIDC Core §3.1.3.7 ID Token checklist with a real HS256 token and at_hash, an attacker lane, and an annotated parameter matrix. No network calls; a fixed demo clock keeps outputs reproducible.

Execution

Run this tool

Fill in the form, run the tool, and review the result in one place.

Samples

Examples that match this tool

Related

Continue with connected tools and hubs

Written by the Elysia Tools team

Tool usage guide

Learn when to use this tool, what it supports, and how real users apply it.

Key facts

Category
Development
Input types
select, text, checkbox
Output type
html
Sample coverage
4
API ready
Yes

Overview

The OAuth 2.0 / OIDC Authorization Code with PKCE Flow Visualizer is a spec-compliant offline simulator designed to demonstrate modern authentication and authorization workflows. It models every step of the RFC 7636 and OpenID Connect protocols—from code verifier and challenge derivation to authorization URL generation, back-channel token exchange, complete ID Token validation (§3.1.3.7), and optional front-channel interception attack scenarios.

When to use

  • When learning or teaching OAuth 2.0 and OpenID Connect Authorization Code flows with PKCE.
  • When debugging authorization URL parameters, S256 code challenges, and token exchange payloads offline.
  • When verifying how PKCE mitigates authorization code interception attacks compared to flows without PKCE.

How it works

  1. 1Derives the code challenge from the provided or generated code_verifier using SHA-256 (S256), plain, or none modes.
  2. 2Constructs the front-channel authorization request URL and simulates callback parameters with state and authorization code values.
  3. 3Simulates the back-channel token exchange POST request and decodes an authentic HS256-signed ID Token containing claim bindings.
  4. 4Evaluates the complete OIDC Core §3.1.3.7 validation checklist (including iss, aud, nonce, and at_hash) and presents an annotated parameter matrix alongside optional attack simulation results.

Use cases

  • Educational walkthroughs illustrating why single-page applications and native apps require PKCE.
  • Validating client-side parameter construction before integrating with production OpenID Connect identity providers.
  • Security analysis showing how missing PKCE validation exposes authorization codes to front-channel interception.

Examples

1. PKCE S256 Standard Authorization Flow

Frontend Security Engineer

Background

Configuring a single-page application to authenticate users against an OpenID Connect identity provider using the recommended S256 PKCE flow.

Problem

Needs to inspect the generated S256 challenge, request URL, and the resulting OIDC ID Token claims checklist.

How to use

Select 'PKCE S256' as the flow variant, input the issuer URL and client ID, specify scopes including 'openid profile email', and run the simulator.

Flow Variant: s256
code_verifier: dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk
Issuer: http://127.0.0.1:8443
Client ID: spa-demo-client
Redirect URI: http://127.0.0.1:8080/callback
Scope: openid profile email
Simulate Attack: false

Outcome

Generates the exact RFC 7636 challenge E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM, a complete authorization URL, and a 9/9 passing OIDC ID Token validation report.

2. Front-Channel Code Interception Attack Demo

Application Security Trainer

Background

Demonstrating the security risks of public clients using standard authorization code flow without PKCE protection.

Problem

Needs an interactive visual to show students how an intercepted authorization code can be redeemed by an attacker without a verifier.

FAQ

Does this tool make actual network requests to identity providers?

No. The simulator runs completely offline using a deterministic clock to ensure reproducible protocol artifacts.

What is the difference between PKCE S256 and plain?

S256 hashes the code_verifier with SHA-256 and Base64URL-encodes it, whereas plain sends the verifier unchanged as the challenge.

Why is the at_hash check important in OIDC ID Tokens?

The at_hash claim binds the access token to the ID Token, ensuring that the issued access token has not been substituted.

What happens when the interception attack simulation is enabled?

The visualizer simulates an attacker intercepting the authorization code to demonstrate whether token redemption succeeds based on the chosen PKCE mode.

Can I provide custom client credentials and URLs?

Yes. You can supply custom values for issuer URL, client_id, client_secret, redirect_uri, scope, state, nonce, and code_verifier.

Home
Tools3212
Samples593
Visualizations471
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact
Code Processing

Code Comment Samples

Sample code files with various comment styles for testing comment removal

Authentication & Authorization

OAuth 2.0 & OpenID Connect Samples

OAuth 2.0 authorization framework and OpenID Connect authentication protocol examples

Media

QR Code Samples

Sample QR code images for testing QR code reading and generation tools

Authentication & Authorization

OAuth 2.0 Samples

OAuth 2.0 implementation examples including authorization flows, client configurations, and security best practices

Security

PKCE Code Verifier & Challenge Generator

Generate, validate and verify OAuth2 / OIDC PKCE (RFC 7636) code_verifier and S256 code_challenge pairs. Three modes: (1) generate a fresh verifier + challenge from cryptographically secure random bytes at 256/384/512/768-bit entropy, (2) audit a verifier you already have against the RFC — length (43–128), charset [A-Za-z0-9-._~] and ≥256-bit entropy, and (3) verify a verifier/challenge pair by recomputing BASE64URL(SHA256(verifier)). Optionally build the full authorization-request URL and token-exchange body. Complements the generic nonce-generator (which only emits a verifier+challenge pair) with RFC-compliance auditing and pair verification.

Security

BIP39 Mnemonic Phrase Generator

Generate or validate 12 to 24 word BIP39 mnemonic phrases with entropy and PBKDF2-HMAC-SHA512 seed output

Cryptography

Hash Algorithm Comparator

Hash the same input with MD5, SHA-1, SHA-256, SHA-512, BLAKE2b, and BLAKE3 at the same time and compare them side by side: output length, hex/Base64 digest, security status (broken / modern), and a relative speed benchmark. Great for teaching, choosing a hashing algorithm, or sanity-checking checksums.

Games

Kakuro / Fillomino / Masyu / Yajilin / Hashiwokakero / Nurikabe / Slitherlink / Star Battle Puzzle Generator with Uniqueness Prover

Deterministically seeded generator for eight Nikoli logic-puzzle families — each board is grown solution-first, rendered as puzzle + solution SVGs, and verified by an exhaustive backtracking solver that counts solutions to two, so “unique” is a proof (and an exhausted budget is reported as unproven, never guessed).

How to use

Select 'No PKCE' as the flow variant, check 'Simulate a code-interception attack', and view the attacker lane output.

Flow Variant: none
Issuer: http://127.0.0.1:8443
Client ID: spa-demo-client
Redirect URI: http://127.0.0.1:8080/callback
Scope: openid
State: st-attack-demo
Nonce: n-attack-demo
Simulate Attack: true

Outcome

Displays an attack report highlighting that the authorization code was redeemed without code_verifier binding, contrasting it directly against secure PKCE mitigation.