बाइनरी `dist/titus` पर होगी।

## त्वरित शुरुआत```bash
# Scan a file for secrets
titus scan path/to/file.txt

# Scan a directory for leaked credentials
titus scan path/to/directory

# Scan a public GitHub repository (no token needed)
titus scan github.com/org/repo

# Scan a public GitLab project (no token needed)
titus scan gitlab.com/namespace/project

# Scan git history for secrets in past commits
titus scan --git path/to/repo

# Scan a Docker / OCI image (pulled from a registry — no docker daemon required)
titus scan --docker alpine:latest

# Validate detected secrets against source APIs
titus scan path/to/code --validate

संगठन-व्यापी या उपयोगकर्ता-व्यापी स्कैनिंग के लिए, समर्पित सबकमांड्स का उपयोग करें:```bash
# Scan all public repos in a GitHub org
titus github --org kubernetes

# Scan all repos in a GitHub org with a token (private repos + higher rate limits)
titus github --org kubernetes --token $GITHUB_TOKEN

# Scan all repos for a GitHub user
titus github --user octocat

# Scan all projects in a GitLab group
titus gitlab scan --group mygroup --token $GITLAB_TOKEN

# Scan a single repo with git history (finds deleted secrets)
titus github owner/repo --git

प्रमाणीकरण आपके मौजूदा Docker / Podman कॉन्फ़िग (`~/.docker/config.json`, `${XDG_RUNTIME_DIR}/containers/auth.json`) का उपयोग करता है। निजी रजिस्ट्रियाँ जिन्हें नए लॉगिन की आवश्यकता होती है, उन्हें पहले `docker login` (या `podman login`, या `crane auth login`) से प्रमाणित किया जाना चाहिए — titus क्रेडेंशियल्स के लिए प्रॉम्प्ट नहीं करता।

### स्कैन परिणाम देखना

पिछले स्कैन से निष्कर्षों को दोबारा पढ़ने के लिए `report` का उपयोग करें:```bash
# Human-readable summary of detected secrets
titus report

# JSON output for programmatic processing
titus report --format json

# SARIF output for CI/CD integration with GitHub Advanced Security
titus report --format sarif

# Report from a specific datastore
titus report --datastore path/to/titus.ds

### पता लगाए गए Secrets का सत्यापन

स्कैन के दौरान `--validate` पास करें ताकि पता लगाए गए secrets को उनके स्रोत APIs के विरुद्ध जाँचा जा सके:```bash
titus scan path/to/code --validate

### बाइनरी फ़ाइलों से सीक्रेट्स निकालना

Titus बाइनरी फ़ाइल फ़ॉर्मेट्स से टेक्स्ट निकाल सकता है और सामग्री में सीक्रेट्स की स्कैनिंग कर सकता है:```bash
# Extract and scan all supported binary formats
titus scan path/to/files --extract=all

# Target specific formats
titus scan path/to/files --extract=xlsx,docx,pdf,zip

SQLite डेटाबेस के लिए, Titus सभी तालिकाओं से टेक्स्ट निकालता है (डिफ़ॉल्ट रूप से प्रति तालिका 1000 पंक्तियाँ)। समायोजित करने के लिए `--sqlite-row-limit` का उपयोग करें:```bash
# Full dump of all SQLite tables (no row limit)
titus scan path/to/files --extract=all --sqlite-row-limit 0

# Custom row limit per table
titus scan path/to/files --extract=all --sqlite-row-limit 5000

Titus में AWS क्रेडेंशियल्स, GitHub PATs, और Slack टोकन्स के लिए YAML स्कोरर्स शामिल हैं, साथ ही Go-आधारित SDK स्कोरर्स भी हैं जो `--score-scope` सक्षम होने पर लाइव IAM पॉलिसी एन्यूमरेशन (AWS) और रिपॉज़िटरी अनुमति जाँच (GitHub fine-grained PATs) करते हैं।

पूर्ण संदर्भ के लिए [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/main/docs/scoring.md) देखें: severity tiers, modifier kinds, अंतर्निहित स्कोरर विवरण, और अपने स्वयं के YAML या Go स्कोरर्स कैसे लिखें।

## Secrets Detection के लिए Go Library

Titus को एक Go library के रूप में import किया जा सकता है ताकि आप अपने स्वयं के टूल्स और pipelines में secrets detection जोड़ सकें।```bash
go get github.com/praetorian-inc/titus

