Open Source Intelligence Techniques

OSINT Techniques: Chapter 9 - Usernames

An exhaustive breakdown of Chapter 9 of Michael Bazzell's 'Open Source Intelligence Techniques', analyzing username enumeration mechanics, Sherlock and Maigret architectures, false positive elimination, and automated cross-platform identity clustering.

8 min read
views
visits
OSINT Techniques Chapter 9 Summary - Usernames
OSINT Techniques Chapter 9 Summary - Usernames

Welcome to our ninth chapter analysis covering “Open Source Intelligence Techniques: Resources for Searching and Analyzing Online Information” (Sixth Edition) by Michael Bazzell.

Humans are creatures of habit. When a person selects a unique username—whether for Xbox Live, GitHub, an obscure automotive forum, or Instagram—they frequently reuse that exact handle or slight variations across dozens of services.

In Chapter 9: Usernames, Bazzell formalizes the discipline of Username OSINT. A single verified username can unmask an individual’s entire digital life: their coding repositories, gaming habits, Spotify listening playlists, cryptocurrency addresses, and personal forum discussions. In this comprehensive guide, we dissect the inner mechanics of automated username checkers (WhatsMyName, Sherlock, Maigret), analyze HTTP response verification algorithms, examine false-positive pruning, and demonstrate cross-platform identity clustering.


Key Takeaways

  • The Username Fingerprint: An uncommon username (e.g., xX_ShadowSniper99_Xx or k8s_wizard_boston) carries a high uniqueness coefficient, allowing high-confidence correlation across unrelated platforms.
  • HTTP 200 vs Body Inspection: Amateur scripts only check if a profile URL returns an HTTP 200 OK status code. Professional tools must inspect response body tokens, redirect headers, and error strings to eliminate false positives on sites that return custom 200 OK error pages.
  • The WhatsMyName JSON Standard: The modern OSINT community maintains WhatsMyName, an open-source schema defining URL patterns, probe methods, and error detection strings for over 600 platforms.
  • Username Permutation Engine: When an exact handle yields limited results, investigators must generate structured permutations based on naming conventions (john_doe, johndoe88, j_doe_us).
  • Temporal Clustering: Comparing account registration dates across discovered platforms reveals an individual’s digital evolution over time.

Architectural & Investigative Workflow

The following flowchart outlines the automated username discovery, verification, and correlation pipeline:

flowchart TD
    subgraph Seed_Extraction["Phase 1: Seed Username Extraction"]
        Seed["Target Seed Username (e.g., cyber_phantom)"] --> Permutation["Generate Algorithmic Variations (Prefixes / Suffixes / Years)"]
    end
    subgraph Automated_Probing["Phase 2: Multi-Platform Probing (WhatsMyName / Sherlock)"]
        Permutation --> Dispatcher["Asynchronous HTTP Request Dispatcher (100+ Concurrent Requests)"]
        Dispatcher --> TargetEndpoints["600+ Web Platforms (GitHub, Reddit, Steam, Pinterest, TikTok)"]
        TargetEndpoints --> ResponseAnalyzer["Response Verification Engine"]
    end
    subgraph Verification_Pruning["Phase 3: False-Positive Pruning Engine"]
        ResponseAnalyzer --> CheckCode{"HTTP 200 & Error Token Absent?"}
        CheckCode -- Yes --> ConfirmedMatch["Confirmed Live Account"]
        CheckCode -- No --> Discard["Discard (False Positive / Unregistered)"]
    end
    subgraph Profile_Clustering["Phase 4: Identity Clustering & Synthesis"]
        ConfirmedMatch --> BioScrape["Exfiltrate Avatars, Bios, Location Metadata"]
        BioScrape --> ClusterDossier["Unified Target Intelligence Dossier"]
    end

Technical Breakdown & Investigative Mechanics

1. How Username Enumeration Works: The WhatsMyName Standard

Modern username reconnaissance relies on structured JSON schemas that define how each web service responds when a profile exists versus when it is absent.

Deconstructing a WhatsMyName Schema Entry:

1
2
3
4
5
6
7
8
{
  "name": "GitHub",
  "uri_check": "https://www.github.com/{account}",
  "e_code": 404,
  "m_code": 200,
  "m_string": "Pinned",
  "category": "coding"
}

Why HTTP Status Codes Are Insufficient:

Many platforms (such as TikTok, Medium, or Steam) employ Single Page Applications (SPAs). When navigating to a non-existent user profile, the server serves the generic index.html file with an HTTP 200 OK status code, while the client-side JavaScript renders “User not found”.

A robust username detection engine must perform two-factor response validation:

  1. Verify the HTTP status code matches m_code (e.g., 200).
  2. Verify the response body does NOT contain the error string e_string (e.g., “This account does not exist” or “Sorry, nobody on Reddit goes by that name”).

2. Modern CLI Toolchains: Sherlock & Maigret

1. Sherlock Project

The standard asynchronous CLI tool for scanning usernames across 400+ platforms:

1
2
3
4
5
# Installing Sherlock via Pipx
pipx install sherlock-project

# Scanning a target username with proxy support and verbose reporting
sherlock target_handle --timeout 5 --print-found --csv output_sherlock.csv

2. Maigret (Advanced Semantic Scraper)

Maigret builds upon Sherlock by not only checking if an account exists, but also automatically extracting profile pictures, full names, bio descriptions, and linked URLs from discovered profiles:

1
2
3
# Installing and executing Maigret
pipx install maigret
maigret target_handle --all-sites --pdf report_target.pdf

3. Automated Username Permutation Generation (Python)

