
उच्च-प्रदर्शन रहस्य स्कैनर। CLI, Go लाइब्रेरी, Burp Suite एक्सटेंशन, और Chrome एक्सटेंशन। 487 डिटेक्शन नियम लाइव क्रेडेंशियल सत्यापन के साथ।
<img width="1200" height="628" alt="Titus - स्रोत कोड, git इतिहास और बाइनरी फ़ाइलों के लिए उच्च-प्रदर्शन सीक्रेट्स स्कैनर" src="https://assets.kitploit.com/production/public/readmes/11969/d2f6b99d686a073185db1b7299fa5f033067b057000062cf592a4ae15a796034.png" />
# Titus: उच्च-प्रदर्शन सीक्रेट्स स्कैनर
[](https://go.dev)
[](LICENSE)
[](https://github.com/praetorian-inc/titus/actions)
**Titus** एक उच्च-प्रदर्शन सीक्रेट्स स्कैनर है जो स्रोत कोड, फ़ाइलों और git इतिहास में क्रेडेंशियल, API कुंजियों और टोकन का पता लगाता है। इसमें सैकड़ों सेवाओं और क्रेडेंशियल प्रकारों को कवर करने वाले 487 डिटेक्शन नियम शामिल हैं, जो [NoseyParker](https://github.com/praetorian-inc/noseyparker) और [Kingfisher](https://github.com/mongodb/kingfisher) से लिए गए हैं। Titus एक CLI, एक Go लाइब्रेरी, एक Burp Suite एक्सटेंशन और एक Chrome ब्राउज़र एक्सटेंशन के रूप में चलता है — ये सभी एक ही डिटेक्शन इंजन और नियम सेट साझा करते हैं।
सुरक्षा इंजीनियरों, पेनेट्रेशन टेस्टरों और DevSecOps टीमों के लिए बनाया गया, Titus [Hyperscan](https://github.com/intel/hyperscan)/[Vectorscan](https://github.com/VectorCamp/vectorscan)-त्वरित regex मिलान को लाइव क्रेडेंशियल सत्यापन के साथ जोड़ता है ताकि आपके पूरे कोडबेस में लीक हुए सीक्रेट्स को खोजा और सत्यापित किया जा सके।
## विषय-सूची
- [Titus क्यों?](#why-titus)
- [इंस्टॉलेशन](#installation)
- [त्वरित शुरुआत](#quick-start)
- [स्कैनिंग विकल्प](#scanning-options)
- [फाइंडिंग स्कोरिंग](#finding-scoring)
- [Go लाइब्रेरी](#go-library-for-secrets-detection)
- [Burp Suite एक्सटेंशन](#burp-suite-extension-for-secret-scanning)
- [ब्राउज़र एक्सटेंशन](#chrome-browser-extension-for-secret-scanning)
- [स्रोत से बिल्ड करना](#building-from-source)
- [योगदान](#contributing)
- [लाइसेंस](#license)
## Titus क्यों?
- **तेज़ सीक्रेट्स स्कैनिंग**: उपलब्ध होने पर [Hyperscan](https://github.com/intel/hyperscan)/[Vectorscan](https://github.com/VectorCamp/vectorscan) द्वारा त्वरित regex मिलान, किसी भी प्लेटफ़ॉर्म पर पोर्टेबिलिटी के लिए शुद्ध-Go फ़ॉलबैक के साथ।
- **व्यापक क्रेडेंशियल डिटेक्शन कवरेज**: 487 नियम AWS, GCP, Azure, GitHub, Slack, डेटाबेस, CI/CD सिस्टम और सैकड़ों अन्य सेवाओं के लिए API कुंजियों, टोकन और क्रेडेंशियल का पता लगाते हैं।
- **लाइव सीक्रेट सत्यापन**: पता लगाए गए सीक्रेट्स को यह पुष्टि करने के लिए उनके स्रोत API के विरुद्ध जाँचा जाता है कि वे सक्रिय हैं या नहीं, जिससे गलत सकारात्मक परिणाम कम होते हैं और उपचार को प्राथमिकता मिलती है।
- **जोखिम-आधारित गंभीरता स्कोरिंग**: प्रत्येक फाइंडिंग को एक संख्यात्मक स्कोर (0–100) और गंभीरता स्तर (info → critical) मिलता है। स्कोर को स्थिर नियम मेटाडेटा, कोड-एक्सेसिबिलिटी संदर्भ और लाइव API कॉल द्वारा ट्यून किया जाता है जो क्रेडेंशियल के वास्तविक प्रभाव क्षेत्र को मापते हैं — ताकि सबसे खतरनाक फाइंडिंग्स हमेशा पहले सामने आएँ।
- **कंटेनर इमेज स्कैनिंग**: किसी भी रजिस्ट्री, tarball या OCI लेआउट डायरेक्टरी से सीधे Docker और OCI इमेज स्कैन करें — किसी Docker डेमॉन या बाइनरी की आवश्यकता नहीं।
- **हर वर्कफ़्लो के लिए कई इंटरफ़ेस**: CLI से स्कैन करें, Go लाइब्रेरी के रूप में एम्बेड करें, Burp Suite में HTTP ट्रैफ़िक को निष्क्रिय रूप से स्कैन करें, या एप्लिकेशन सुरक्षा परीक्षण के दौरान Chrome में वेब पेज स्कैन करें।
- **बाइनरी फ़ाइल निष्कर्षण**: Office दस्तावेज़ों, PDFs, अभिलेखों (zip, tar, 7z), मोबाइल ऐप्स (APK, IPA), ब्राउज़र एक्सटेंशन और अन्य से सीक्रेट्स निकालें और स्कैन करें।
## इंस्टॉलेशन
[Releases](../../releases) पेज से पहले से बनी बाइनरी डाउनलोड करें, या स्रोत से बिल्ड करें:
```bash
make build
```
बाइनरी `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` डिफ़ॉल्ट रूप से) में लिखे जाते हैं और कंसोल पर प्रिंट किए जाते हैं।
### सबकमांड
<!-- BEGIN generated: cli-subcommands -->
Titus अपनी कार्यक्षमता को इन केंद्रित सबकमांड में व्यवस्थित करता है:
```bash
titus analyze # Analyze a credential on demand — detect type, validate, score, and enumerate resources
titus enum # Enumerate remote services for secrets
titus explore # Interactively explore scan results
titus report # Generate a report from scan results
titus rules # Manage detection rules
titus scan # Scan a target for secrets
titus serve # Run as streaming server for Burp extension integration
titus version # Show version information
```
<!-- END generated: cli-subcommands -->
प्रत्येक सबकमांड अपने स्वयं के फ़्लैग के लिए `--help` स्वीकार करता है। शीर्ष-स्तरीय `titus <provider>` रूप जो `titus enum <provider>` से पहले के हैं, अभी भी काम करते हैं, लेकिन वे उपनाम के बजाय छिपे हुए और अप्रचलित हैं, इसलिए उन्हें यहाँ के बजाय जनरेट किए गए संदर्भ में सूचीबद्ध किया गया है।
<!-- BEGIN generated: cli-aliases -->
पूरा संदर्भ — प्रत्येक सबकमांड, उपनाम और फ़्लैग, जिनमें `--help` से छिपे हुए भी शामिल हैं — [docs/CLI.md](https://github.com/praetorian-inc/titus/blob/main/docs/CLI.md) में जनरेट किया गया है।
<!-- END generated: cli-aliases -->
## स्कैनिंग विकल्प
### 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 scan owner/repo --git
```
सार्वजनिक रिपॉज़िटरी के लिए टोकन वैकल्पिक हैं। निजी रिपॉज़िटरी एक्सेस और उच्चतर API दर सीमाओं के लिए `GITHUB_TOKEN` या `GITLAB_TOKEN` सेट करें (या `--token` का उपयोग करें)।
### Docker / OCI इमेज स्कैनिंग
कंटेनर इमेज को सीधे स्कैन करें — किसी docker daemon या `docker` बाइनरी की आवश्यकता नहीं। Titus किसी भी OCI रजिस्ट्री से HTTPS के माध्यम से सीधे इमेज खींचता है (`~/.docker/config.json` से क्रेडेंशियल्स का उपयोग करते हुए), या स्थानीय `docker save` tarball या 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
# Only findings from one repository (host-qualified as recorded, or without the host)
titus report --repo github.com/acme/api
# Repeat a selector, or combine selectors; a location matching any value is kept
titus report --namespace github.com/acme --namespace gitlab.example.com/acme --path src/config.yaml
# List the repository, namespace and path values that select current findings
titus report sources
# List every recorded source, including sources with no findings
titus report sources all
```
आप `--format` के साथ स्कैन के समय आउटपुट फ़ॉर्मेट को भी नियंत्रित कर सकते हैं:
```bash
titus scan path/to/code --format json
```
### पहचाने गए Secrets का सत्यापन
स्कैन के दौरान पहचाने गए secrets को उनके स्रोत APIs के विरुद्ध जाँचने के लिए `--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
```
`visible: false` के रूप में चिह्नित नियम हेल्पर होते हैं जो अन्य नियमों के लिए संदर्भ कैप्चर करते हैं, जैसे क्लाइंट ID, खाता नाम या होस्ट, न कि कोई सीक्रेट। उनके पैटर्न अभी भी चलते हैं, लेकिन उनके मैच कभी भी रिपोर्ट नहीं किए जाते, CLI या Go लाइब्रेरी द्वारा, भले ही नियम स्पष्ट रूप से चयनित हो।
### बाइनरी फ़ाइलों से सीक्रेट निकालना
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
```
समर्थित प्रारूपों में 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
```
## Finding Scoring
Titus द्वारा उत्पन्न प्रत्येक finding में 0–100 तक का एक संख्यात्मक स्कोर और एक severity tier होता है:
| स्कोर | Severity |
|-------|----------|
| 0–20 | info |
| 21–40 | low |
| 41–60 | medium |
| 61–80 | high |
| 81–100 | critical |
स्कोर rule के `base_score` से शुरू होते हैं और **modifiers** द्वारा समायोजित किए जाते हैं — ऐसी शर्तें जो credential के बारे में ज्ञात जानकारी के आधार पर स्कोर को बढ़ाती या घटाती हैं:
```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)
```
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 स्कोरर कैसे लिखें।
## सीक्रेट्स डिटेक्शन के लिए Go लाइब्रेरी
Titus को Go लाइब्रेरी के रूप में इम्पोर्ट किया जा सकता है ताकि आप अपने स्वयं के टूल्स और पाइपलाइन्स में सीक्रेट्स डिटेक्शन जोड़ सकें।
```bash
go get github.com/praetorian-inc/titus
```
```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 = AKIADEADBEEFDEADBEEF`)
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))
```
पूर्ण API संदर्भ, concurrency पैटर्न और अधिक उदाहरणों के लिए [docs/library-usage.md](https://github.com/praetorian-inc/titus/blob/main/docs/library-usage.md) देखें।
## Secret Scanning के लिए Burp Suite Extension
Burp extension proxy ट्रैफ़िक और active penetration testing के दौरान HTTP responses में secrets को स्कैन करता है।
### Setup
#### Linux / macOS (स्रोत से Build करें)
```bash
# Build the CLI and Burp extension JAR, install CLI to ~/.titus/
make install-burp
```
फिर 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
```
3. Burp Suite में Extensions > Add के अंतर्गत JAR लोड करें
#### Linux / macOS (Releases से डाउनलोड करें)
1. अपने प्लेटफ़ॉर्म के लिए उपयुक्त बाइनरी और `titus-burp-<version>.jar` को [Releases](../../releases) से डाउनलोड करें:
- Linux के लिए `titus-linux-amd64` या `titus-linux-arm64`
- macOS के लिए `titus-darwin-amd64` या `titus-darwin-arm64`
2. बाइनरी इंस्टॉल करें:
```bash
mkdir -p ~/.titus
cp titus-<platform> ~/.titus/titus
chmod +x ~/.titus/titus
```
3. Burp Suite में Extensions > Add के अंतर्गत JAR लोड करें
एक्सटेंशन बैकग्राउंड में एक `titus serve` प्रक्रिया शुरू करता है और NDJSON का उपयोग करके stdin/stdout पर संचार करता है। डिटेक्शन नियम स्टार्टअप पर एक बार लोड होते हैं।
### Burp एक्सटेंशन विशेषताएँ
- **निष्क्रिय सीक्रेट स्कैनिंग**: Burp से गुजरने वाले प्रॉक्सी ट्रैफ़िक को स्वचालित रूप से स्कैन करता है
- **सक्रिय सीक्रेट स्कैनिंग**: चयनित अनुरोधों को स्कैन करने के लिए राइट-क्लिक संदर्भ मेनू
- **डुप्लिकेट हटाना**: प्रति एंगेजमेंट में एक ही सीक्रेट की रिपोर्ट केवल एक बार की जाती है
- **फ़ास्ट-पाथ फ़िल्टरिंग**: बाइनरी सामग्री, छवियाँ और गैर-पाठ प्रतिक्रियाएँ छोड़ दी जाती हैं
- **लाइव क्रेडेंशियल सत्यापन**: पता लगाए गए सीक्रेट को स्रोत API के विरुद्ध जाँचें ताकि पुष्टि हो सके कि वे सक्रिय हैं या नहीं
- **फ़ॉल्स पॉज़िटिव प्रबंधन**: शोर फ़िल्टर करने के लिए निष्कर्षों को फ़ॉल्स पॉज़िटिव के रूप में चिह्नित करें
- **गंभीरता वर्गीकरण**: निष्कर्ष जोखिम के अनुसार रंग-कोडित (उच्च/मध्यम/निम्न)
- **निर्यात**: रिपोर्टिंग के लिए निष्कर्षों को JSON में सहेजें
### Burp एक्सटेंशन इंटरफ़ेस
एक्सटेंशन Burp में एक **Titus** टैब जोड़ता है जिसमें तीन उप-टैब होते हैं:
**Secrets**: सभी पता लगाए गए सीक्रेट, प्रकार, होस्ट और सत्यापन स्थिति के अनुसार फ़िल्टरिंग के साथ।
Titus Burp Suite extension secrets tab showing detected API keys and credentials with validation status
- **सत्यापन स्थिति**: दिखाता है कि सीक्रेट की जाँच की गई है या नहीं (सक्रिय/निष्क्रिय/अज्ञात)
- **फ़िल्टरिंग**: विशिष्ट मानों के अनुसार फ़िल्टर करने के लिए Type, Host या Status बटन पर क्लिक करें; टेक्स्ट और रेगेक्स मिलान के लिए सर्च बॉक्स का उपयोग करें
- **बल्क क्रियाएँ**: बैच में सत्यापित करने या फ़ॉल्स पॉज़िटिव के रूप में चिह्नित करने के लिए कई पंक्तियाँ चुनें
- **Secret Details पैनल**: देखने के लिए एक निष्कर्ष चुनें:
- **Details**: नियम जानकारी, श्रेणी, पूर्ण सीक्रेट मान, पहली बार देखे जाने का टाइमस्टैम्प
- **URLs**: वे सभी स्थान जहाँ यह सीक्रेट पाया गया था
- **Validation**: विवरण के साथ सत्यापन परिणाम (जैसे, AWS खाता ID, ARN)
- **Request/Response**: सीक्रेट हाइलाइट किए गए पूर्ण HTTP ट्रैफ़िक
**Statistics**: प्रकार और होस्ट के अनुसार समूहीकृत सीक्रेट का समग्र दृश्य।
<img width="1964" height="848" alt="Titus Burp Suite extension statistics tab showing secrets by type and host" src="https://assets.kitploit.com/production/public/readmes/11969/4a3d6f997049bb8bba621ceb8511b9a41c63867a5c1e8add6065c483706ac36a.png" />
- **सारांश**: कुल अद्वितीय सीक्रेट, स्कैन किए गए होस्ट, सत्यापन विवरण (सक्रिय बनाम निष्क्रिय), और फ़ॉल्स पॉज़िटिव गणना
- **प्रकार के अनुसार सीक्रेट**: श्रेणी वर्गीकरण के साथ प्रत्येक सीक्रेट प्रकार की गणना
- **होस्ट के अनुसार सीक्रेट**: प्रति होस्ट पाए गए सीक्रेट की संख्या
**Settings**: स्कैनिंग विकल्प, सत्यापन और गंभीरता मैपिंग कॉन्फ़िगर करें।
Titus Burp Suite extension settings tab with scan configuration options
- **स्कैन सेटिंग्स**:
- *निष्क्रिय स्कैनिंग*: सभी प्रॉक्सी ट्रैफ़िक को स्वचालित रूप से स्कैन करें (डिफ़ॉल्ट रूप से सक्षम)
- *अनुरोध बॉडी स्कैनिंग*: एप्लिकेशन द्वारा भेजे गए सीक्रेट के लिए अनुरोध बॉडी भी स्कैन करें
- *सत्यापन*: स्रोत API के विरुद्ध सीक्रेट की जाँच करने के लिए सक्षम करें (आउटबाउंड अनुरोध करता है और अलर्ट ट्रिगर कर सकता है)
- **स्कैन पैरामीटर**: वर्कर थ्रेड्स, अधिकतम फ़ाइल आकार, कॉन्टेक्स्ट स्निपेट लंबाई
- **गंभीरता कॉन्फ़िगरेशन**: प्रति सीक्रेट श्रेणी गंभीरता स्तर अनुकूलित करें
- **क्रियाएँ**: कैश साफ़ करें, सेटिंग्स रीसेट करें, निष्कर्षों को JSON में सहेजें/निर्यात करें
---
[Read more](https://github.com/praetorian-inc/titus)