Titus: उच्च-प्रदर्शन गुप्त स्कैनर

Titus एक उच्च-प्रदर्शन गुप्त स्कैनर है जो स्रोत कोड, फ़ाइलों और git इतिहास में क्रेडेंशियल्स, API कुंजियाँ और टोकन का पता लगाता है। यह NoseyParker और Kingfisher से लिए गए 487 डिटेक्शन नियमों के साथ आता है, जो सैकड़ों सेवाओं और क्रेडेंशियल प्रकारों को कवर करते हैं। Titus CLI, एक Go लाइब्रेरी, एक Burp Suite एक्सटेंशन और एक Chrome ब्राउज़र एक्सटेंशन के रूप में चलता है — ये सभी एक ही डिटेक्शन इंजन और नियम सेट साझा करते हैं।

सुरक्षा इंजीनियरों, प्रवेश परीक्षकों और DevSecOps टीमों के लिए बनाया गया, Titus Hyperscan/Vectorscan-त्वरित regex मिलान को लाइव क्रेडेंशियल सत्यापन के साथ जोड़ता है ताकि आपके संपूर्ण कोडबेस में लीक हुए गुप्तों को खोजा और सत्यापित किया जा सके।

विषय सूची

• Titus क्यों?
• स्थापना
• त्वरित प्रारंभ
• स्कैनिंग विकल्प
• खोज स्कोरिंग
• Go लाइब्रेरी
• Burp Suite एक्सटेंशन
• ब्राउज़र एक्सटेंशन
• स्रोत से निर्माण
• योगदान
• लाइसेंस

Titus क्यों?

• त्वरित गुप्त स्कैनिंग: Hyperscan/Vectorscan द्वारा त्वरित Regex मिलान जब उपलब्ध हो, किसी भी प्लेटफॉर्म पर पोर्टेबिलिटी के लिए शुद्ध-Go फ़ॉलबैक के साथ।
• व्यापक क्रेडेंशियल डिटेक्शन कवरेज: 487 नियम AWS, GCP, Azure, GitHub, Slack, डेटाबेस, CI/CD सिस्टम और सैकड़ों अन्य सेवाओं के लिए API कुंजियाँ, टोकन और क्रेडेंशियल्स का पता लगाते हैं।
• लाइव गुप्त सत्यापन: पाए गए गुप्तों को उनके स्रोत APIs के विरुद्ध जांचा जाता है ताकि पुष्टि की जा सके कि वे सक्रिय हैं या नहीं, जिससे झूठी सकारात्मकता कम होती है और सुधार को प्राथमिकता दी जाती है।
• जोखिम-आधारित गंभीरता स्कोरिंग: प्रत्येक खोज को एक संख्यात्मक स्कोर (0–100) और गंभीरता स्तर (info → critical) प्राप्त होता है। स्कोर स्थिर नियम मेटाडेटा, कोड-पहुंच संदर्भ और लाइव API कॉल द्वारा ट्यून किए जाते हैं जो क्रेडेंशियल के वास्तविक विस्फोट दायरे को मापते हैं — ताकि सबसे खतरनाक खोजें हमेशा पहले सामने आएं।
• कंटेनर इमेज स्कैनिंग: किसी भी रजिस्ट्री, tarball या OCI लेआउट निर्देशिका से सीधे Docker और OCI इमेज स्कैन करें — किसी Docker डेमन या बाइनरी की आवश्यकता नहीं है।
• प्रत्येक वर्कफ़्लो के लिए एकाधिक इंटरफ़ेस: CLI से स्कैन करें, Go लाइब्रेरी के रूप में एम्बेड करें, Burp Suite में HTTP ट्रैफ़िक को निष्क्रिय रूप से स्कैन करें, या एप्लिकेशन सुरक्षा परीक्षण के दौरान Chrome में वेब पेज स्कैन करें।
• बाइनरी फ़ाइल निष्कर्षण: Office दस्तावेज़ों, PDFs, संग्रह (zip, tar, 7z), मोबाइल ऐप्स (APK, IPA), ब्राउज़र एक्सटेंशन और अधिक से गुप्तों को निकालें और स्कैन करें।

स्थापना

पूर्व-निर्मित बाइनरी को Releases पृष्ठ से डाउनलोड करें, या स्रोत से निर्माण करें:```bash make build

The binary will be at `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

परिणाम एक डेटास्टोर (titus.ds डिफ़ॉल्ट रूप से) में लिखे जाते हैं और कंसोल पर मुद्रित किए जाते हैं।

