Suche nach Cheat Sheet

generieren

Überblick

SearchSploit ist ein Kommandozeilen-Suche-Tool für ExploitDB, mit dem Sie eine Kopie der ExploitDB mitnehmen können, wohin Sie auch gehen. SearchSploit gibt Ihnen die Möglichkeit, detaillierte Offline-Suche durch Ihre vor Ort überprüfte Kopie des Repository durchzuführen. Diese Fähigkeit ist besonders nützlich bei Penetrationstests, bei denen Internet-Konnektivität begrenzt sein kann oder wenn Sie schnell durch tausende von Exploits suchen müssen, ohne auf Web-Schnittstellen zu verlassen.

ZEIT Warning: SearchSploit bietet Zugang zu realen Exploits, die Schäden an Systemen verursachen können. Verwenden Sie diese Exploits nur gegen Systeme, die Sie besitzen oder eine ausdrückliche schriftliche Erlaubnis zum Testen haben. Unberechtigte Nutzung von Exploits kann lokale Gesetze und Vorschriften verletzen.

Installation

Kali Linux Installation

# SearchSploit is pre-installed on Kali Linux
searchsploit --version

# Update the database
searchsploit -u

# Check installation path
which searchsploit

# Verify database location
searchsploit --path
```_

### Ubuntu/Debian Installation
```bash
# Install git if not already installed
sudo apt update
sudo apt install git

# Clone ExploitDB repository
sudo git clone https://github.com/offensive-security/exploitdb.git /opt/exploitdb

# Create symbolic link
sudo ln -sf /opt/exploitdb/searchsploit /usr/local/bin/searchsploit

# Update PATH (add to ~/.bashrc for persistence)
export PATH="$PATH:/opt/exploitdb"

# Verify installation
searchsploit --help
```_

### Manuelle Installation
```bash
# Download and extract
wget https://github.com/offensive-security/exploitdb/archive/main.zip
unzip main.zip
mv exploitdb-main /opt/exploitdb

# Make searchsploit executable
chmod +x /opt/exploitdb/searchsploit

# Create symbolic link
sudo ln -sf /opt/exploitdb/searchsploit /usr/local/bin/searchsploit

# Configure .searchsploit_rc file
echo 'papers_directory="/opt/exploitdb/papers"' > ~/.searchsploit_rc
echo 'exploits_directory="/opt/exploitdb/exploits"' >> ~/.searchsploit_rc
```_

### Docker Installation
```bash
# Create Dockerfile
cat > Dockerfile << 'EOF'
FROM ubuntu:20.04
RUN apt-get update && apt-get install -y git
RUN git clone https://github.com/offensive-security/exploitdb.git /opt/exploitdb
RUN ln -sf /opt/exploitdb/searchsploit /usr/local/bin/searchsploit
WORKDIR /opt/exploitdb
ENTRYPOINT ["/opt/exploitdb/searchsploit"]
EOF

# Build Docker image
docker build -t searchsploit .

# Run SearchSploit in Docker
docker run --rm searchsploit apache

# Create alias for easier usage
echo 'alias searchsploit="docker run --rm -v $(pwd):/data searchsploit"' >> ~/.bashrc
```_

## Basisnutzung

### Einfache Suche
```bash
# Basic search
searchsploit apache

# Search for multiple terms
searchsploit apache 2.4

# Search with quotes for exact phrase
searchsploit "apache 2.4.7"

# Case-insensitive search (default)
searchsploit APACHE

# Case-sensitive search
searchsploit -c Apache

# Search in title only
searchsploit -t apache

# Search excluding specific terms
searchsploit apache --exclude="2.2"
```_

### Erweiterte Suchoptionen
```bash
# Search by platform
searchsploit --platform windows apache
searchsploit --platform linux kernel
searchsploit --platform php web

# Search by exploit type
searchsploit --type remote apache
searchsploit --type local windows
searchsploit --type webapps php

# Search by author
searchsploit --author "Metasploit"
searchsploit --author "exploit-db"

# Search by port
searchsploit --port 80
searchsploit --port 443

# Combine multiple filters
searchsploit --platform linux --type local kernel
```_

### CVE und Schwachstellensuche
```bash
# Search by CVE number
searchsploit --cve 2021-44228
searchsploit --cve CVE-2021-34527

# Search by multiple CVEs
searchsploit --cve 2021-44228,2021-34527

# Search for recent CVEs
searchsploit --cve 2023-

# Search by vulnerability type
searchsploit "buffer overflow"
searchsploit "sql injection"
searchsploit "privilege escalation"
searchsploit "remote code execution"
```_

### Datumsbasierte Recherchen
```bash
# Search for exploits after specific date
searchsploit --after 2020 apache
searchsploit --after 2021-01-01 windows

# Search for exploits before specific date
searchsploit --before 2019 linux
searchsploit --before 2020-12-31 php

# Search within date range
searchsploit --after 2020 --before 2021 kernel

# Search for recent exploits (last 30 days)
searchsploit --after $(date -d "30 days ago" +%Y-%m-%d)
```_

## Ausgabeformatierung und Anzeige

### Ausgabeformate
```bash
# Default table format
searchsploit apache

# Verbose output with full paths
searchsploit -v apache

# JSON output
searchsploit -j apache

# XML output
searchsploit -x apache

# CSV output (pipe to file)
| searchsploit apache | sed 's/ | /,/g' > results.csv |

# Color output (default)
searchsploit --colour apache

# No color output
searchsploit --no-colour apache
```_

### Filter- und Limitierungsergebnisse
```bash
# Limit number of results
searchsploit apache|head -10

# Show only exploit IDs
| searchsploit apache | awk '\\\\{print $1\\\\}' | grep -E '^[0-9]+ |