# पुराने सिस्टम का पूर्ण सुरक्षा ऑडिट
python3 cve_2025_55182.py --target https://legacy-app.company.com --verbose

# परिणाम: सभी कमजोरियों की पहचान करें और सुधार को प्राथमिकता दें

# बग बाउंटी कार्यक्रम के लिए त्वरित जाँच
python3 cve_2025_55182.py --target https://target.com --output bounty_report.json

# परिणाम: सत्यापन के लिए साक्ष्य के साथ पेशेवर रिपोर्ट

# अनुपालन आवश्यकताओं के लिए नियमित सुरक्षा स्कैन
python3 cve_2025_55182.py --target https://production.company.com --output compliance_audit.json

# परिणाम: अनुपालन टीमों के लिए विस्तृत ऑडिट ट्रेल

# GitHub Actions वर्कफ़्लो उदाहरण
name: Security Scan
on: [push, pull_request]

jobs:
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Run CVE-2025-55182 Scanner
        run: |
          python3 cve_2025_55182.py --target ${{ secrets.TARGET_URL }} --output scan_results.json
      - name: Upload Results
        uses: actions/upload-artifact@v3
        with:
          name: security-scan-results
          path: scan_results.json

# सुरक्षा अवधारणाओं को प्रदर्शित करने के लिए नियंत्रित वातावरण में परीक्षण
python3 cve_2025_55182.py --target http://localhost:3000 --verbose

# परिणाम: सुरक्षा कमजोरियों के बारे में जानें

╔══════════════════════════════════════════════════════════════╗
║  CVE-2025-55182 सुरक्षा स्कैनर v1.0.0                        ║
║  React Server Components RCE कमजोरी स्कैनर                   ║
╚══════════════════════════════════════════════════════════════╝

[*] लक्ष्य: https://example.com
[*] स्कैन शुरू हो रहा है...

[+] चरण 1: लक्ष्य पहुँच की जाँच कर रहा है... ✓
[+] चरण 2: React Server Components का पता लगा रहा है... ✓
[+] चरण 3: सर्वर क्रियाओं की गणना कर रहा है... ✓
[+] चरण 4: कमजोर पेलोड का परीक्षण कर रहा है... ✓
[+] चरण 5: सफल शोषण की पुष्टि कर रहा है... ✓

[!] कमजोरी का पता चला!
    ├─ प्रकार: रिमोट कोड निष्पादन (RCE)
    ├─ गंभीरता: महत्वपूर्ण (CVSS 10.0)
    ├─ CVE: CVE-2025-55182
    └─ प्रभावित: React Server Components

[*] स्कैन पूरा हुआ। परिणाम scan_results.json में सहेजे गए

{
  "scan_info": {
    "target": "https://example.com",
    "timestamp": "2025-01-15T10:30:00Z",
    "scanner_version": "1.0.0",
    "duration_seconds": 12.5
  },
  "vulnerability": {
    "cve_id": "CVE-2025-55182",
    "severity": "CRITICAL",
    "cvss_score": 10.0,
    "type": "Remote Code Execution",
    "affected_component": "React Server Components",
    "description": "React Server Components में अनपेक्षित सर्वर क्रियाओं के माध्यम से दूरस्थ कोड निष्पादन की अनुमति देने वाली कमजोरी"
  },
  "findings": {
    "vulnerable": true,
    "confidence": "HIGH",
    "evidence": {
      "detection_method": "Server Action enumeration",
      "exploitation_successful": true,
      "payload_used": "[REDACTED]"
    }
  },
  "recommendations": [
    "तत्काल: React और Next.js को नवीनतम संस्करण में अपडेट करें",
    "अल्पकालिक: संदिग्ध सर्वर क्रियाओं की निगरानी लागू करें",
    "दीर्घकालिक: नियमित सुरक्षा ऑडिट लागू करें"
  ]
}

