A proof-of-concept exploit for the MongoDB zlib decompression vulnerability that allows unauthenticated attackers to leak sensitive server memory.

One example of something I couldn't believe Claude Opus 4.5 could generate until it did: a full-on MIDI mixer as a terminal app, written in Rust.

  https://hackerbook.dosaygo.com/static-shards/shard_1636.sqlite.gz
  https://hackerbook.dosaygo.com/static-shards/shard_1635.sqlite.gz
  https://hackerbook.dosaygo.com/static-shards/shard_1634.sqlite.gz

Quality of Bug Bounty submissions after AI:

> 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. 🌎