### Search Result Analysis
```bash
# Gesamtergebnisse
suchsploit apache|wc -l

# Zählen Sie nach Plattform
suchsploit apache|grep -c linux
suchsploit apache|grep -c windows

# Anzahl nach Typ
suchsploit apache|grep -c remote
suchsploit apache|grep -c local

# Extrahieren Sie einzigartige Plattformen
| Suchanfragen -j apache | jq -r '.RESULTS_EXPLOIT[]. Plattform | sort | uniq -c |

# Ausgewählte Autoren
suchsploit -j apache|jq -r '.RESULTS_EXPLOIT[]. Autor(en) -c

Exploit Management

Copying and Downloading Exploits

# Kopieren von Exploit in aktuelles Verzeichnis
Suche -m 50383

# Kopieren Sie mehrere Exploits
Suche -m 50383,50384,50385

# Kopieren von Exploit auf bestimmtes Verzeichnis
Suchanfrage -m 50383 -o /tmp/exploits/

# Kopie mit Originaldateinamen erhalten
Suchanfragen -m Exploits/linux/local/50383.c

# Alle Exploits von Suchergebnissen kopieren
| suchsploit -j apache | jq -r '.RESULTS_EXPLOIT[]. EDB-ID' | head -5 | xargs searchsploit - Ja. |

# Batch copy Exploits
| echo "50383,50384,50385" | tr ',' '\n' | xargs -I \{\} searchsploit -m \{\} |

Viewing and Examining Exploits

# Inhalte nutzen
Suche -x 50383

# Open Exploit im Standardeditor
Suche -e 50383

# Exploit mit Syntax-Highlighting ansehen
searchsploit -m 50383 && cat 50383.c|highlight --syntax=c

# Metadaten nutzen
| searchsploit -j apache | jq '.RESULTS_EXPLOIT[] | select(.["EDB-ID"] == "50383") ' |

# Informationen zur Nutzung
Suchanfrage -p 50383

Exploit Organization

# Organisierte Verzeichnisstruktur erstellen
mkdir -p nutzt/\{windows,linux,web,mobile\}

# Kopieren von Exploits durch Plattform
| searchsploit --platform windows -j | jq -r '.RESULTS_EXPLOIT[].["EDB-ID"]' | head -10 | xargs -I \{\} searchsploit -m \{\} -o Exploits/Fenster/ |

# Kopieren von Exploits nach Typ
| searchsploit --type webapps -j | jq -r '.RESULTS_EXPLOIT[].["EDB-ID"]' | head -10 | xargs -I \{\} searchsploit -m \{\} -o Exploits/web/ |

# Exploit Inventar erstellen
| suchsploit -j apache | jq -r '.RESULTS_EXPLOIT[] | \(.["EDB-ID"]),\(.Title),\(.Platform),\(.Type)" > apache_exploits.csv |

Database Management

Database Updates

# ExploitDB Datenbank aktualisieren
Suchanfragen -u

# Force Update (überschreiben lokale Änderungen)
cd /opt/exploitdb &amp; git reset --hard &amp; git pull

# Überprüfen Sie Updates ohne Anwendung
cd /opt/exploitiert &amp; git fetch && git status

# Spezifische Branche aktualisieren
cd /opt/exploitiert &amp; git pull

# Update verifizieren
Suche --stats

Database Information

# Datenbankstatistiken anzeigen
Suche --stats

# Datenbankpfad anzeigen
Suchanfragen --path

# Überprüfen Sie die Integrität der Datenbank
Suchanfragen - Check

# Datenbankindex aufbauen
Suchanfragen -- rebuild

# Versionsinformationen anzeigen
Suchanfragen --version

# Hilfeinformationen anzeigen
Suchanfragen -- Hilfe

Database Maintenance

# temporäre Dateien reinigen
finden /opt/exploitdb -name "*.tmp" -delete

# Verwenden der Festplatten
du -sh /opt/exploitiert

# Backup-Datenbank
tar -czf Ausbeutedb_backup_$(date +%Y%m%d.tar.gz /opt/exploitiert

# Wiederherstellen Datenbank von Backup
Teer -xzf Explodb_backup_20231201.tar.gz -C /

# Datenbank nach Wartung überprüfen
Suchanfragen - Check

Automation Scripts

Automated Vulnerability Assessment

#!/bin/bash
# Automatische Sicherheitsbewertung mit SearchSploit

TARGET_LIST="$1"
OUTPUT_DIR="searchsploit_assessment_$(date +%Y%m%d_%H%M%S"
REPORT_FILE="$OUTPUT_DIR/vulnerability_assessment_report.html"

| wenn [ -z "$TARGET_LIST" ] |  | [ ! -f "$TARGET_LIST" ]; dann |
echo "Nutzung: $0 <target_list_file>"
echo "Target-Listendatei sollte eine Software/Service pro Zeile enthalten"
echo "Beispiel: 'Apache 2.4.7', 'Windows 10', 'PHP 7.4'"
Ausgang 1
Fichte

mkdir -p "$OUTPUT_DIR"

# Funktion zur Bewertung eines einzelnen Ziels
Bewertung_target() \{
lokale Ziel="$1"
lokale Ziel_dir="$OUTPUT_DIR/$(echo "$target"|tr ' /' '_')"

echo "[+] Assessing: $target"

mkdir -p "$target_dir"

    # Search for exploits
suchsploit -j "$target" > "$target_dir/search_results.json"

wenn [ -s "$target_dir/search_results.json"]; dann
        # Parse and analyze results
Python3 << EOF
Import json
Einfuhr
aus Sammlungen import defaultdict

# Lesen Sie die Suchergebnisse
mit open('$target_dir/search_results.json', 'r') als f:
Daten = json.load(f)

Exploits = data.get('RESULTS_EXPLOIT', [])
shellcodes = data.get('RESULTS_SHELLCODE', [])

Print(f) [+] Gefunden \{len(Exploits)\} Exploits und \{len(Shellcodes)\} Shellcodes")

wenn nicht ausnutzt und nicht Shellcodes:
Druck(f) [-] Keine Exploits gefunden für: $target")
Ausstieg(0)

# Ausbeutungen analysieren
Analyse
'Ziel': '$target',
„total_exploits": len(exploits),
'total_shellcodes': len(shellcodes),
"Platforms": defaultdict(int),
'Typen': defaultdict(int),
'Jahre': defaultdict(int),
'severity_assessment': 'Unknown',
'high_priority_exploits': []
{\cHFFFF}

zur Nutzung in Exploits:
Plattform = Exploit.get('Platform', 'Unknown')
Ausbeute_type = Ausbeute.get('Type', 'Unknown')
Datum = Ausbeute.get('Date', '')
Titel = Ausbeute.get('Title', '').lower()

Analyse['Plattformen'][Plattform] += 1
Analyse['Typen'][exploit_type] += 1

wenn Datum:
Jahr = Datum.Split('-')[0]
Analyse[Jahre][Jahr] += 1

    # Identify high-priority exploits
wenn ein(Schlüsselwort im Titel für Stichwort in ['remote', 'rce', 'privilege', 'escalation', 'buffer overflow']):
Analyse['high_priority_exploits'].append(exploit)

# Besessene Schwere
total_exploits = len(exploits)
hoch_priority_count = len(Analyse['high_priority_exploits'))
remote_count = analysis['types'].get('remote', 0)

wenn hoch_priority_count > 5 oder remote_count > 3:
Analyse['severity_assessment'] = 'Kritisch '
elif high_priority_count > 2 oder remote_count > 1:
Analyse['severity_assessment'] = 'High '
elif total_exploment > 5:
Analyse['severity_assessment'] = 'Medium '
andere:
Analyse['severity_assessment'] = 'Low'

# Analyse speichern
mit offen('$target_dir/analysis.json', 'w') als f:
json.dump(Analyse, f, indent=2, default=str)

Print(f) [+] Beurteilung der Schwere: \{Analyse['severity_assessment']\}")
Print(f) [+] Hohe Prioritätsausbeuten: \{high_priority_count\}")
EOF

        # Download high-priority exploits
wenn [ -f "$target_dir/analysis.json"]; dann
Python3 << EOF
Import json

mit offen('$target_dir/analysis.json', 'r') als f:
Analyse = json.load(f)

high_priority = analysis.get('high_priority_exploits', [])[:10] # Limit to 10

wenn hoch_priority:
mit open('$target_dir/priority_exploits.txt', 'w') als f:
für die Nutzung in High_priority:
f.write(f)\{exploit.get('EDB-ID', '')\\\n")
EOF

            # Download priority exploits
wenn [ -f "$target_dir/priority_exploits.txt"]; dann
während des Lesens -r edb_id; tun
wenn [ -n "$edb_id"]; dann
| searchsploit -m "$edb_id" -o "$target_dir/" 2>/dev/null |  | true |
Fichte
getan < "$target_dir/priority_exploits.txt"
Fichte
Fichte

Rückkehr 0
andere
Echo " [-] Keine Exploits gefunden für: $target"
Rückkehr 1
Fichte
{\cHFFFF}

# Funktion zur Erstellung eines umfassenden Berichts
erzeugen_report() \{
echo "[+] Gesamtbewertungsbericht generieren"

Python3 << EOF
Import json
Einfuhr
Import glob
Datum der Einfuhr
aus Sammlungen import defaultdict

# Alle Analysedaten erfassen
Alle_Analysen = []
für analysis_file in glob.glob('$OUTPUT_DIR/*/analysis.json'):
versuchen:
mit open(analysis_file, 'r') als f:
Daten = json.load(f)
all_analyses.append(data)
ausgenommen:
weiter

# Gesamtstatistik berechnen
total_targets = len(all_analyses)
total_exploits = sum(a.get('total_exploits', 0) for a in all_analyses)
total_shellcodes = sum(a.get('total_shellcodes', 0) for a in all_analyses)

severity_counts = defaultdict(int)
Plattform_counts = defaultdict(int)
type_counts = defaultdict(int)

zur Analyse in all_analysen:
severity_counts[analysis.get('severity_assessment', 'Unknown')] += 1

für die Plattform, zählen in analysis.get('platforms', \{\}).items():
Plattform_counts[Plattform] += Anzahl

für Exploit_type, in analysis.get('types', \{\}).items():
Typ_counts[exploit_type] += Anzahl

# HTML-Bericht erstellen
html_content = f"""
<! DOCTYPE html>
< html
< Kopf >
<title>SearchSploit Vulnerability Assessment Report</title>


</Kopf >
<= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <=
<div class="header">
<h1>SearchSploit Vulnerability Assessment Report</h1>
<p>Generiert: \{datetime.now().strftime('%Y%m%d %H:%M:%S')\}</p>
</div>

<div class="summary">
<h2>Executive Zusammenfassung </h2>
<= <= <= <= <= <= <============================================================================
<tr>>Metric</th> Wert</th>/tr>
<tr>td>Targets Assessed</td>td>\{total_targets\}</td>/tr>
<tr>td>Gesamt Explosivstoffe Gefunden/td>td>\{total_exploplos\}</td>/tr>
<tr>td>Total Shellcodes Found</td>td>\{total_shellcodes\}</td>/tr>
<tr>td>Critical Risk Targets</td>td>\{severity_counts.get('Critical', 0)\}>/td>/tr>
<tr>td>High Risk Targets</td>td>\{severity_counts.get('High', 0)\}>/td>/tr>
<tr>td>Medium Risk Targets</td>td>\{severity_counts.get('Medium', 0)\}>/td>/tr>
<tr>td>Low Risk Targets</td>td>\{severity_counts.get('Low', 0)\}>/td>/tr>
</Tabelle >
</div>

<div class="summary">
<h2>Risk Distribution</h2>
<div class="chart">
<canvas id="riskChart" Breite="400" Höhe="200">
</div>
</div>

<div class="summary">
<h2>Platform Distribution</h2>
<= <= <= <= <= <= <============================================================================
<tr> ≤Platform</th> Exploit Count</th>/tr>
""

für Plattform, Anzahl in sortiert(platform_counts.items(), key=lambda x: x[1], reverse=True)[:10]:
html_content += f" <tr>td>\{platform\}</td>>td>\{count\}>/td>>\n"

html_content += ""
</Tabelle >
</div>

<h2>Einzelzielbewertungen</h2>
""

# Einzelne Zieldetails hinzufügen
zur Analyse in sortiert(all_analysen, key=lambda x: x.get('total_exploits', 0), reverse=True):
severity = analysis.get('severity_assessment', 'Unknown').lower()
Ziel = Analyse.get('target', 'Unknown')

html_content += f"""
<div class="target \{severity\}">
<===============
<p>strong>Risk Level:</strong> \{analysis.get('severity_assessment', 'Unknown')\}</p>
<p>strong>Total Explosivstoffe:</strong> \{analysis.get('total_exploits', 0)\}>/p>
<p>strong>High-Priority Exploits:</strong> \{len(analysis.get('high_priority_exploits', [])\}>/p>

<h4>Platform Aufschlüsselung:</h4>
<= <= <= <= <= <= <============================================================================
<tr>> >Platform</th>>>Spannung>/th>
""

für die Plattform, zählen in analysis.get('platforms', \{\}).items():
html_content += f" <tr>td>\{platform\}</td>>td>\{count\}>/td>>\n"

html_content += ""
</Tabelle >
</div>
""

html_content += f"""

</Körper >
</html>
""

mit offen('$REPORT_FILE', 'w') als f:
f.write(html_content)

Druck(f)[+] Umfassender Bericht generiert: $REPORT_FILE")
EOF
{\cHFFFF}

# Funktion zur Generierung von CSV-Zusammenfassung
erzeugen_csv_summary() \{
echo "[+] CSV Zusammenfassung generieren"

lokal csv_file="$OUTPUT_DIR/vulnerability_summary.csv"

Echo "Target,Total_Exploits, Total_Shellcodes,Severity,High_Priority_Exploits,Top_Platform,Top_Type" > "$csv_file"

für analysis_file in "$OUTPUT_DIR"/*/analysis.json; do
wenn [ -f "$analysis_file" ]; dann
Python3 << EOF
Import json

mit open('$analysis_file', 'r') als f:
Daten = json.load(f)

Ziel = data.get('target', 'Unknown')
total_exploits = data.get('total_exploits', 0)
total_shellcodes = data.get('total_shellcodes', 0)
severity = data.get('severity_assessment', 'Unknown')
hoch_priority = len(data.get('high_priority_exploits', []))

Plattformen = data.get('platforms', \{\})
top_platform = max(platforms.keys(), key=lambda k: Plattformen[k]) wenn Plattformen sonst 'Unknown'

Typen = data.get('types', \{\})
top_type = max(types.keys(), key=lambda k: typen[k]) wenn Typen sonst 'Unknown'

Print(f"\{target\},\{total_exploits\},\{total_shellcodes\},\{severity\},\{high_priority\},\{top_platform\},\{top_type\}")
EOF
Fichte
gemacht >> "$csv_file"

echo "[+] CSV Zusammenfassung generiert: $csv_file"
{\cHFFFF}

# Hauptausführung
echo "[+] Automatische Sicherheitsbewertung starten"
echo "[+] Zielliste: $TARGET_LIST"
Echo "[+] Ausgabeverzeichnis: $OUTPUT_DIR"

# Abhängigkeiten prüfen
wenn ! Befehl -v searchsploit &> /dev/null; dann
echo "[-] SearchSploit nicht gefunden. Bitte installieren Sie ExploitDB zuerst."
Ausgang 1
Fichte

# Bearbeiten Sie jedes Ziel
total_targets=0
erfolgreich_assessments=0

während des Lesens -r-Ziel; tun
    # Skip empty lines and comments
| [[ -z "$target" |  | "$target" =~ ^#.*$ ]] &amp; weiterlesen |

total_targets=$(total_targets + 1))

wenn bewerten_target "$target"; dann
erfolgreich_assessments=$((successful_assessments + 1))
Fichte

    # Small delay to avoid overwhelming the system
1

fertig < "$TARGET_LIST"

echo "[+] Bewertung abgeschlossen"
echo " Gesamtziele: $total_targets"
echo " Erfolgreiche Bewertungen: $successful_assessments"

# Berichte erstellen
erzeugen _report
erzeugen_csv_summary

echo "[+] Sicherheitsbewertung abgeschlossen"
Echo "[+] Ergebnisse gespeichert in: $OUTPUT_DIR"
echo "[+] Öffnen Sie $REPORT_FILE für ausführlichen Bericht

Exploit Collection and Organization

#!/bin/bash
# Automatisierte Sammlung und Organisation von Exploit

COLLECTION_NAME="$1"
SEARCH_TERMS="$2"
"exploit_collection_$\{COLLECTION_NAME\}_$(date +%Y%m%d_%H%M%S"

| wenn [ -z "$COLLECTION_NAME" ] |  | [ -z "$SEARCH_TERMS"]; dann |
echo "Nutzung: $0 <collection_name> <search_terms>"
echo "Beispiel: $0 'web_exploits' 'php,apache,nginx,wordpress'"
Ausgang 1
Fichte

mkdir -p "$OUTPUT_DIR"

# Funktion zum Sammeln von Exploits für Suchbegriff
Collect_exploits() \{
lokal search_term="$1"
lokale Bezeichnung_dir="$OUTPUT_DIR/$(echo "$search_term")tr ' /' '_')"

echo "[+] Exploits sammeln für: $search_term"

mkdir -p "$term_dir"

    # Search and save results
Suchanfrage -j "$search_term" > "$term_dir/search_results.json"

wenn [ ! -s "$term_dir/search_results.json"]; dann
Echo " [-] Keine Exploits gefunden für: $search_term"
Rückkehr 1
Fichte

    # Parse and categorize exploits
Python3 << EOF
Import json
Einfuhr
aus Sammlungen import defaultdict

# Lesen Sie die Suchergebnisse
mit open('$term_dir/search_results.json', 'r') als f:
Daten = json.load(f)

Exploits = data.get('RESULTS_EXPLOIT', [])
Print(f) [+] gefunden \{len(exploits)\} nutzt für $search_term")

# Kategorisieren von Exploits
Kategorien {\cHFFFF}
"Entfernung":
'lokal': [],
'Webapps': [],
'dosis': [],
"Fenster": [],
'linux':
'php':
'recent': [] # Letzte 2 Jahre
{\cHFFFF}

zur Nutzung in Exploits:
Ausbeute_type = Ausbeute.get('Typ', '').lower()
Plattform = Exploit.get('Platform', '').lower()
Titel = Ausbeute.get('Title', '').lower()
Datum = Ausbeute.get('Date', '')

    # Categorize by type
wenn "Entfernung" im Exploit_Typ:
Kategorien['remote'].append(exploit)
elif 'local' in Ausbeute_type:
Kategorien['local'].append(exploit)
elif 'webapps' in Ausbeute_type:
Kategorien['webapps'].append(exploit)
elif 'dos' in Ausbeute_type:
Kategorien['dos'].append(exploit)

    # Categorize by platform
wenn "Fenster" in Plattform:
Kategorien['windows'].append(exploit)
elif 'linux' in Plattform:
Kategorien['linux'].append(exploit)
elif 'php' in Plattform:
Kategorien['php'].append(exploit)

    # Check if recent (last 2 years)
wenn Datum:
Jahr = int(date.split('-')[0]
wenn Jahr >= 2022: # Anpassung an das laufende Jahr
Kategorien['recent'].append(exploit)

# Kategorisierte Daten speichern
für Kategorie, Exploits_list inkategorien.items():
wenn Exploits_list:
Kategorie_dir = f'$term_dir/\{Kategorie\} '
os.makedirs(category_dir, exist_ok=True)

mit offen(f'\{category_dir\}/exploits.json', 'w') als f:
json.dump(exploits_list, f, indent=2)

        # Create download list
mit open(f'\{category_dir\}/download_list.txt', 'w') als f:
für Exploits_list[:20]: # Limit bis 20 pro Kategorie
f.write(f)\{exploit.get('EDB-ID', '')\\\n")

Print(f" [+] \{Kategorie\}: \{len(exploits_list)\} Exploits")

print(f" [+] Kategorisierung abgeschlossen für $search_term)
EOF

    # Download exploits by category
für Kategorie_Dir in "$term_dir"/*; tun
wenn [ -d "$category_dir" ] und [ -f "$category_dir/download_list.txt" ]; dann
Kategorie_name=$(Basisname "$category_dir")
Echo " [+] Download von $category_name Exploits"

während des Lesens -r edb_id; tun
wenn [ -n "$edb_id"]; dann
| searchsploit -m "$edb_id" -o "$category_dir/" 2>/dev/null |  | true |
Fichte
fertig < "$category_dir/download_list.txt"
Fichte
erledigt

Rückkehr 0
{\cHFFFF}

# Funktion zum Erstellen von Sammelindex
create_collection_index() \{
echo "[+] Sammlungsindex erstellen"

lokale index_file="$OUTPUT_DIR/collection_index.html"

Python3 << EOF
Import json
Einfuhr
Import glob
Datum der Einfuhr
aus Sammlungen import defaultdict

# Sammeln Sie alle Nutzungsdaten
All_exploits = []
term_stats = defaultdict(lambda: defaultdict(int))

für results_file in glob.glob('$OUTPUT_DIR/*/search_results.json'):
term_name = os.path.basename(os.path.dirname(results_file))

versuchen:
mit open(results_file, 'r') als f:
Daten = json.load(f)

Exploits = data.get('RESULTS_EXPLOIT', [])
all_exploits.extend(exploits)

        # Calculate statistics
term_stats[term_name]['total'] = len(exploits)

zur Nutzung in Exploits:
Plattform = Exploit.get('Platform', 'Unknown')
Ausbeute_type = Ausbeute.get('Type', 'Unknown')

term_stats[term_name]['platforms'][platform] += 1
term_stats[term_name]['types'][exploit_type] += 1

ausgenommen:
weiter

# HTML-Index generieren
html_content = f"""
<! DOCTYPE html>
< html
< Kopf >
<title>Exploit Collection: $COLLECTION_NAME</title>

</Kopf >
<= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <=
<div class="header">
<h1>Erhebung: $COLLECTION_NAME</h1>
<p>Generiert: \{datetime.now().strftime('%Y%m%d %H:%M:%S')\}</p>
<p>Search Bedingungen: $SEARCH_TERMS</p>
</div>

<div class="stats">
<div class="stat-box">
<h3>\{len(all_exploits)\}>/h3>
<p>Gesamtermittlung
</div>
<div class="stat-box">
<h3>\{len(term_stats)\}>/h3>
<p>Search Bedingungen</p>
</div>
<div class="stat-box">
<h3>\{len(set(e.get('Platform', 'Unknown') für e in all_exploits))\}</h3>
<p>Platforms</p>
</div>
<div class="stat-box">
<h3>\{len(set(e.get('Typ', 'Unknown') für e in all_exploits))\}>/h3>
<p>Exploit Types</p>
</div>
</div>

<h2>Collection Contents</h2>
""

# Details zu jedem Suchbegriff hinzufügen
für term_name, stats in term_stats.items():
html_content += f"""
<div class="term">
<h3>\{term_name.replace('_', '.title()\}/h3>
<p>strong>Gesamt Exploits:</strong> \{stats['total '\}>/p>

<h4>Kategorien Verfügbar:</h4>
<div style="display: flex; flex-wrap: wrap; gap: 10px;">
""

    # List available categories
Bezeichnung_dir = f"$OUTPUT_DIR/\{term_name\}"
für Kategorie in ['remote', 'local', 'webapps', 'dos', 'windows', 'linux', 'php', 'recent']:
Kategorie_Pfad = f"\{term_dir\}/\{Kategorie\}"
wenn os.path.exists(category_path):
Exploit_count = 0
versuchen:
mit open(f"\{category_path\}/exploits.json", 'r') als f:
nutzt = json.load(f)
Explo_count = len(exploits)
ausgenommen:
passieren

html_content += f"""
<div class="Kategorie">
<strong>\{catego.title()\}>/strong>br>
\{exploit_count\} nutzt
</div>
""

html_content += ""
</div>
</div>
""

html_content += ""

<h2>Verwendungshinweise</h2>
<div class="term">
<h3>Regelung Struktur</h3>
<=================
< < <>stark >search_term/>/stark> - Individuelle Suchbegriffe Ergebnisse</li>
< < <>stark >search_term/categos/>/stark> - Exploits nach Typ/Platform</li>
<li>stark>search_term/categos/exploplos.json</strong> - Exploit metadata</li>
< < <>stark>search_term/catego/[EDB-ID].*</stark> - Downloaded Exploit Dateien </li>
</ul>

<h3>Quick Access Commands</h3>
<==================
# Alle Remote Exploits anzeigen
finden . -Name "Remote" -Typ d

# Alle heruntergeladenen Exploit Dateien anzeigen
-name "*.c" -o -name "*.py" -o -name "*.rb" -o -name "*.pl"

# Suche in der Sammlung
grep -r "Puffer Überlauf" .

# Grafenausbeuten nach Typ
| finden . -Name "exploits.json" -exec jq -r '.[].Typ \{\} \; | sort | uniq -c |
</pre>
</div>
</Körper >
</html>
""

mit open('$index_file', 'w') als f:
f.write(html_content)

Druck(f)[+] Erhebungsindex generiert: $index_file")
EOF
{\cHFFFF}

# Funktion zum Erstellen einer tragbaren Sammlung
create_portable_collection() )
echo "[+] Erstellen von tragbaren Sammlungsarchiven"

lokale Archive_name="$\{COLLECTION_NAME\}_exploit_collection_$(date +%Y%m%d).tar.gz"

    # Create README
Kat > "$OUTPUT_DIR/README" << EOF
# Exploit Collection: $COLLECTION_NAME

Generiert: $(date)
Suchbegriffe: $SEARCH_TERMS

## Verzeichnis Struktur

- **search_term/**: Einzelne Suchergebnisse
- **search_term/categos/**: Exploits nach Typ/Plattform
- **search_term/categoits/exploits.json**: Metadaten nutzen
- **search_term/categos/[EDB-ID].***: Downloaded Exploit Dateien

## Kategorien

- **remote**: Ausführung von Remotecodes
- **lokal**: Lokale Privilegiskalation nutzt
- **webapps**: Web-Anwendung nutzt
- **dos**: Denial of service Exploits
- **Fenster*: Windows-spezifische Exploits
- **linux**: Linux-spezifische Exploits
- **php**: PHP-spezifische Exploits
- ** recent**: Neue Exploits (letzte 2 Jahre)

## Verwendung

1. Extrahieren Sie das Archiv an Ihren gewünschten Standort
2. Open collection_index.html für eine Übersicht
3. Navigieren Sie zu bestimmten Kategorien für gezielte Exploits
4. Bewertung Exploit Code vor Gebrauch
5. Gewährleistung der ordnungsgemäßen Genehmigung vor dem Testen

## Rechtliche Hinweise

Diese Ausbeutungen sind nur für pädagogische und autorisierte Testzwecke vorgesehen.
Verwenden Sie nur gegen Systeme, die Sie besitzen oder eine ausdrückliche schriftliche Erlaubnis zum Testen haben.
Unberechtigte Nutzung kann lokale Gesetze und Vorschriften verletzen.
EOF

    # Create archive
tar -czf "$archive_name" -C "$(dirname "$OUTPUT_DIR")" "$(basename "$OUTPUT_DIR")"

echo "[+] Tragbare Sammlung erstellt: $archive_name
echo " Archivgröße: $(du -h "$archive_name"|cut -f1)"
{\cHFFFF}

# Hauptausführung
echo "[+] Starten Exploit Sammlung und Organisation"
echo "[+] Name der Sammlung: $COLLECTION_NAME"
echo "[+] Suchbegriffe: $SEARCH_TERMS"

# Abhängigkeiten prüfen
wenn ! Befehl -v searchsploit &> /dev/null; dann
echo "[-] SearchSploit nicht gefunden. Bitte installieren Sie ExploitDB zuerst."
Ausgang 1
Fichte

# Bearbeiten Sie jeden Suchbegriff
IFS=',' read -ra TERMS ```SEARCH_TERMS
für den Begriff "$\{TERMS[@\\}"; tun
    # Trim whitespace