# कस्टम पेलोड बनाएँ
from cve_2025_55182 import ExploitBuilder

builder = ExploitBuilder()
payload = builder.create_payload(
    command="whoami",
    encoding="base64",
    obfuscation=True
)

# स्कैनर को अपने एप्लिकेशन में एकीकृत करें
from cve_2025_55182 import CVEScanner

scanner = CVEScanner(target="https://example.com")
results = scanner.scan()

if results.vulnerable:
    send_alert(results)

"github.com/praetorian-inc/titus"

// Scan a string for API keys, tokens, and credentials
matches, err := scanner.ScanString(`aws_access_key_id = AKIAIOSFODNN7EXAMPLE`)
if err != nil {
    log.Fatal(err)
}

for _, match := range matches {
    fmt.Printf("%s (rule: %s) at line %d\n",
        match.RuleName, match.RuleID,
        match.Location.SourceSpan.Start.Line,
    )
}

लाइब्रेरी बाइट्स और फ़ाइलों को स्कैन करना, पाए गए सीक्रेट्स को मान्य करना, और कस्टम नियम लोड करना भी सपोर्ट करती है:```go
// Scan a file for leaked credentials
matches, err := scanner.ScanFile("/path/to/config.json")

// Enable validation to check if detected secrets are live
scanner, err := titus.NewScanner(titus.WithValidation())

// Load custom detection rules for organization-specific secrets
rules, err := titus.LoadRulesFromFile("/path/to/rules.yaml")
scanner, err := titus.NewScanner(titus.WithRules(rules))

फिर Burp Suite में Extensions > Add के अंतर्गत `dist/titus-burp-1.0.0-all.jar` लोड करें।

#### Windows (Releases से डाउनलोड करें)

1. [Releases](../../releases) से `titus-windows-amd64.exe` और `titus-burp-<version>.jar` डाउनलोड करें
2. Titus निर्देशिका बनाएं और बाइनरी इंस्टॉल करें:   ```powershell
   mkdir %USERPROFILE%\.titus
   copy titus-windows-amd64.exe %USERPROFILE%\.titus\titus.exe

1. `chrome://extensions/` पर नेविगेट करें
2. **Developer mode** सक्षम करें
3. **Load unpacked** पर क्लिक करें और `extension/` डायरेक्टरी चुनें

### ब्राउज़र एक्सटेंशन विशेषताएँ

- API keys और tokens के लिए inline और external JavaScript और stylesheets को स्कैन करता है
- लीक हुए credentials के लिए localStorage और sessionStorage को स्कैन करता है
- व्यापक secret detection के लिए वैकल्पिक network response capture
- परिणाम popup और dashboard में प्रदर्शित होते हैं

<img width="1719" height="958" alt="Titus Chrome extension popup showing detected secrets on a web page" src="https://assets.kitploit.com/production/public/readmes/11969/057a24e2746412ceabe1aac0292a2de463de1efee5bca2489ca34b59d8b0dc2c.png" />

<img width="1744" height="827" alt="Titus Chrome extension dashboard with aggregated secret detection results" src="https://assets.kitploit.com/production/public/readmes/11969/265d972fadcc7f212944d7a1d8fd58a43446e7199d1209900e83b96a546ffb00.png" />

### सुरक्षा सूचना

ब्राउज़र एक्सटेंशन external resources को स्कैन करने के लिए विज़िट किए गए पेजों से Content Security Policy और CORS headers हटा देता है। एक्सटेंशन के सक्रिय रहने के दौरान यह आपके द्वारा विज़िट की जाने वाली साइटों की सुरक्षा स्थिति को कमज़ोर करता है। **केवल सक्रिय सुरक्षा परीक्षण के दौरान ही सक्षम करें।**

## सोर्स से बिल्ड करना

### मानक बिल्ड (Vectorscan-accelerated)