When targets adopt professional or sanitized handles, investigators generate systematic variations based on known identity seeds:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#!/usr/bin/env python3
# username_permutator.py - Algorithmic Username Matrix Generator

def generate_permutations(first, last, year=""):
    first = first.lower()
    last = last.lower()
    f = first[0]
    l = last[0]
    
    variations = [
        f"{first}{last}",
        f"{first}.{last}",
        f"{first}_{last}",
        f"{last}{first}",
        f"{f}{last}",
        f"{f}_{last}",
        f"{first}{l}",
        f"{first}_{l}",
        f"{last}_{f}",
        f"{last}{f}"
    ]
    
    if year:
        short_year = year[-2:]
        extended = []
        for v in variations:
            extended.append(f"{v}{year}")
            extended.append(f"{v}{short_year}")
            extended.append(f"{v}_{short_year}")
        variations.extend(extended)
        
    return sorted(list(set(variations)))

# Example: Generate variations for John Miller born in 1994
results = generate_permutations("John", "Miller", "1994")
print(f"Generated {len(results)} permutations. Sample:")
print("
".join(results[:8]))

4. Cross-Platform Avatar & Bio Clustering

Once a list of confirmed profiles is generated, the analyst must verify whether all accounts belong to the same physical individual or represent unrelated people sharing a common handle:

  1. Avatar Image Hashing: Calculate the SHA-256 or perceptual hash (pHash) of profile pictures across platforms. Identical avatars across Steam, GitHub, and a local forum confirm a single human operator.
  2. Bio Text Cross-Referencing: Many users copy and paste identical quotes, employer titles, or personal philosophies into bio fields across platforms.
  3. Friend Graph Overlap: If the Twitter account and the Instagram account both follow the same 3 niche artists or local sports clubs, correlation confidence reaches near certainty.

Real-World Case Scenario

Case Study: Tracking a Rogue Developer Leaking Enterprise Firmware

An anonymous user on an obscure hardware reverse-engineering forum (reverse_core_91) published proprietary firmware binaries extracted from an industrial control system.

  1. An analyst executed Sherlock on the handle reverse_core_91.
  2. The tool discovered active accounts on GitHub, SoundCloud, and an Italian motorcycle enthusiast forum.
  3. The GitHub account had zero public commits, but the SoundCloud account featured playlists of local garage rock bands based in Bologna, Italy.
  4. On the Italian motorcycle forum, reverse_core_91 had posted photos of a modified Ducati motorcycle in 2021.
  5. The motorcycle photo contained a reflection in the chrome exhaust pipe showing a driveway and house number. Cross-referencing the Italian motorcycle forum’s member birthday field with local Bologna voter registries pinpointed the firmware developer within 24 hours.

Defensive Countermeasures & OpSec Recommendations

For individuals and security professionals seeking to protect their identity:

  1. Compartmentalize Usernames by Domain: Maintain completely separate, uncorrelated usernames for distinct aspects of life:
    • Professional / Public (e.g., LinkedIn, corporate GitHub)
    • Personal / Social (e.g., private Instagram, family Facebook)
    • High-Risk / Anonymous (e.g., security research, gaming, crypto)
  2. Never Use Identical Usernames Across Anonymous and Clear Identifiers: Avoid using your favorite gaming alias or childhood nickname on research platforms or darknet accounts.
  3. Periodically Run Sherlock on Your Own Handles: Audit your own digital footprint annually to discover forgotten accounts on obsolete forums and request account deletion.

Conclusion & Next Steps

Chapter 9 illustrates that a username is a uniquely resilient thread connecting disparate online platforms. By leveraging high-speed enumeration engines, validating response bodies, and clustering avatar metadata, an analyst can assemble a comprehensive target profile from a single handle.

In Chapter 10: People Search Engines, we pivot to real-world identity aggregation: public records, voter registries, property deed databases, and data broker opt-out protocols.


Practical Username Enumeration & Moniker Correlation Cheat-Sheet

Tool / Engine Command / Query Format Investigative Output
Sherlock Multi-Platform sherlock target_alias --timeout 10 --folder-output ./results Scans 400+ social and developer websites for target alias presence
Maigret Recursive Triage maigret target_alias -a --pdf --html Parses target profile pages recursively, extracting full names, IDs, and avatars
WhatsMyName Engine python3 whatsmyname.py -u target_alias Matches target alias against curated and verified community regex signatures
GitHub Commit Forensics curl -s 'https://api.github.com/users/target_alias/events/public' | grep 'email' Extracts author email addresses and commit PGP signatures from public activities
Keybase Identity Tree curl -s 'https://keybase.io/_/api/1.0/user/lookup.json?usernames=target_alias' Resolves cryptographically linked Twitter, GitHub, Mastodon, and Bitcoin addresses

Authoritative References & Verified Investigative Sources


Author: Abdulrahman M. Fathi (0x3bdo) • Cyber Security Engineer & Penetration Tester

Open Research & Community Labs
صدقة جارية • Ongoing Charity

Empowering the Cybersecurity Community

All research, lab walkthroughs, and technical series on this platform remain 100% free. You can support server hosting, research environments, and lab infrastructure.

Support & Wall of Honor
اللهم اجعل هذا العمل علمًا نافعًا وصدقةً جارية، واكتب لي به الأجر والقبول، وانفع به كل من قرأه أو تعلّمه.
اللهم احفظ لي والديّ وأهلي، وبارك في أعمارهم وصحتهم، وأدم عليهم نعمة الصحة والعافية، ولا تريني فيهم بأسًا يبكيني.
Dedicated as ongoing charity and beneficial knowledge. May Allah bless my parents and family, protect them, and grant them lasting health and happiness.