Begriff=$(echo "$term"|xargs)
Collect_exploits "$term"
erledigt

# Sammelindex und Archiv erstellen
erstellen_collection_index
create_portable_collection

echo "[+] Exploit Sammlung abgeschlossen"
Echo "[+] Ergebnisse gespeichert in: $OUTPUT_DIR"
echo "[+] $OUTPUT_DIR/collection_index.html zur Übersicht öffnen"

Continuous Monitoring for New Exploits

#!/bin/bash
# Kontinuierliche Überwachung neuer Exploits

CONFIG_FILE="exploit_monitoring.conf"
LOG_DIR="exploit_monitoring_logs"
ALERT_EMAIL="security@company.com"
CHECK_INTERVAL=3600 # 1 Stunde

mkdir -p "$LOG_DIR"

# Standardkonfiguration erstellen
wenn [ ! -f "$CONFIG_FILE" ]; dann
"$CONFIG_FILE" << "EOF"
# Konfiguration der Überwachung nutzen

# Überwachungsziele (eines pro Zeile)
MONITOR_TARGETS="
Apache
Nginx
WordPress
PHP
Windows 10
Linux-Kernel
OpenSSL
"

# Alarmeinstellungen
ALERT_ON_NEW_EXPLOITS=true
ALERT_ON_HIGH_SEVERITY=true
MINIMUM_SEVERITY_THRESHOLD=5