डिफ़ॉल्ट रूप से Titus SIMD-accelerated regex matching के लिए [Vectorscan](https://github.com/VectorCamp/vectorscan) (ARM) / [Hyperscan](https://github.com/intel/hyperscan) (x86) के साथ कंपाइल होता है। इसके लिए CGO, C लाइब्रेरी, और `pkg-config` (जिसका उपयोग cgo लाइब्रेरी को खोजने के लिए करता है) की आवश्यकता होती है। `make build` इनकी जाँच करता है और Homebrew / apt / dnf के माध्यम से किसी भी अनुपलब्ध चीज़ को इंस्टॉल करने का प्रयास करता है:```bash
# Build the CLI binary with vectorscan acceleration (outputs to dist/titus)
make build

# Build the Burp Suite extension JAR
make build-burp

# Build the Chrome browser extension
make build-extension

# Run unit tests
make test

# Run integration tests
make integration-test

यदि आप सीधे `go build` को invoke करते हैं (उदाहरण के लिए, Titus को embed करते समय), तो tag पास करें और CGO enable करें:```bash
# macOS (Homebrew) — adjust PKG_CONFIG_PATH to your installed version
CGO_ENABLED=1 PKG_CONFIG_PATH="$(brew --prefix vectorscan)/lib/pkgconfig" \
  go build -tags vectorscan -o dist/titus ./cmd/titus

# Linux (system-installed)
CGO_ENABLED=1 go build -tags vectorscan -o dist/titus ./cmd/titus

#### स्वचालित Hyperscan डेटाबेस कैश

Titus प्रत्येक सफलतापूर्वक संकलित Hyperscan डेटाबेस को स्वचालित रूप से मानक उपयोगकर्ता कैश में क्रमबद्ध (serialize) करता है। बाद के स्कैनर इंस्टेंस जिनके पास बिल्कुल समान क्रमबद्ध नियम और फ़्लैग होते हैं, वे उस डेटाबेस को फिर से संकलित करने के बजाय लोड कर लेते हैं। कैश फ़ाइल Hyperscan के `hs_serialize_database` द्वारा उत्पन्न असंशोधित बाइट स्ट्रीम है, और Titus इसे `hs_deserialize_database` के साथ लोड करता है।

`TITUS_CACHE_DIR` कैश स्थान को ओवरराइड कर सकता है। कैश लेखन परमाणु (atomic) और best-effort होते हैं: अनुपलब्ध या read-only कैश स्कैनिंग को नहीं रोकता। अनुपस्थित, दूषित, असंगत, या भिन्न फ़िंगरप्रिंट वाला डेटाबेस सामान्य संकलन को ट्रिगर करता है और जब संभव हो तो कैश को रीफ़्रेश करता है।

क्रमबद्ध डेटाबेस आर्किटेक्चर-, CPU-फ़ीचर-, और Hyperscan-संस्करण-विशिष्ट होते हैं। Titus डीसीरियलाइज़ करते समय असंगत प्रविष्टियों का पता लगाता है और उन्हें वर्तमान रनटाइम के लिए संकलित डेटाबेस से बदल देता है।

## योगदान

योगदान का स्वागत है! Titus में योगदान कैसे करें, इसके दिशानिर्देशों के लिए [CONTRIBUTING.md](https://github.com/praetorian-inc/titus/blob/main/CONTRIBUTING.md) देखें।

## लाइसेंस

Apache License 2.0 — [LICENSE](https://github.com/praetorian-inc/titus/blob/main/LICENSE) देखें।

डिटेक्शन नियम [NoseyParker](https://github.com/praetorian-inc/noseyparker) (Praetorian Security, Inc.) और [Kingfisher](https://github.com/mongodb/kingfisher) (MongoDB, Inc.) से व्युत्पन्न हैं, दोनों Apache 2.0 के अंतर्गत लाइसेंस प्राप्त हैं। पूर्ण श्रेय के लिए [NOTICE](https://github.com/praetorian-inc/titus/blob/main/NOTICE) देखें।