स्कैनिंग विकल्प

GitHub और GitLab स्कैनिंग

सार्वजनिक रिपॉजिटरी को URL द्वारा सीधे स्कैन करें — कोई API टोकन आवश्यक नहीं है:```bash

Scan a GitHub repository

titus scan github.com/kubernetes/kubernetes

Scan a GitLab project

titus scan gitlab.com/gitlab-org/cli

Full URLs work too

titus scan https://github.com/org/repo titus scan https://gitlab.com/namespace/project.git

संगठन-व्यापी या उपयोगकर्ता-व्यापी स्कैनिंग के लिए, समर्पित उप-कमांड का उपयोग करें:```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

टोकन सार्वजनिक रिपॉजिटरी के लिए वैकल्पिक हैं। निजी रिपॉजिटरी एक्सेस और उच्च API दर सीमाओं के लिए GITHUB_TOKEN या GITLAB_TOKEN सेट करें (या --token का उपयोग करें)।

Docker / OCI इमेज स्कैनिंग

कंटेनर इमेज को सीधे स्कैन करें — कोई docker daemon, कोई docker बाइनरी आवश्यक नहीं। Titus किसी भी OCI रजिस्ट्री से HTTPS के माध्यम से इमेज को सीधे खींचता है (~/.docker/config.json से क्रेडेंशियल का उपयोग करके), या स्थानीय docker save टारबॉल या OCI इमेज लेआउट डायरेक्टरी से इमेज पढ़ता है। फिर यह इमेज मेनिफेस्ट/कॉन्फिग मेटाडेटा और प्रत्येक लेयर में प्रत्येक नियमित फ़ाइल को स्कैन करता है, जिसमें बाद की लेयरों द्वारा हटाई गई निचली-लेयर फ़ाइलें भी शामिल हैं (क्योंकि गुप्त जानकारी इमेज हिस्ट्री से पुनर्प्राप्त की जा सकती है)।```bash

Pull from a registry and scan

titus scan --docker alpine:latest titus scan docker://ghcr.io/owner/repo:tag

Scan an image saved to a tarball:

docker save my-app:latest -o my-app.tar

podman save my-app:latest -o my-app.tar

titus scan --docker ./my-app.tar

Scan an OCI image layout directory:

docker buildx build --output type=oci,dest=./img/ .

skopeo copy docker://my-app:latest oci:./img:latest

titus scan --docker ./img/

प्रमाणीकरण आपके मौजूदा 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

आप स्कैन समय पर आउटपुट प्रारूप को --format के साथ नियंत्रित कर सकते हैं:```bash titus scan path/to/code --format json

### पता लगाए गए रहस्यों को मान्य करना

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

सत्यापन एक साथ चलता है (डिफ़ॉल्ट रूप से 4 वर्कर्स, --validate-workers से कॉन्फ़िगरेबल) और प्रत्येक खोज को पुष्टि, अस्वीकृत या अज्ञात के रूप में चिह्नित करता है।

फ़िल्टरिंग डिटेक्शन नियम```bash

List all available detection rules

titus rules list

Scan with only specific rules (e.g., AWS and GCP credentials)

titus scan path/to/code --rules-include "aws,gcp"

Exclude rules by pattern

titus scan path/to/code --rules-exclude "kingfisher.generic"

Use a custom rules file for organization-specific secrets

titus scan path/to/code --rules path/to/custom-rules.yaml

Opt in to rules marked noisy: true (high false-positive rate, off by default)

titus scan path/to/code --include-noisy

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

टाइटस बाइनरी फ़ाइल स्वरूपों से टेक्स्ट निकाल सकता है और सामग्री को रहस्यों के लिए स्कैन कर सकता है:```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

समर्थित प्रारूपों में Office दस्तावेज़ (xlsx, docx, pptx, odp, ods, odt), PDFs, Jupyter notebooks, SQLite डेटाबेस, ईमेल (eml, rtf), और आर्काइव (zip, tar, tar.gz, jar, war, ear, apk, ipa, crx, xpi, 7z) शामिल हैं। आर्काइव को कॉन्फ़िगरेबल गहराई और आकार सीमाओं तक पुनरावर्ती रूप से निकाला जाता है।```bash

Tune extraction limits for large codebases

titus scan path/to/files --extract=all
--extract-max-size 10MB
--extract-max-total 100MB
--extract-max-depth 5

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 उत्पन्न करता है, उसमें 0–100 का एक संख्यात्मक स्कोर और एक गंभीरता स्तर होता है:

स्कोर नियम के base_score से शुरू होते हैं और संशोधक — ऐसी स्थितियाँ जो क्रेडेंशियल के बारे में ज्ञात जानकारी के आधार पर स्कोर को बढ़ाती या घटाती हैं — द्वारा समायोजित किए जाते हैं:```bash