# Datenbankeinstellungen
UPDATE_DATABASE=true
UPDATE_INTERVAL=86400 # 24 Stunden

# Benachrichtigungseinstellungen
EMAIL_ALERTS=true
SLACK_WEBHOOK="
DISCORD_WEBHOOK="
EOF
echo "Created $CONFIG_FILE - bitte Kontrolleinstellungen konfigurieren"
Ausgang 1
Fichte

Quelle "$CONFIG_FILE"

# Funktion zum Update ExploitDB
update_database() \{
echo "[+] Updating ExploitDB Datenbank"

lokale update_log="$LOG_DIR/database_update_$(date +%Y%m%d_%H%M%S).log"

Suchanfrage -u > "$update_log" 2>&1

wenn [ $? -eq 0]; dann
Echo " [+] Datenbank erfolgreich aktualisiert"
Rückkehr 0
andere
Echo " [-] Datenbank-Update fehlgeschlagen"
Rückkehr 1
Fichte
{\cHFFFF}

# Funktion, um neue Exploits zu überprüfen
Check_new_exploits()
lokale Ziel="$1"
Lokale Zeitstempel=$(date +%Y%m%d_%H%M%S)
lokal current_results="$LOG_DIR/$\{target\}_$\{timestamp\}.json"
lokale vorherige_results="$LOG_DIR/$\{target\}_previous.json"

echo "[+] Suche nach neuen Exploits: $target"

    # Get current exploits
searchsploit -j "$target" > "$current_results"

wenn [ ! -s "$current_results" ]; dann
Echo " [-] Keine Exploits gefunden für: $target"
Rückkehr 1
Fichte

    # Compare with previous results
wenn [ -f "$previous_results" ]; dann
        # Extract exploit IDs
Lokal current_ids=$(jq -r '.RESULTS_EXPLOIT[]?.["EDB-ID"]" "$current_results" 2>/dev/null|sort)
lokale vorherige_ids=$(jq -r '.RESULTS_EXPLOIT[]?.["EDB-ID"]" "$previous_results" 2>/dev/null|sort)

        # Find new exploits
lokal new_exploits=$(comm -23 <(echo "$current_ids") <(echo "$previous_ids")

wenn [ -n "$new_exploits" ]; dann
lokal new_count=$(echo "$new_exploits"|wc -l)
Echo " [!] gefunden $new_count neue Exploits für: $target"

            # Get details of new exploits
lokal new_exploits_details="$LOG_DIR/$\{target\}_new_$\{timestamp\}.json"

Python3 << EOF
Import json

# Aktuelle Ergebnisse anzeigen
mit offen('$current_results', 'r') als f:
Daten = json.load(f)

Exploits = data.get('RESULTS_EXPLOIT', [])
new_ids = ""$new_exploits""".strip().split('\n')

# Neue Exploits filtern
new_exploits = [e für e in Exploits, wenn e.get('EDB-ID') in new_ids]

# Neue Exploits speichern
mit offen('$new_exploits_details', 'w') als f:
json.dump(new_exploits, f, indent=2)

print(f"Neue Exploits gespeichert: $new_exploits_details")
EOF

            # Send alert
wenn [ "$ALERT_ON_NEW_EXPLOITS" = "true" ]; dann
send_alert "NEW_EXPLOITS" "$target" "$new_count" "$new_exploits_details"
Fichte

Rückkehr 0
andere
Echo " [+] Keine neuen Exploits gefunden für: $target"
Fichte
andere
Echo " [+] Erster Scan für: $target"
Fichte

    # Update previous results
cp "$current_results" "$previous_results"

Rückkehr 0
{\cHFFFF}

# Funktion zur Beurteilung der Schwere
Bewertung(') \{
lokale Exploits_file="$1"
lokale Ziel="$2"

Python3 << EOF
Import json

versuchen:
mit open('$exploits_file', 'r') als f:
nutzt = json.load(f)

falls nicht instance(exploits, list):
Exploits = Exploits.get('RESULTS_EXPLOIT', [])

    # Severity scoring
severity_score = 0
High_severity_count = 0

zur Nutzung in Exploits:
Titel = Ausbeute.get('Title', '').lower()
Ausbeute_type = Ausbeute.get('Typ', '').lower()

        # High severity indicators
wenn ein(Schlüsselwort im Titel für Stichwort in ['remote', 'rce', 'buffer overflow', 'privilege escalation']):
severity_score += 3
High_severity_count += 1
elif 'remote' in Ausbeute_type:
severity_score += 2.
High_severity_count += 1
elif any(keyword im Titel für Stichwort in ['dos', 'denial of service']):
severity_score += 1
andere:
severity_score += 0,5 mg/kg

print(f"Severity score: \{severity_score\}")
print(f"High severity Exploits: \{high_severity_count\}")

    # Check threshold
wenn severity_score >= $MINIMUM_SEVERITY_THRESHOLD:
Print("ALERT_THRESHOLD_EXCEEDEDED")

mit Ausnahme von e:
print(f"Error Bewertung der Schwere: \{e\}")
EOF
{\cHFFFF}

# Funktion, Alarme zu senden
send_alert() \{
lokal alert_type="$1"
lokale Ziel="$2"
Ortszahl ="$3"
lokale details_file="$4"

lokales Subjekt="[EXPLOIT ALERT] $alert_type: $target"
lokale Nachricht="Alert: $count neue Exploits gefunden für $target bei $(date)"

Echo "[!] Alarm senden: $subject"

    # Email alert
wenn [ "$EMAIL_ALERTS" = "true" ] && [ -n "$ALERT_EMAIL"]
wenn [ -f "$details_file" ]; dann
| echo "$message" | mail -s "$subject" -A "$details_file" "$ALERT_EMAIL" 2>/dev/null |  | \ |
Echo "E-Mail-Benachrichtigung versagt"
andere
| echo "$message" | mail -s "$subject" "$ALERT_EMAIL" 2>/dev/null |  | \ |
Echo "E-Mail-Benachrichtigung versagt"
Fichte
Fichte

    # Slack alert
wenn [ -n "$SLACK_WEBHOOK" ]; dann
curl -X POST -H 'Content-Typ: Anwendung/json' \
--data "\{\"text\":\"$subject: $message\"\}" .
| "$SLACK_WEBHOOK" 2>/dev/null |  | echo "Schwarzer Alarm versagt" |
Fichte

    # Discord alert
wenn [ -n "$DISCORD_WEBHOOK"]; dann
curl -X POST -H 'Content-Typ: Anwendung/json' \
--data "\{\"content\":\"$subject: $message\"\}" .
| "$DISCORD_WEBHOOK" 2>/dev/null |  | echo "Discord Alarm versagt" |
Fichte
{\cHFFFF}

# Funktion zur Erstellung von Überwachungsberichten
erzeugen_monitoring_report() \{
echo "[+] Überwachungsbericht generieren"

Lokal report_file="$ LOG_DIR/monitoring_report_$(date +%Y%m%d).html"

Python3 << EOF
Import json
Import glob
Einfuhr
ab Datum Einfuhrdatum, Zeitdelta
aus Sammlungen import defaultdict

# Daten zur Überwachung sammeln
monitor_data = defaultdict(list)
Gesamt_new_explot = 0

# Alle neuen Exploit Dateien aus den letzten 24 Stunden finden
cutoff_time = datetime.now() - timedelta(hours=24)

für new_file in glob.glob('$LOG_DIR/*_new_*.json'):
versuchen:
        # Extract timestamp from filename
Dateiname = os.path.basename(new_file)
timestamp_str = filename.split('_new_')[1].replace('.json', '')
file_time = datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S')

wenn Datei_Zeit >= Cutoff_time:
            # Extract target name
Ziel = Dateiname.split('_new_')[0]

mit open(new_file, 'r') als f:
nutzt = json.load(f)

monitor_data[target].extend(exploits)
total_new_exploits += len(exploits)

ausgenommen:
weiter

# HTML-Bericht erstellen
html_content = f"""
<! DOCTYPE html>
< html
< Kopf >
<title>Exploit Monitoring Report</title>

</Kopf >
<= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <= <=
<div class="header">
<h1>Exploit Monitoring Report</h1>
<p>Generiert: \{datetime.now().strftime('%Y%m%d %H:%M:%S')\}</p>
<p>Monitoring Period: Letzte 24 Stunden</p>
</div>

<div class="alert">
<h2>>
<p>strong>Gesamt Neue Explosivstoffe:</strong> \{total_new_exploploits\}</p>
<p>>strong>Betroffene Ziele:</strong> \{len(monitoring_data)\}</p>
</div>
""

wenn Monitoring_data:
html_content += "<h2>New Explos by Target</h2>

für Ziel, nutzt in monitor_data.items():
html_content += f"""
<div class="target">
<===============
<p>strong>Neue Explosivstoffe:</strong> \{len(exploits)\}</p>

<= <= <= <= <= <= <============================================================================
<tr>> Titel</th>>th>Platform</th>>th>Typ</th>th> Datum</th>
""

für Exploit in Exploits[:10]: # Top 10 anzeigen
html_content += f"""
Insgesamt
<td>a href="https://www.exploit-db.com/exploits/\{exploit.get('EDB-ID', '')\"
<td>\{exploit.get('Title', ''')\}/td>
<td>\{exploit.get('Platform', '')\}/td>
<td>\{exploit.get('Typ', '')\}/td>
<td>\{exploit.get('Date', '')\}>/td>
</tr>
""

html_content += ""
</Tabelle >
</div>
""
andere:
html_content += ""
<div class="target">
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >
<p> Keine neuen Exploits wurden in den letzten 24 Stunden für überwachte Ziele nachgewiesen.</p>
</div>
""

html_content += ""
</Körper >
</html>
""

mit open('$report_file', 'w') als f:
f.write(html_content)

Druck(f)[+] Monitoring-Bericht generiert: $report_file")
EOF
{\cHFFFF}

# Funktion zur Reinigung von alten Protokollen
Sauberkeit() \{
echo "[+] Reinigung von alten Überwachungsprotokollen"

    # Keep logs for 30 days
"$LOG_DIR" -Name "*.json" -Zeit +30 -delete
"$LOG_DIR" -Name "*.log" -Zeit +30 -delete
"$LOG_DIR" -Name "*.html" -Zeit +7 -delete
{\cHFFFF}

# Hauptüberwachungsschleife
echo "[+] Dauerbetriebsüberwachung starten"
Echo "[+] Prüfintervall: $((CHECK_INTERVAL / 60) Minuten)"

Letzter Beitrag

während wahr; tun
echo "[+] Beginn des Monitoringzyklus bei $(date)"

    # Update database if needed
aktuelle_time=$(date +%s)
wenn [ "$UPDATE_DATABASE" = "true" ] && [$((current_time - last_update))) -ge $UPDATE_INTERVAL ]; dann
wenn update_database; dann
last_update=$current_time
Fichte
Fichte

    # Check each monitored target
echo "$MONITOR_TARGETS"ilewhile read -r target; do
        # Skip empty lines
[ -z "$target" ] &gt; weiter

check_new_exploits "$target"
erledigt

    # Generate daily report and cleanup
erzeugen_monitoring_report
Sauberkeit_logs

echo "[+] Überwachungszyklus abgeschlossen bei $(date)"
echo "[+] Nächster Check in $(CHECK_INTERVAL / 60) Minuten)"

Schlaf "$CHECK_INTERVAL"
erledigt

Integration with Security Tools

Metasploit Integration

# Suche nach Metasploit-Modulen mit SearchSploit
suchsploit metasploit apache

# Exploits mit Metasploit-Modulen finden
| searchsploit -j apache | jq -r '.RESULTS_EXPLOIT[] | select(.Title | contains("Metasploit"))..["EDB-ID"] ' |

# Cross-Referenz mit Metasploit Datenbank
msfconsole -q -x "Suche edb:12345; Ausfahrt"

Nmap Integration

# Verwenden Sie SearchSploit mit Nmap-Scanergebnissen
nmap -sV Target.com|grep -E "^[0-9]+/tcp"ilewhile Lesezeile; tun
service=$(echo "$line"|awk '\{print $3\}')
version=$(echo "$line"|awk '\{print $4" "$5\}')
echo "Searching Exploits für: $service $version"
searchsploit "$service $version"
erledigt

# Nmap-Skript erstellen mit SearchSploit
Kat > searchsploit.nse << 'EOF'
lokale nmap = benötigen "nmap"
Local shortport = erfordern "shortport"
lokale stdnse = erfordern "stdnse"

Beschreibung
SuchSploit verwendet, um Exploits für erkannte Dienste zu finden.
!

Autor = "Security Researcher"
Lizenz = "Same as Nmap-See https://nmap.org/book/man-legal.html"
Kategorien = \{"Entdeckung", "sicher"\}

portrule = shortport.version_port_or_service()

Aktion = Funktion(Host, Port)
Lokaler Service = port.service
lokale Version = port.version

wenn Service und Version dann
lokal cmd = String. format("searchsploit '%s%s'", service, version.version oder "")
lokales Ergebnis = os.execute(cmd)
zurück string.format("SearchSploit query: %s", cmd)
Ende

zurück zur Übersicht
Ende
EOF

Burp Suite Integration

# Export SearchSploit Ergebnisse für Burp Suite
| searchsploit -j webjjq -r '.RESULTS_EXPLOIT[] | select(.Type | contains("webapps")) | .Title" > burp_payloads.txt |

# Burp Suite Erweiterung Payload-Liste erstellen
| searchsploit --type webapps -j | jq -r '.RESULTS_EXPLOIT[] | .["EDB-ID"]' | while read id; do |
Suchanfrage -m "$id" -o /tmp/burp_exploits/
erledigt

Troubleshooting

Common Issues

Database Problems

# Datenbank nicht gefunden
Suchanfragen --path
ls -la /opt/exploitdb/

# Rebuild Datenbank
Suchanfragen -- rebuild

# Berechtigungen reparieren
sudo chown -R $USER:$USER /opt/exploitdb/

# Manuelles Datenbank-Update
cd /opt/exploitiert &amp; git Zug

Search Issues

# Keine Ergebnisse gefunden
Suchanfragen - Check
Suche --stats

# Löschen Cache
rm -rf ~/.searchsploit_cache

# Suche nach Debug
searchsploit --debug apache

# Suchbegriffe anzeigen
searchsploit -e "exact match"
searchsploit -i "case insensitive"

File Access Problems

# Genehmigung verweigert
Sudo chmod +x /opt/exploitdb/searchsploit

# Datei nicht gefunden
Suche -p 12345
ls -la /opt/exploitdb/exploitiert/

# Probleme mit dem Kopieren
Suche -m 12345 -o /tmp/
ls -la /tmp/

Performance Issues

# Langsame Suche
searchsploit --platform linux apache # Limit Plattform
searchsploit -t apache # Titel nur
suchsploit apache|head -20 # Limit Ergebnisse

# Große Datenbank
du -sh /opt/exploitiert
git gc --aggressive # Cleanup git repo

# Speicherprobleme
ulimit -v 1000000 # virtueller Speicher begrenzen

Resources

This cheat sheet provides a comprehensive reference for using SearchSploit for exploit research and vulnerability assessment. Always ensure you have proper authorization before using any exploits in any environment.

Filter by specific platforms

searchsploit apache|grep -i linux searchsploit apache|grep -i windows

Filter by exploit type

searchsploit apache|grep -i remote searchsploit apache|grep -i local

Sort by date (newest first)


### Suchergebnisanalyse