Patched code sample

import json
import base64

def base64url_decode(data):
    """Helper to decode base64url strings, handling padding."""
    padding = '=' * (4 - len(data) % 4)
    return base64.urlsafe_b64decode(data + padding)

def base64url_encode(data):
    """Helper to encode data into base64url strings."""
    return base64.urlsafe_b64encode(data).rstrip(b'=')

def vulnerable_decode_jwt(token):
    """
    A simplified representation of the vulnerable logic.
    It incorrectly accepts 'none' algorithm without checking if it's allowed.
    """
    try:
        header_b64, payload_b64, signature = token.split('.')
        header = json.loads(base64url_decode(header_b64))
        
        if header.get('alg') == 'none':
            # VULNERABILITY: Accepts 'none' alg and returns payload without
            # checking if 'none' was explicitly allowed by the developer.
            return json.loads(base64url_decode(payload_b64))

        # ... logic for other algorithms like RS256/HS256 would go here ...
        print(f"[VULNERABLE] JWT with alg '{header.get('alg')}' would be verified here.")
        return json.loads(base64url_decode(payload_b64))

    except Exception as e:
        print(f"[VULNERABLE] Decoding failed: {e}")
        return None

def fixed_decode_jwt(token, allowed_algs):
    """
    A simplified representation of the fixed logic.
    It explicitly checks the token's algorithm against a list of allowed algorithms.
    """
    try:
        header_b64, payload_b64, signature = token.split('.')
        header = json.loads(base64url_decode(header_b64))
        alg = header.get('alg')

        # FIX: Immediately reject if the token's algorithm is not in the allowed list.
        if alg not in allowed_algs:
            raise ValueError(f"Algorithm '{alg}' is not allowed.")

        if alg == 'none':
            if signature:
                raise ValueError("A token with 'alg: none' must not have a signature.")
            return json.loads(base64url_decode(payload_b64))

        # ... logic for other algorithms like RS256/HS256 would go here ...
        # This part would verify the signature using a key.
        print(f"[FIXED] JWT with alg '{alg}' is allowed and would be verified here.")
        return json.loads(base64url_decode(payload_b64))

    except Exception as e:
        raise type(e)(f"Verification failed: {e}")

if __name__ == '__main__':
    # 1. Create a malicious JWT with "alg": "none" and an empty signature.
    header = {"alg": "none", "typ": "JWT"}
    payload = {"user": "admin", "is_admin": True, "exp": 9999999999}
    
    encoded_header = base64url_encode(json.dumps(header).encode()).decode()
    encoded_payload = base64url_encode(json.dumps(payload).encode()).decode()
    
    # The malicious token has an empty signature part.
    malicious_token = f"{encoded_header}.{encoded_payload}."
    
    print("--- Demonstrating the Vulnerability ---")
    print(f"Malicious Token: {malicious_token}\n")
    
    # The application expects tokens to be signed with 'HS256'.
    app_expected_algs = ['HS256']
    print(f"Application expects algorithms: {app_expected_algs}\n")
    
    # 2. Show the VULNERABLE function incorrectly accepting the token.
    print("Calling vulnerable_decode_jwt...")
    try:
        decoded_payload = vulnerable_decode_jwt(malicious_token)
        if decoded_payload:
            print("SUCCESS: Vulnerable function INSECURELY accepted the 'none' token.")
            print(f"Decoded Payload: {decoded_payload}\n")
    except Exception as e:
        print(f"ERROR: This should not happen. {e}\n")

    # 3. Show the FIXED function correctly rejecting the token.
    print("--- Demonstrating the Fix ---")
    print("Calling fixed_decode_jwt with allowed_algs=['HS256']...")
    try:
        fixed_decode_jwt(malicious_token, allowed_algs=app_expected_algs)
    except Exception as e:
        print("SUCCESS: Fixed function SECURELY rejected the 'none' token as it was not allowed.")
        print(f"Error Message: {e}\n")