v0.4.0: smart domain matching

Boundary-aware domain detection — matches subdomains, URLs, and emails
while rejecting false positives. Output always user:pass.

Author: sinescode

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "ulpExtractor"
-version = "0.3.1"
+version = "0.4.0"
 edition = "2021"
 
 [dependencies]

Cargo.toml

@@ -1,11 +1,12 @@
 # ulpExtractor
 
-**Fast domain credential extractor** — parse large `domain:user:pass` lists and extract matching credentials by domain.
+**Fast domain credential extractor** — parse large `url:user:pass` lists and extract matching credentials by domain.
 
 Built in Rust with a styled CLI, interactive prompt mode, and multi-file batch scanning.
 
 ## Features
 
+- **Smart domain matching** — boundary-aware, matches subdomains (`www.netflix.com` matches `netflix.com`), URLs (`https://deepseek.com/path:user:pass`), and emails (`user@domain.com`); rejects false positives like `mydeepseek.com`
 - **Styled CLI** — boxed header, colored fields, live progress bar with real-time match counter
 - **Interactive mode** — guided prompts when run with no arguments, same visual design as CLI
 - **Multi-file scan** (`-a`) — scan all files in a directory matching given extensions
@@ -67,14 +68,26 @@ ulpExtractor -d netflix.com -a --dir ./data -o results.txt -t 8
 
 ## Input Format
 
-Each line should be `domain<divider>user<divider>password`:
+Lines use `<url_or_domain><divider><user><divider><password>`. The domain can appear anywhere in the URL portion — bare, as a subdomain, inside an `https://` URL with paths, or in an email:
 
 ```
-fiverr.com:estheticdesigns:Ahmadraza
-google.com:user@gmail.com:password123
+netflix.com:john:secret123
+www.netflix.com:user@mail.com:pass456
+https://platform.deepseek.com/login:admin:pass789
+user@example.com:somepass
 ```
 
-Output is `user<divider>password` for matching lines only.
+Matching is **boundary-aware** — `deepseek.com` matches `platform.deepseek.com` but NOT `mydeepseek.com`.
+
+Output is `user<divider>password` for matching lines only. Lines without a user portion (`domain:pass`) are skipped.
+
+## Upgrade Notes (v0.3.x → v0.4.0)
+
+v0.4.0 introduces **smart domain matching**:
+- **Subdomain matching**: `netflix.com` now matches `www.netflix.com`, `login.netflix.com`, etc.
+- **URL support**: URLs like `https://domain.com/path:user:pass` are parsed correctly
+- **Boundary detection**: `deepseek.com` no longer false-matches `mydeepseek.com`
+- **Output format**: always `user:pass` — lines without a user portion are skipped
 
 ## Build from Source
 

README.md

@@ -5,7 +5,7 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::time::Instant;
 
-use memchr::memchr;
+use memchr::{memchr, memrchr};
 use memmap2::Mmap;
 use rayon::prelude::*;
 
@@ -28,6 +28,43 @@ pub struct ExtractResult {
 }
 
 /// Find all files in `dir` matching any of the given extensions.
+
+/// Find `domain` inside `user_part` at a domain boundary. Returns the end
+/// position of the match so the caller can slice the remainder (user:pass).
+/// Handles URLs, emails, and bare domains:
+///   "platform.deepseek.com"  ← subdomain (left boundary: '.')
+///   "https://deepseek.com/login"  ← URL with path (left: '://', right: '/')
+///   "user@deepseek.com"      ← email (left boundary: '@')
+///   "deepseek.com:user"      ← username (right boundary: ':')
+/// Rejects partial-domain matches like "mydeepseek.com" (no boundary before).
+fn domain_end(user_part: &[u8], domain: &[u8]) -> Option<usize> {
+    if domain.is_empty() || user_part.len() < domain.len() {
+        return None;
+    }
+    if user_part == domain {
+        return Some(domain.len());
+    }
+    let d0 = domain[0];
+    let mut start = 0;
+    while let Some(pos) = memchr(d0, &user_part[start..]) {
+        let abs = start + pos;
+        let end = abs + domain.len();
+        start = abs + 1;
+        if end > user_part.len() {
+            continue;
+        }
+        if &user_part[abs..end] != domain {
+            continue;
+        }
+        let left_ok = abs == 0 || matches!(user_part[abs - 1], b'.' | b'@' | b'/' | b':');
+        let right_ok = end >= user_part.len() || matches!(user_part[end], b'/' | b':');
+        if left_ok && right_ok {
+            return Some(end);
+        }
+    }
+    None
+}
+
 pub fn find_files(dir: &Path, extensions: &[String]) -> std::io::Result<Vec<PathBuf>> {
     let exts: Vec<String> = extensions
         .iter()
@@ -171,9 +208,17 @@ pub fn extract_multi(
                             line = &line[..line.len() - 1];
                         }
 
-                        if let Some(div_pos) = memchr(div, line) {
-                            if &line[..div_pos] == domain {
-                                local.push(line[div_pos + 1..].to_vec());
+                        if let Some(div_pos) = memrchr(div, line) {
+                            let user_part = &line[..div_pos];
+                            if let Some(end_pos) = domain_end(user_part, domain) {
+                                let after = &user_part[end_pos..];
+                                // must have user portion: url:user:pass (at least 3 parts)
+                                if let Some(last_colon) = memrchr(div, after) {
+                                    let mut out = after[last_colon + 1..].to_vec();
+                                    out.push(div);
+                                    out.extend_from_slice(&line[div_pos + 1..]);
+                                    local.push(out);
+                                }
                             }
                         }
 

src/extractor.rs

@@ -63,7 +63,7 @@ fn print_header() {
     let top = "┌".to_string() + &"─".repeat(w.saturating_sub(2)) + "┐";
     let bot = "└".to_string() + &"─".repeat(w.saturating_sub(2)) + "┘";
 
-    let title = " ulpExtractor v0.3.1 ";
+    let title = " ulpExtractor v0.4.0 ";
     let subtitle = " Domain credential extractor ";
 
     let pad = (w.saturating_sub(title.len())) / 2;