pslist 0.1.0__py3-none-any.whl

pslist-0.1.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: pslist
+Version: 0.1.0
+Summary: Username-targeted password wordlist generator
+Author: Shanmukha
+License: MIT
+Project-URL: Homepage, https://github.com/5h4nnu-dev/wl
+Project-URL: Repository, https://github.com/5h4nnu-dev/wl
+Project-URL: BugTracker, https://github.com/5h4nnu-dev/wl/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# wl — Username-Targeted Password Wordlist Generator
+
+Generate highly targeted password candidates for a given username by applying structural patterns derived from real-world breach data (RockYou, SecLists, etc.). Every generated password relates to the target username — no filler entries.
+
+## Installation
+
+```bash
+pip install pslist   # once published
+# or from source:
+git clone https://github.com/5h4nnu-dev/wl.git
+cd wl
+pip install -e .
+```
+
+## Usage
+
+```bash
+wl <username> [options]
+```
+
+### Basic
+
+```bash
+wl john
+```
+
+Generates `john_wordlist.txt` with ~78k unique candidates using the common word pool and structural patterns.
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `--keywords` | Custom keywords (pets, partners, etc.) |
+| `--birth-year` | Birth year (e.g. 1990) |
+| `--year-range` | Year range (default: 2020-2026) |
+| `--leet` | Apply leet substitutions |
+| `--output FILE` | Output file (default: `<username>_wordlist.txt`) |
+| `--min-len` | Minimum password length (default: 4) |
+| `--max-len` | Maximum password length (default: 32) |
+| `--wordlist` | External wordlist file (adds to token pools) |
+| `--refresh` | Re-download common passwords cache |
+
+### Examples
+
+```bash
+wl john --leet --output john.txt
+wl admin --birth-year 1990 --year-range 2020 2026 --keywords rocket star
+wl alice --wordlist rockyou.txt --refresh
+```
+
+## How It Works
+
+Token pools are built from the username (variants, truncations, reversals) and combined using structural patterns observed in real breaches:
+
+```
+{name}{digits}         →  john123
+{name}{special}        →  john!
+{name}{digits}{special} →  john123!
+{Name}{digits}         →  John123
+{name}{year}           →  john2024
+{word}{digits}         →  password123
+{name}{word}           →  johnpassword
+{l33t}{digits}         →  j0hn123
+```
+
+### Token Sources
+
+| Token | Source |
+|-------|--------|
+| `{name}` | username + case variants + truncations + reversed |
+| `{Name}` | capitalized variants |
+| `{digits}` | 0–99, common sequences, birth/year range |
+| `{special}` | `! @ # $ % & *` |
+| `{year}` | birth year + year range |
+| `{word}` | top words from SecLists 10k-most-common |
+| `{l33t}` | leet-speak variants |
+| `{keyword}` | user-supplied custom keywords |
+
+The common password pool is downloaded from [SecLists](https://github.com/danielmiessler/SecLists) on first run and cached at `~/.cache/wl/common_passwords.txt`.
+
+## Use Cases
+
+- **Offline hash cracking** — feed wordlist into Hashcat / John
+- **Internal password spraying** — targeted low-and-slow attempts per user
+- **Credential pattern analysis** — understand a target's password habits
+
+## Dependencies
+
+Python stdlib only — no third-party packages required.
+
+## License
+
+MIT

pslist-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pslist-0.1.0.dist-info/licenses/LICENSE,sha256=ESYyLizI0WWtxMeS7rGVcX3ivMezm-HOd5WdeOh-9oU,1056
+wl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wl/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+wl/cli.py,sha256=DLCKeglaJ-mNUbrr0fnLWJcitQQMqlDB_XtVnBw8ubM,2240
+wl/fetcher.py,sha256=RhnSI5WbXY-Z9WV4ut9W0nsL2yysNzmbCLqjUqcHrHo,1641
+wl/generator.py,sha256=rln9V3goycQF3pEDb5wMqCD7aeMQH4B1JIpH5Y4L8ic,899
+wl/leet.py,sha256=ELICju1QagdsggUlyC2mbqBDjDx41kOYkR2DDGdu9z8,842
+wl/patterns.py,sha256=Z8leVAew0-Z3ommOOrJ8H13SpnBRtH_wHwycrc5oHm0,1224
+wl/tokens.py,sha256=uoftFRJB9ZChaPGeflTtDTIUuQ8owUkPdShgy9g6JZM,2461
+pslist-0.1.0.dist-info/METADATA,sha256=Y2E4cJRPBqQIQwOguCM0mONGA0zcgkjywh6TwG5r0fI,3669
+pslist-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pslist-0.1.0.dist-info/entry_points.txt,sha256=Rw3pr85HWo0z_drJoMccDLQ5znMipC649xaEK0ob6sE,35
+pslist-0.1.0.dist-info/top_level.txt,sha256=5xIGnFBetCT7B4-eHKWhTl8HjW0MZVbbtlIBf45fhN0,3
+pslist-0.1.0.dist-info/RECORD,,

pslist-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pslist-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wl = wl.cli:main

pslist-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pslist-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wl

wl/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

wl/cli.py

@@ -0,0 +1,55 @@
+import argparse
+import sys
+
+from .generator import generate_wordlist
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate a targeted password wordlist for a given username.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  wl john\n"
+            "  wl john --leet --output john.txt\n"
+            "  wl admin --birth-year 1990 --year-range 2020 2026 --keywords rocket star\n"
+            "  wl alice --wordlist rockyou.txt --refresh\n"
+        ),
+    )
+    parser.add_argument("username", help="Target username")
+    parser.add_argument("--keywords", nargs="+", default=[], help="Additional keywords (pets, partners, etc.)")
+    parser.add_argument("--birth-year", type=int, help="Birth year (e.g. 1990)")
+    parser.add_argument("--year-range", nargs=2, type=int, default=[2020, 2026], metavar=("START", "END"), help="Year range (default: 2020 2026)")
+    parser.add_argument("--leet", action="store_true", help="Apply leet speak substitutions")
+    parser.add_argument("--output", help="Output file (default: <username>_wordlist.txt)")
+    parser.add_argument("--min-len", type=int, default=4, help="Minimum password length (default: 4)")
+    parser.add_argument("--max-len", type=int, default=32, help="Maximum password length (default: 32)")
+    parser.add_argument("--wordlist", help="External wordlist file for additional tokens")
+    parser.add_argument("--refresh", action="store_true", help="Re-download common passwords cache")
+
+    args = parser.parse_args()
+
+    output = args.output or f"{args.username}_wordlist.txt"
+
+    passwords = generate_wordlist(
+        username=args.username,
+        keywords=args.keywords,
+        birth_year=args.birth_year,
+        year_range=tuple(args.year_range),
+        leet=args.leet,
+        min_len=args.min_len,
+        max_len=args.max_len,
+        wordlist_path=args.wordlist,
+        refresh=args.refresh,
+    )
+
+    with open(output, "w") as f:
+        for pwd in passwords:
+            f.write(pwd + "\n")
+
+    print(f"[*] Generated {len(passwords):,} unique candidates", file=sys.stderr)
+    print(f"[*] Saved to {output}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

wl/fetcher.py

@@ -0,0 +1,57 @@
+import os
+import sys
+import urllib.request
+
+COMMON_PASSWORDS_URL = (
+    "https://raw.githubusercontent.com/danielmiessler/SecLists/"    # change 
+    "master/Passwords/Common-Credentials/10k-most-common.txt"
+)
+CACHE_DIR = os.path.expanduser("~/.cache/wl")
+CACHE_FILE = os.path.join(CACHE_DIR, "common_passwords.txt")
+
+
+def _ensure_cache_dir():
+    os.makedirs(CACHE_DIR, exist_ok=True)
+    return CACHE_DIR
+
+
+def fetch_common_passwords(refresh=False):
+    _ensure_cache_dir()
+
+    if not refresh and os.path.exists(CACHE_FILE):
+        return CACHE_FILE
+
+    print("[*] No cached word pool found — downloading common passwords...", file=sys.stderr)
+    try:
+        urllib.request.urlretrieve(COMMON_PASSWORDS_URL, CACHE_FILE)
+        print(f"[*] Cached to {CACHE_FILE}", file=sys.stderr)
+    except Exception as e:
+        print(f"[!] Failed to download: {e}", file=sys.stderr)
+        if os.path.exists(CACHE_FILE):
+            return CACHE_FILE
+        return None
+
+    return CACHE_FILE
+
+
+def extract_word_pool(wordlist_path=None, refresh=False):
+    cache_file = fetch_common_passwords(refresh)
+    words = set()
+
+    sources = []
+    if cache_file:
+        sources.append(cache_file)
+    if wordlist_path and os.path.exists(wordlist_path):
+        sources.append(wordlist_path)
+
+    for src in sources:
+        try:
+            with open(src, "r", errors="ignore") as f:
+                for line in f:
+                    word = line.strip()
+                    if word and word.isalpha() and 3 <= len(word) <= 15:
+                        words.add(word.lower())
+        except Exception:
+            pass
+
+    return sorted(words)

wl/generator.py

@@ -0,0 +1,32 @@
+import sys
+
+from .tokens import build_token_pools
+from .patterns import generate_all
+from .fetcher import extract_word_pool
+
+
+def generate_wordlist(
+    username, keywords=None, birth_year=None, year_range=None,
+    leet=False, min_len=4, max_len=32, wordlist_path=None, refresh=False,
+):
+    word_pool = extract_word_pool(wordlist_path, refresh)
+    if word_pool:
+        print(f"[*] Extracted {len(word_pool):,} common words as pattern tokens", file=sys.stderr)
+
+    pools = build_token_pools(
+        username=username,
+        leet=leet,
+        keywords=keywords,
+        word_pool=word_pool,
+        birth_year=birth_year,
+        year_range=year_range,
+    )
+
+    for key, values in pools.items():
+        if values:
+            print(f"[*] {key}: {len(values)} tokens", file=sys.stderr)
+
+    passwords = list(generate_all(pools, min_len, max_len))
+    passwords.sort()
+
+    return passwords

wl/leet.py

@@ -0,0 +1,42 @@
+from itertools import product
+
+LEET_MAP = {
+    "a": ["4", "@"],
+    "e": ["3"],
+    "i": ["1", "!"],
+    "o": ["0"],
+    "s": ["5", "$"],
+    "t": ["7"],
+    "b": ["8"],
+    "g": ["9"],
+}
+
+
+def apply_leet(text):
+    if not text:
+        return []
+
+    text_lower = text.lower()
+    positions = []
+    for i, c in enumerate(text_lower):
+        if c in LEET_MAP:
+            positions.append((i, c))
+
+    if not positions:
+        return [text]
+
+    if len(positions) > 6:
+        positions = positions[:6]
+
+    results = set()
+    substitutions = []
+    for _idx, char in positions:
+        substitutions.append(LEET_MAP[char])
+
+    for combo in product(*substitutions):
+        chars = list(text)
+        for (idx, _), sub in zip(positions, combo):
+            chars[idx] = sub
+        results.add("".join(chars))
+
+    return list(results)

wl/patterns.py

@@ -0,0 +1,51 @@
+import re
+from itertools import product
+
+TOKEN_RE = re.compile(r"\{(\w+)\}")
+
+PATTERNS = [
+    "{name}{digits}",
+    "{name}{special}",
+    "{name}{digits}{special}",
+    "{Name}{digits}",
+    "{Name}{special}",
+    "{name}{year}",
+    "{word}{digits}",
+    "{digits}{name}",
+    "{name}{special}{digits}",
+    "{l33t}{digits}",
+    "{name}{word}",
+    "{word}{name}",
+    "{Name}{year}",
+    "{name}{special}{year}",
+    "{name}{keyword}",
+    "{keyword}{name}",
+    "{Keyword}{digits}",
+    "{name}{special}{keyword}",
+    "{keyword}{special}{digits}",
+]
+
+
+def generate_for_pattern(pattern, pools, min_len, max_len):
+    tokens = TOKEN_RE.findall(pattern)
+
+    token_lists = []
+    for t in tokens:
+        vals = pools.get(t)
+        if not vals:
+            return
+        token_lists.append(vals)
+
+    for combo in product(*token_lists):
+        pwd = pattern.format(**dict(zip(tokens, combo)))
+        if min_len <= len(pwd) <= max_len:
+            yield pwd
+
+
+def generate_all(pools, min_len=4, max_len=32):
+    seen = set()
+    for pattern in PATTERNS:
+        for pwd in generate_for_pattern(pattern, pools, min_len, max_len):
+            if pwd not in seen:
+                seen.add(pwd)
+                yield pwd

wl/tokens.py

@@ -0,0 +1,96 @@
+from .leet import apply_leet
+
+COMMON_DIGITS = [
+    "00", "000", "0000", "007", "069", "123", "234", "345",
+    "456", "567", "678", "789", "69", "88", "420", "666",
+    "777", "999", "111", "222", "333",
+]
+
+
+def build_name_variants(username):
+    variants = set()
+    u = username
+
+    variants.add(u)
+    variants.add(u.lower())
+    variants.add(u.upper())
+    variants.add(u.capitalize())
+
+    rev = u[::-1]
+    if len(rev) >= 3:
+        variants.add(rev)
+        variants.add(rev.capitalize())
+
+    max_trunc = min(5, len(u))
+    for i in range(3, max_trunc + 1):
+        variants.add(u[:i].lower())
+        variants.add(u[-i:].lower())
+
+    if len(u) >= 3:
+        variants.add(u.lower() * 2)
+
+    return [v for v in variants if v]
+
+
+def build_token_pools(
+    username, leet=False, keywords=None,
+    word_pool=None, birth_year=None, year_range=None,
+):
+    name_variants = build_name_variants(username)
+
+    pools = {}
+
+    pools["name"] = sorted(set(v.lower() for v in name_variants if v))
+
+    pools["Name"] = sorted(set(
+        v[0].upper() + v[1:].lower() if len(v) > 1 else v.upper()
+        for v in name_variants if v
+    ))
+
+    pools["NAME"] = sorted(set(v.upper() for v in name_variants if v))
+
+    if leet:
+        l33t_set = set()
+        for v in name_variants:
+            l33t_set.update(apply_leet(v))
+        pools["l33t"] = sorted(l33t_set)
+    else:
+        pools["l33t"] = []
+
+    digits = set()
+    for d in range(10):
+        digits.add(str(d))
+    for d in range(10, 100):
+        digits.add(str(d))
+    for seq in COMMON_DIGITS:
+        digits.add(seq)
+
+    if birth_year is not None:
+        digits.add(str(birth_year))
+    if year_range:
+        for y in range(year_range[0], year_range[1] + 1):
+            digits.add(str(y))
+
+    pools["digits"] = sorted(digits, key=lambda x: (len(x), x))
+
+    pools["special"] = ["!", "@", "#", "$", "%", "&", "*"]
+
+    years = set()
+    if birth_year is not None:
+        years.add(str(birth_year))
+    if year_range:
+        for y in range(year_range[0], year_range[1] + 1):
+            years.add(str(y))
+    pools["year"] = sorted(years, key=lambda x: int(x))
+
+    if word_pool:
+        pools["word"] = word_pool[:500]
+    else:
+        pools["word"] = []
+
+    kw = [k.lower() for k in (keywords or []) if k]
+    pools["keyword"] = sorted(set(kw))
+    pools["Keyword"] = sorted(set(k.capitalize() for k in kw))
+    pools["KEYWORD"] = sorted(set(k.upper() for k in kw))
+
+    return pools