GitHub - CatMe0w/uuidminer: Which Minecraft (offline) player name has the highest "difficulty"‽

uuidminer

中文版请见这里。

A high-performance CUDA/OpenCL/Metal search tool designed to find offline-mode Minecraft player names that correspond to UUIDs with specific prefixes.

In offline mode, a player's UUID is determined by the MD5 hash of the string OfflinePlayer:playername, with the version and variant bits set according to UUID v3 rules. Since the player name space can be viewed as an enumerable search space, this project performs a parallel search on player names to filter out results where the UUID high bits match a specific pattern.

In offline mode, the player name CBRVJ has a UUID with the prefix deadbeef.

Motivation & Evolution

This project started as a joke: if we treat player UUIDs like Bitcoin block hashes, could we define a "name difficulty" and find the "most difficult" player name?

Later, the idea became more practical: the program's performance improved to surpass hashcat. At the same time, the search target was no longer limited to the number of leading zeros, but allowed users to specify any target UUID prefix, such as the hexadecimal string deadbeef, or a combination of dates and numbers with personal significance.

Now, uuidminer is a general-purpose offline player UUID searcher, no longer limited to finding leading zeros.

Features

The program enumerates the legal Minecraft player name character set (excluding CJK player names), i.e., 0-9, a-z, A-Z, and _, totaling 63 characters. It searches for player names with lengths from 3 to 16. Each candidate name is first mapped to its corresponding offline-mode UUID, then matched against the user-specified target prefix.

The program supports multi-GPU and multi-node parallel execution. It provides CUDA, OpenCL, and Metal backends, and runs on Windows, Linux, and macOS.

When no arguments are passed, the program outputs results if the UUID has at least 8 leading zeros. Users can also specify any 8-digit hexadecimal prefix as the search target.

Build

Requires CMake >= 3.18, Python 3, and a compiler toolchain for your platform.

By default, CUDA and OpenCL backends are built on Windows and Linux, while the Metal backend is built on macOS.

cmake -B build
cmake --build build --config Release
./build/uuidminer.exe

To choose which backends to build, pass -DUSE_CUDA, -DUSE_OPENCL, or -DUSE_METAL. For example, to disable the CUDA backend:

cmake -B build -DUSE_CUDA=OFF
cmake --build build --config Release

Usage

uuidminer.exe [--target <hex_prefix>] [--backend <backend>] [--node-index N] [--node-count M] [--node-slices S]

• --target <hex_prefix>: Target UUID prefix, 8 hex digits (4 bytes). Defaults to 00000000 (i.e., at least 8 leading zeros).
• --backend <backend>: Backend to use. One of cuda, opencl, or metal. By default, an available backend is selected automatically.
• --node-index, --node-count, --node-slices: See the "Distributed & Multi-node Configuration" section.

Performance & Status

In the current implementation, the measured performance of a single RTX 3090 is approximately 44 GH/s, which is about 70% of hashcat mode 0 "MD5" and 126% of hashcat mode 20 "md5($salt.$pass)".

The current implementation has been optimized close to the theoretical limit for this specific target. Due to the username generation logic, it cannot reach the peak performance of hashcat mode 0 pure MD5.

At this performance level, the search for all 8-character results has been fully completed. For 9-character length, a single 3090 would take about 4 days of continuous running, and there are currently no plans to exhaustively search it.

Design Trade-offs on Leading Zero Threshold

The program uses 8 leading zeros as the output threshold instead of a longer 12, i.e., 00000000-xxxx-xxxx-xxxx-xxxxxxxxxxxx instead of 00000000-0000-xxxx-xxxx-xxxxxxxxxxxx, for the following reasons:

In actual searching, results with 12 leading zeros do not appear until entering the 9-character name space. In other words, purely for the visual effect of "two segments of leading zeros," the computational cost rises sharply while the return is extremely limited.

At the same time, due to the existence of UUID version and variant bits, the 13th character is fixed as 3. From this point on, the visual "rarity" drops significantly. I personally believe that pursuing more leading zeros beyond 12 bits has no obvious display or research value.

The final consideration is that the results for the first 8 bits are abundant enough. Most target prefixes can find dozens of results within the 6-character or even 5-character space, which should be sufficient for most users.

Analysis Tools

The project provides an additional Python script find_most_difficult.py for statistical analysis of the search results.

The script only analyzes the classic "leading zero" target, but you can modify it to analyze other prefixes or patterns.

Distributed & Multi-node Configuration

The program supports running in multi-GPU and multi-node environments. All distributed behaviors are controlled via command-line arguments.

Core parameters are as follows:

• --node-count: The total number of logical nodes in the entire cluster
• --node-index: The node ID of the current instance, starting from 0
• --node-slices: The number of additional continuous work slices claimed by the current node

For heterogeneous computing clusters, --node-slices is super effective. In an environment with unbalanced computing power, high-performance nodes can actively take on more search space by increasing slices without re-partitioning the entire cluster.

Example 1: Homogeneous Cluster

Suppose there are 4 machines with similar performance, running:

--node-index 0 --node-count 4 --node-slices 1
--node-index 1 --node-count 4 --node-slices 1
--node-index 2 --node-count 4 --node-slices 1
--node-index 3 --node-count 4 --node-slices 1

Each machine is responsible for one-quarter of the search space.

Example 2: Heterogeneous Cluster

Suppose there is 1 high-performance machine and 2 low-performance machines. To let the high-performance node take on half of the workload:

High-performance node:

--node-index 0 --node-count 4 --node-slices 2

Two low-performance nodes:

--node-index 2 --node-count 4 --node-slices 1
--node-index 3 --node-count 4 --node-slices 1

Result Output & CSV Piping

The program outputs hits directly to standard output in the format:

playerName,uuid

To save the results as a CSV file:

uuidminer.exe --target deadbeef > results.csv

Known Most Difficult Usernames

Below are some of the "most difficult" player name results mined so far.

Difficulty is defined as the UUID having the smallest numerical value.

Note: The results for 9-character length have not been fully mined; the table only lists the currently known smallest result.

Special Results

Results for some well-known magic numbers.

deadbeef

deadbeef

deadc0de

fee1dead

defec8ed

Top 10 Smallest Numerical Results for 6-9 Characters

Since the 6-character length already contains a large number of results, the top 10 results with the smallest numerical values for each length are listed here for reference.

These results were generated by the find_most_difficult.py script.

6 Characters

7 Characters

8 Characters

9 Characters (Incomplete)

License

MIT License