Score findings using static rule metadata only (no network calls)

titus scan path/to/code

Score findings AND make live API calls to verify credential blast radius

(calls AWS STS/IAM and GitHub API for supported credential types)

titus scan path/to/code --score-scope

Override the accessibility context (default: auto-detected from git remote)

titus scan path/to/code --accessibility public # no penalty for public repos titus scan path/to/code --accessibility private # -25 penalty (default for local scans)

टाइटस 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/HEAD/docs/scoring.md) देखें: गंभीरता स्तर, संशोधक प्रकार, अंतर्निहित स्कोरर विवरण, और अपने स्वयं के YAML या Go स्कोरर कैसे लिखें।

## सीक्रेट्स डिटेक्शन के लिए Go लाइब्रेरी

टाइटस को Go लाइब्रेरी के रूप में आयात किया जा सकता है ताकि आप अपने स्वयं के टूल्स और पाइपलाइनों में सीक्रेट्स डिटेक्शन जोड़ सकें।```bash
go get github.com/praetorian-inc/titus

INPUT:```go package main

import ( "fmt" "log"

"github.com/praetorian-inc/titus"

)

func main() { // Initialize the secrets scanner with default rules scanner, err := titus.NewScanner() if err != nil { log.Fatal(err) } defer scanner.Close()

// 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))

देखें docs/library-usage.md पूर्ण API संदर्भ, समवर्ती पैटर्न और अधिक उदाहरणों के लिए।

गुप्त स्कैनिंग के लिए Burp Suite एक्सटेंशन

Burp एक्सटेंशन प्रॉक्सी ट्रैफिक और सक्रिय पैठ परीक्षण के दौरान HTTP प्रतिक्रियाओं में गुप्त डेटा स्कैन करता है।

सेटअप

Linux / macOS (स्रोत से निर्माण करें)```bash

Build the CLI and Burp extension JAR, install CLI to ~/.titus/

make install-burp

फिर बर्प सूट में एक्सटेंशन > जोड़ें के अंतर्गत `dist/titus-burp-1.0.0-all.jar` लोड करें।

#### विंडोज़ (रिलीज़ से डाउनलोड करें)

1. [रिलीज़](https://raw.githubusercontent.com/praetorian-inc/releases) से `titus-windows-amd64.exe` और `titus-burp-<version>.jar` डाउनलोड करें
2. Titus निर्देशिका बनाएं और बाइनरी स्थापित करें:   ```powershell
   mkdir %USERPROFILE%\.titus
   copy titus-windows-amd64.exe %USERPROFILE%\.titus\titus.exe

3. बर्प सूट में एक्सटेंशन्स > ऐड के अंतर्गत JAR लोड करें

Linux / macOS (रिलीज़ से डाउनलोड करें)

1. अपने प्लेटफ़ॉर्म के लिए उपयुक्त बाइनरी और titus-burp-<version>.jar को रिलीज़ से डाउनलोड करें:
   • titus-linux-amd64 या titus-linux-arm64 लिनक्स के लिए
   • titus-darwin-amd64 या titus-darwin-arm64 macOS के लिए
2. बाइनरी स्थापित करें: ```bash mkdir -p ~/.titus cp titus- ~/.titus/titus chmod +x ~/.titus/titus
   root@kitploit:~

3. JAR को Burp Suite में Extensions > Add के अंतर्गत लोड करें

यह एक्सटेंशन पृष्ठभूमि में एक titus serve प्रक्रिया लॉन्च करता है और NDJSON का उपयोग करके stdin/stdout पर संचार करता है। डिटेक्शन नियम स्टार्टअप पर एक बार लोड किए जाते हैं।

Burp एक्सटेंशन विशेषताएँ

• निष्क्रिय गुप्त स्कैनिंग: Burp के माध्यम से प्रवाहित होने वाले प्रॉक्सी ट्रैफिक को स्वचालित रूप से स्कैन करता है
• सक्रिय गुप्त स्कैनिंग: चयनित अनुरोधों को स्कैन करने के लिए राइट-क्लिक संदर्भ मेनू
• डीडुप्लीकेशन: एक ही गुप्त जानकारी प्रति एंगेजमेंट केवल एक बार रिपोर्ट की जाती है
• फ़ास्ट-पथ फ़िल्टरिंग: बाइनरी सामग्री, छवियाँ और गैर-पाठ्य प्रतिक्रियाओं को छोड़ दिया जाता है
• लाइव क्रेडेंशियल सत्यापन: पता लगाए गए गुप्त जानकारियों को स्रोत APIs के विरुद्ध जाँच कर पुष्टि करता है कि वे सक्रिय हैं या नहीं
• फ़ॉल्स पॉज़िटिव प्रबंधन: शोर को फ़िल्टर करने के लिए निष्कर्षों को फ़ॉल्स पॉज़िटिव के रूप में चिह्नित करें
• गंभीरता वर्गीकरण: जोखिम के अनुसार रंग-कोडित निष्कर्ष (उच्च/मध्यम/निम्न)
• निर्यात: रिपोर्टिंग के लिए निष्कर्षों को JSON में सहेजें

Burp एक्सटेंशन इंटरफ़ेस

यह एक्सटेंशन Burp में तीन उप-टैब के साथ एक Titus टैब जोड़ता है:

गुप्त जानकारियाँ: प्रकार, होस्ट और सत्यापन स्थिति द्वारा फ़िल्टरिंग के साथ सभी पता लगाए गए गुप्त जानकारियाँ।

Titus Burp Suite extension secrets tab showing detected API keys and credentials with validation status

• सत्यापन स्थिति: दिखाता है कि गुप्त जानकारियाँ जाँची गई हैं या नहीं (सक्रिय/निष्क्रिय/अज्ञात)
• फ़िल्टरिंग: विशिष्ट मानों द्वारा फ़िल्टर करने के लिए प्रकार, होस्ट या स्थिति बटन पर क्लिक करें; पाठ और रेगेक्स मिलान के लिए खोज बॉक्स का उपयोग करें
• बल्क क्रियाएँ: बैच में सत्यापित करने या फ़ॉल्स पॉज़िटिव के रूप में चिह्नित करने के लिए कई पंक्तियाँ चुनें
• गुप्त जानकारी विवरण पैनल: देखने के लिए कोई निष्कर्ष चुनें:
  • विवरण: नियम जानकारी, श्रेणी, पूर्ण गुप्त मान, पहली बार देखे जाने का टाइमस्टैम्प
  • URLs: वे सभी स्थान जहाँ यह गुप्त जानकारी मिली
  • सत्यापन: विवरण के साथ सत्यापन परिणाम (जैसे, AWS खाता ID, ARN)
  • अनुरोध/प्रतिक्रिया: गुप्त जानकारी के साथ हाइलाइट किया गया पूरा HTTP ट्रैफ़िक

आँकड़े: प्रकार और होस्ट के अनुसार समूहित गुप्त जानकारियों का समग्र दृश्य।

• सारांश: कुल अद्वितीय गुप्त जानकारियाँ, स्कैन किए गए होस्ट, सत्यापन विवरण (सक्रिय बनाम निष्क्रिय), और फ़ॉल्स पॉज़िटिव गणना
• प्रकार के अनुसार गुप्त जानकारियाँ: श्रेणी वर्गीकरण के साथ प्रत्येक गुप्त प्रकार की गणना
• होस्ट के अनुसार गुप्त जानकारियाँ: प्रति होस्ट मिली गुप्त जानकारियों की संख्या

सेटिंग्स: स्कैनिंग विकल्प, सत्यापन और गंभीरता मैपिंग कॉन्फ़िगर करें।

Titus Burp Suite extension settings tab with scan configuration options

• स्कैन सेटिंग्स:
  • निष्क्रिय स्कैनिंग: सभी प्रॉक्सी ट्रैफ़िक को स्वचालित रूप से स्कैन करें (डिफ़ॉल्ट रूप से सक्षम)
  • अनुरोध बॉडी स्कैनिंग: एप्लिकेशन द्वारा भेजे गए गुप्त जानकारियों के लिए अनुरोध बॉडी भी स्कैन करें
  • सत्यापन: स्रोत APIs के विरुद्ध गुप्त जानकारियों की जाँच करने के लिए सक्षम करें (आउटबाउंड अनुरोध करता है और अलर्ट ट्रिगर कर सकता है)
• स्कैन पैरामीटर: कार्यकर्ता थ्रेड्स, अधिकतम फ़ाइल आकार, संदर्भ स्निपेट लंबाई
• गंभीरता कॉन्फ़िगरेशन: प्रति गुप्त श्रेणी गंभीरता स्तर अनुकूलित करें
• क्रियाएँ: कैश साफ़ करें, सेटिंग्स रीसेट करें, निष्कर्ष JSON में सहेजें/निर्यात करें

जब Burp में कोई अनुरोध देखा जाता है, तो प्रतिक्रिया निरीक्षक में एक Titus टैब दिखाई देता है यदि गुप्त जानकारियाँ पाई जाती हैं, जो मुख्य Titus टैब पर स्विच किए बिना निष्कर्षों तक त्वरित पहुँच प्रदान करता है।

Titus tab in Burp Suite response inspector highlighting detected secrets in HTTP responses

गुप्त स्कैनिंग के लिए क्रोम ब्राउज़र एक्सटेंशन

क्रोम एक्सटेंशन वेब एप्लिकेशन सुरक्षा मूल्यांकन के दौरान गुप्त जानकारियों के लिए वेब पृष्ठों को स्कैन करता है।

सेटअप```bash

make build-extension

1. `chrome://extensions/` पर जाएँ
2. **डेवलपर मोड** सक्षम करें
3. **अनपैक्ड लोड करें** पर क्लिक करें और `extension/` निर्देशिका चुनें

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

- API कुंजी और टोकन के लिए इनलाइन और बाहरी JavaScript और स्टाइलशीट को स्कैन करता है
- लीक हुई क्रेडेंशियल के लिए localStorage और sessionStorage को स्कैन करता है
- व्यापक गुप्त पहचान के लिए वैकल्पिक नेटवर्क प्रतिक्रिया कैप्चर
- पॉपअप और डैशबोर्ड में प्रदर्शित परिणाम

<img width="1719" height="958" alt="टाइटस क्रोम एक्सटेंशन पॉपअप जो वेब पेज पर पाए गए गुप्त दिखा रहा है" src="https://assets.kitploit.com/production/public/readmes/11969/057a24e2746412ceabe1aac0292a2de463de1efee5bca2489ca34b59d8b0dc2c.png" />

<img width="1744" height="827" alt="टाइटस क्रोम एक्सटेंशन डैशबोर्ड जो एकत्रित गुप्त पहचान परिणामों के साथ है" src="https://assets.kitploit.com/production/public/readmes/11969/265d972fadcc7f212944d7a1d8fd58a43446e7199d1209900e83b96a546ffb00.png" />

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

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

## स्रोत से निर्माण

### मानक निर्माण (Vectorscan-त्वरित)

डिफ़ॉल्ट रूप से, Titus SIMD-त्वरित रेगेक्स मिलान के लिए [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

आप स्टार्टअप पर [vectorscan] N/N rules compiled for Hyperscan देखेंगे जब त्वरित इंजन सक्रिय हो।

ऑटो-इंस्टॉल पर निर्भर रहने के बजाय स्वयं C लाइब्रेरी स्थापित करने के लिए:```bash

macOS (Homebrew)

brew install pkg-config vectorscan

Ubuntu/Debian

sudo apt-get install pkg-config libhyperscan-dev

Fedora/RHEL

sudo dnf install pkgconf-pkg-config vectorscan-devel

Or build vectorscan from source:

git clone --depth 1 --branch vectorscan/5.4.11 https://github.com/VectorCamp/vectorscan.git cd vectorscan && cmake -B build -DCMAKE_INSTALL_PREFIX=/usr/local && cmake --build build && sudo cmake --install build

यदि आप सीधे `go build` का आह्वान करते हैं (उदाहरण के लिए, Titus को एम्बेड करते समय), तो टैग पास करें और CGO सक्षम करें:```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

Pure-Go Build (कोई C निर्भरता नहीं)

यदि आप C लाइब्रेरी स्थापित नहीं कर सकते — या पूरी तरह से पोर्टेबल, स्टैटिक बाइनरी चाहते हैं — तो इसके बजाय pure-Go इंजन बनाएँ। Titus रनटाइम पर स्वचालित रूप से उस पर वापस आ जाता है जब भी vectorscan संकलित नहीं होता है:```bash

Portable pure-Go binary (no CGO, no vectorscan)

make build-pure

Fully static binary

make build-static

## योगदान

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

## लाइसेंस

Apache License 2.0 — [LICENSE](https://github.com/praetorian-inc/titus/blob/HEAD/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/HEAD/NOTICE) देखें।