> random youtube guy
> begins 2 hour video with "today i'm bored"
> continues to create ML library from scratch in C
> types everything manually at 150 wpm in neovim
> trains mnist classification model with his library
> "that is pretty cool"
> chuckles
> leaves

The Miller-Rabin primality test is an algorithm used to determine if a very large number is a prime number. It is the standard method used in cryptography (like RSA key generation and the git-prime example above) because it is incredibly fast.

1. What is it?
It is a probabilistic algorithm. This is the most important distinction:
* Deterministic tests (like trying to divide the number by every smaller number) give you a 100% correct answer but are impossibly slow for large numbers.
* Miller-Rabin gives you an answer very quickly, but it trades absolute certainty for speed.

The output of the test is either:
1. Composite: The number is definitely not prime (100% certainty).
2. Probably Prime: The number is very likely prime.

2. Why do we need it for SHA-1?
As the source noted, SHA-1 hashes are 160-bit integers. That is a number roughly equal to 10 to the power of 48 (a 1 followed by 48 zeros).

If you used standard division to check if that number is prime, the sun would likely explode before your computer finished. Miller-Rabin can check it in milliseconds.

3. How does it work?
The math relies on Fermat's Little Theorem, which states that if p is a prime number, then for any integer a, a^(p-1) mod p = 1.

Here is the simplified process:

Step 1: The Setup
Let's say we want to test a big number n. We express n-1 in a specific form (2^s * d). This is basically factoring out all powers of 2.

Step 2: The Witness
We pick a random number a (called a base) that is smaller than n. We call this number a "witness."

Step 3: The Interrogation
We run a modular exponentiation calculation using a, s, and d.
* If the math doesn't balance out according to the theorem, a acts as a witness that proves n is Composite. We stop immediately.
* If the math *does* balance out, n passes the test for that specific witness.

Step 4: Repetition
Because there is a tiny chance a composite number could "trick" the test (called a Strong Pseudoprime), we repeat Step 2 and 3 with different random values for a.

import random
def is_prime_miller_rabin(n, k=40):
    """Miller-Rabin primality test - probabilistic but very reliable"""
    if n < 2:
        return False
    if n == 2 or n == 3:
        return True
    if n % 2 == 0:
        return False

    # Write n-1 as 2^r * d
    r, d = 0, n - 1
    while d % 2 == 0:
        r += 1
        d //= 2

    # Witness loop
    for _ in range(k):
        a = random.randrange(2, n - 1)
        x = pow(a, d, n)

        if x == 1 or x == n - 1:
            continue

        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False

    return True

Step inside Project Genie: our experimental research prototype that lets you create, edit, and explore virtual worlds. 🌎

[1 corner][2 edge][3 corner]
[4 edge ][5 fill][6 edge  ]
[7 corner][8 edge][9 corner]

StackOverflow post from official staff about how the website hasn't been killed by AI.... is AI generated

Fiber v2 contains an internal vendored copy of gofiber/utils, and its functions UUIDv4() and UUID() inherit the same critical weakness described in the upstream advisory. On Go versions prior to 1.24, the underlying crypto/rand implementation can return an error if secure randomness cannot be obtained. In such cases, these Fiber v2 UUID functions silently fall back to generating predictable values — the all-zero UUID 00000000-0000-0000-0000-000000000000.

On Go 1.24+, the language guarantees that crypto/rand no longer returns an error (it will block or panic instead), so this vulnerability primarily affects Fiber v2 users running Go 1.23 or earlier, which Fiber v2 officially supports.

Because no error is returned by the Fiber v2 UUID functions, application code may unknowingly rely on predictable, repeated, or low-entropy identifiers in security-critical pathways. This is especially impactful because many Fiber v2 middleware components (session middleware, CSRF, rate limiting, request-ID generation, etc.) default to using utils.UUIDv4().