The Copenhagen Book

An Open Redirect vulnerability occurs when an application accepts a user-controlled URL (often via a query parameter like redirect_to) and redirects the user to that location without proper validation.

Attackers can exploit this by crafting links that appear to belong to your trusted domain but actually redirect users to malicious sites (e.g., https://example.com/login?redirect_to=https%3A%2F%2Fscam.com). This is frequently used in phishing attacks to trick users into entering credentials on a fraudulent site that mimics the original.

Some providers (like Google) allow sub-addressing using the + symbol (e.g., user+foo@example.com).

• You can block emails containing + to prevent users from creating multiple accounts with the same primary address.
• Warning: Never silently remove the tag portion from user input, as an email address with + can be a valid, intentional address.

WebAuthn (Web Authentication) allows users to authenticate using device-bound credentials (PINs or biometrics).

Key Terms

• Relying Party (RP): Your application.
• Authenticator: The device holding the credential (e.g., a phone or security key).
• Challenge: A unique, single-use token (minimum 16 bytes entropy) generated by the server to prevent replay attacks.
• User Presence: Confirmation that the user has physical access to the device.
• User Verification: Confirmation that the user has verified their identity (e.g., via biometrics or PIN).
• Resident Keys (Discoverable Credentials): Credentials stored directly on the authenticator. These allow for passwordless login.
• Non-resident Keys: Credentials that are encrypted and stored on your application's server (database).

WebAuthn allows applications to use user devices (like security keys or biometrics) for authentication via public key cryptography.

Capabilities:

• Verify identity using a device's PIN or biometrics.
• Verify the device itself (more user-friendly as it avoids password/fingerprint prompts).

Both methods serve as a second factor. Refer to the specific WebAuthn guide for implementation details.

ECDSA signatures consist of a pair of positive integers, (r, s). There are two primary ways to encode these values:

1. IEEE P1363: The signature is the direct concatenation of r and s. Both are encoded as big-endian bytes with a size equal to the curve size (e.g., 32 bytes for P-256). Format: r || s

2. PKIX (RFC 5480): The signature is an ASN.1 DER encoded sequence containing r and s.

// IEEE P1363
r || s;

// PKIX
SEQUENCE {
    r     INTEGER,
    s     INTEGER
}

Randomness generation can introduce biases that make certain values more likely than others.

Modulo Bias

Occurs when using RANDOM_INT % MAX. If the range of the random source is not a multiple of MAX, some numbers will appear more frequently. Approximate bias formula: 1 / ( RANDOM_BITS - LOG2(MAX) ).

Floating-point Bias

Occurs when multiplying a maximum by a random float (e.g., FLOOR( RANDOM_FLOAT * 5 )). If the precision of the RANDOM_FLOAT is low relative to the multiplier, certain outcomes will have higher probabilities.

The safest way to generate random strings is to generate random bytes using crypto/rand and then encode them using standard schemes like base16 (hex), base32, or base64. This avoids the need for manual character selection and ensures high entropy.

import (
	"crypto/rand"
	"encoding/base32"
)

func generateRandomString() string {
	bytes := make([]byte, 12)
	rand.Read(bytes)
	return base32.StdEncoding.EncodeToString(bytes)
}

A simple defense against CSRF is to check the Origin header for all non-GET requests. Since the Origin header cannot be spoofed via client-side JavaScript in a browser, it is a reliable way to ensure the request started from a trusted source.

Implementation Details:

• If the Origin header is missing, do not allow the request.
• You can use the Referer header as a fallback if Origin is not defined.
• Critical Requirement: If you rely on this method, your application must not use GET requests to modify resources.

func handleRequest(w http.ResponseWriter, request *http.Request) {
  	if request.Method != "GET" {
		originHeader := request.Header.Get("Origin")
		// You can also compare it against the Host or X-Forwarded-Host header.
		if originHeader != "https://example.com" {
			// Invalid request origin
			w.WriteHeader(403)
			return
		}
	}
  	// ...
}