FAQ

General Questions

Which module should I use?

  • ULP Cleaner: Validate and clean url:log:pass data
  • ULP Sorter: Categorize credentials by type (email, phone, username)
  • ULP Extractor: Extract credentials from archives and password files
  • LP Cleaner: Validate login:pass format with complexity rules
  • CIS Cleaner: Filter lines based on blacklist patterns
  • Anti-Public: Find unique credentials not in your database
  • Splitter: Break large files into chunks
  • Joiner: Merge multiple files
  • Deduper: Remove duplicate lines
  • Filter: Regex-based filtering

What’s the difference between ULP Cleaner and LP Cleaner?

  • ULP Cleaner: Handles url:log:pass format, validates URL structure
  • LP Cleaner: Handles log:pass format, focuses on password validation

Can I process multiple files at once?

Yes, most modules support:

  • Multiple input files
  • Directory scanning
  • Archive processing (ZIP, RAR, 7Z)

What file formats are supported?

Input formats:

  • Text files (.txt)
  • CSV files (.csv)
  • Archives (.zip, .rar, .7z) - including password-protected
  • Any plain text format

Performance

How do I optimize processing speed?

  1. Use SSD: Disk I/O is often the bottleneck
  2. Close other apps: Free up RAM and CPU
  3. Process in chunks: Split very large files first
  4. Enable Fast Search: Premium feature for faster ULP Sorter

How much RAM do I need?

Chronos uses streaming processing, so RAM requirements are minimal for most operations. Anti-Public mode loads the database to memory, so larger RAM helps. Low-memory mode is available for systems with limited RAM.

Can Chronos handle large files?

Yes! Streaming processing allows handling large files:

  • Minimal memory footprint
  • Only limited by storage space

Why is processing slow?

Common causes:

  1. HDD instead of SSD: Major bottleneck for large files
  2. Complex regex patterns: Simplify if possible
  3. Archive extraction: Nested archives take longer
  4. Antivirus scanning: May slow file operations

Modules

ULP Cleaner

What does “remove protocols” do?

Strips http://, https://, ftp:// from URLs, leaving clean domain:path format.

What are “spam/ads patterns”?

Pre-defined patterns for removing common advertising and spam URLs that pollute credential databases.

Why are credentials going to “bad” output?

Credentials are marked bad if:

  • URL format is invalid
  • Login or password is empty
  • Line doesn’t match url:log:pass format

ULP Sorter

How does automatic categorization work?

Analyzes login field format:

  • MailPass: email@domain format
  • UserPass: username format
  • PhonePass: phone number patterns
  • UrlLogPass: original format
  • LogPass: stripped URL format

Premium feature that uses optimized algorithms for faster pattern matching.

ULP Extractor

What files does it search for?

Default pattern: passw*.txt (passwords.txt, password.txt, etc.)

How deep does archive extraction go?

Recursive extraction up to 3 levels:

  • Archive → Archive → Archive → Files

Can I extract from password-protected archives?

Yes, provide the password in settings. Common passwords are tried automatically.

CIS Cleaner

What does CIS Cleaner do?

Filters lines based on blacklist patterns. Creates two outputs:

  • Cleaned: Lines that don’t match blacklist
  • Blacklisted: Lines that were removed

When should I use it?

Use CIS Cleaner to remove unwanted entries from your data based on pattern matching.

Anti-Public

What is “low-memory mode”?

Uses hashed comparisons instead of loading full database to memory. Slower but works on systems with limited RAM.

Can I update my database automatically?

Yes, enable “Update stored database” to add new unique findings to your reference database.

Why is Anti-Public slow?

Anti-Public needs to compare every line against your database:

  • Large databases require more memory
  • Use low-memory mode for systems with limited RAM
  • SSD significantly improves performance

LP Cleaner

What complexity options are available?

  • Min/Max length: Password length requirements
  • Uppercase/Lowercase: Required character types
  • Digits: Must contain numbers
  • Special characters: Must contain symbols

Should I use email validation?

Enable if you want only email:password format. Disable if usernames or other login types are acceptable.

Filter

What regex syntax is supported?

Full Rust regex syntax:

  • .* - any characters
  • \d+ - digits
  • [a-z] - character classes
  • ^ and $ - anchors

What does “invert filter” do?

Keeps lines that DON’T match the pattern instead of those that do.

Output

Where are results saved?

Default: chronos_output/ in your working directory

  • Each module creates appropriate subfolders
  • Timestamps identify processing runs

Can I customize output location?

Yes, specify custom output directory in module settings.

Troubleshooting

“Invalid UTF-8” errors

Your input file has encoding issues:

  1. Convert to UTF-8 using a text editor
  2. Use encoding detection tools
  3. Remove problematic lines

Processing hangs

  1. Check disk space
  2. Verify file isn’t locked by another process
  3. Try smaller test file first
  4. Check for infinite archive loops

Results are empty

  1. Verify input file format
  2. Check filter/pattern settings
  3. Review module configuration
  4. Test with sample data

Archive extraction fails

  1. Check archive isn’t corrupted
  2. Provide correct password
  3. Ensure enough disk space for extraction
  4. Update archive tools if needed

Best Practices

Workflow recommendations

  1. ULP Extractor → Extract from archives first
  2. ULP Cleaner → Validate and clean extracted data
  3. Deduper → Remove duplicates
  4. ULP Sorter → Categorize by type
  5. Anti-Public → Find unique entries

Handling very large files

  1. Use Splitter to break into manageable chunks
  2. Process chunks in parallel with multiple instances
  3. Use Joiner to combine results
  4. Use Deduper on final combined output

Preserving data integrity

  1. Always keep original files
  2. Process copies, not originals
  3. Verify output counts match expectations
  4. Use checksums for critical data