\{platform\}
html_content += ""
< >
< >
Valutazione dell'obiettivo individuale
""
# Aggiungi i dettagli del target
per l'analisi in ordine (all_analyses, key=lambda x: x.get('total_exploits', 0), reverse=True):
gravità = analisi.get('severity_assessment', 'Unknown').lower()
target = analysis.get('target', 'Unknown')
html_content += f"
Traduzione:
Traduzione:
> Livello di rischio: \{analysis.get('severity_assessment', 'Unknown')
< > > Totale Sfruttamento: \{analysis.get('total_exploits', 0)\}
ι > Esplicazioni ad alta priorità: ι > > > > > > > > > > > > > > > > > ι > > > > > ι > ι > ι > ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι ι
Ripartizione della forma:
*
> > Platform < / > > > > > > > > > > > > > > > > > > > > > > > > > > >
""
per piattaforma, conteggio in analisi.get('platforms', \{\}).items():
html_content += f" \{platform\}
html_content += ""
< >
< >
""
html_content += f"
< >
< >
""
con apertura('$REPORT_FILE', 'w') come f:
f.write (html_content)
stampa(f)[+] Rapporto completo generato: $REPORT_FILE")
EOF
#
# Funzione per generare sommario CSV
genera_csv_summary()
echo "[+] Generando sommario CSV"
csv_file="$OUTPUT_DIR/vulnerability_summary.csv"
eco "Target,Total_Exploits, Totale_Codici dello schermo,Severity,High_Priority_Exploits,Top_Platform,Top_Type" > "$csv_file"
per analisi_file in "$OUTPUT_DIR"/*/analysis.json; do
se [ -f "$analysis_file" ]; allora
Python
importazione json
con aperto('$analysis_file', 'r') come f:
dati = json.load(f)
target = data.get('target', 'Unknown').replace(',', ';'
Total_exploits = data.get('total_exploits', 0)
Total_shellcodes = data.get('total_shellcodes', 0)
gravità = data.get('severity_assessment', 'Unknown')
(data.get('high_priority_exploits', []))
piattaforme = data.get('platforms', \{\})
top_platform = max(platforms.keys(), key=lambda k: piattaforme[k]) se piattaforme altre 'Unknown'
tipi = data.get('types', \{\})
top_type = max(types.keys(), key=lambda k: type[k]) se tipi "Unknown"
(f)\{target\},\{total_exploits\},\{total_shellcodes\},\{severity\},\{high_priority\},\{top_platform\},\{top_type\}]
EOF
#
> > "$csv_file"
echo "[+] CSV sommario generato: $csv_file"
#
# Esecuzione principale
echo "[+] Avviare la valutazione automatizzata delle vulnerabilità"
echo "[+] Lista di destinazione: $TARGET_LIST"
echo "[+] directory di output: $OUTPUT_DIR"
# Controllare le dipendenze
Se! comando -v searchsploit &> /dev/null; poi
echo "[-] SearchSploit non trovato. Si prega di installare ExploitDB prima."
uscita 1
#
# Elaborare ogni obiettivo
Totale_targets=0
successo_assessments=0
mentre legga -r bersaglio; fare
# Skip empty lines and comments
| [[ -z "$target" | | "$target" =~ ^#.*$ ]] < continuare |
Total_targets=$(total_targets + 1))
se valuta_target "$target"; allora
successo_valutazioni=$(successo_valutazioni + 1))
#
# Small delay to avoid overwhelming the system
sonno 1
)
echo "[+] Valutazione completata
echo " Total targets: $total_targets"
echo " Valutazione di successo: $successful_assessments"
# Genera report
genera_report
genera_csv_summary
echo "[+] Valutazione della vulnerabilità completata"
echo "[+] Risultati salvati in: $OUTPUT_DIR"
echo "[+] Aprire $REPORT_FILE per un report dettagliato"
Traduzione:
#!/bin/bash
# Raccolta e organizzazione di exploit automatizzati
COLLECTION_NAME="$1"
SEARCH_TERMS="$2"
FUORI_DIR="exploit_collection_$\{COLLECTION_NAME\}_$ +% Y%m%d_%H%M%S)"
| se [ -z "$COLLECTION_NAME" ] | | [ -z "$SEARCH_TERMS"]; allora |
eco "Usage: $0 "
echo "Esempio: $0 'web_exploits' 'php, apache,nginx,wordpress'"
uscita 1
#
mkdir -p "$OUTPUT_DIR"
# Funzione per raccogliere gli exploit per il termine di ricerca
Raccolta delle informazioni()
ricerca locale_term="$1"
term_dir="$OUTPUT_DIR/$(echo "$search_term"|tr ' /' '_')"
echo "[+] Raccogliere exploit per: $search_term"
mkdir -p "$term_dir"
# Search and save results
ricercasploit -j "$search_term" > "$term_dir/search_results.json"
se [! -s "$term_dir/search_results.json" ]; allora
eco " [-] Nessun exploit trovati per: $search_term"
ritorno 1
#
# Parse and categorize exploits
Python
importazione json
importazione
da collezioni importare defaultdict
# Leggi i risultati della ricerca
con aperto('$term_dir/search_results.json', 'r') come f:
dati = json.load(f)
sfrutta = data.get('RESULTS_EXPLOIT', [])
stampa(f) [+] Trovato \{len(exploits)\} exploits for $search_term")
# Categorizzare gli exploit
categorie = {}
[],
[],
[],
[],
[],
[],
[],
# Last 2 years
#
per lo sfruttamento nelle imprese:
exploit_type = exploit.get('Type', '').lower()
piattaforma = exploit.get('Platform', '').lower()
titolo = exploit.get('Title', '').lower()
data = exploit.get('Date', '')
# Categorize by type
se 'remote' in exploit_type:
categorie['remote'].append(exploit)
elif 'local' in exploit_type:
categorie['local'].append(exploit)
elif 'webapps' in exploit_type:
categorie['webapps'].append(exploit)
elif 'dos' in exploit_type:
categorie['dos'].append(exploit)
# Categorize by platform
se 'finestre' in piattaforma:
categorie['windows'].append(exploit)
elif 'linux' in piattaforma:
categorie['linux'].append(exploit)
elif 'php' in piattaforma:
categorie['php'].append(exploit)
# Check if recent (last 2 years)
se la data:
anno = int(date.split('-')[0])
se anno >= 2022: # Regolare in base all'anno corrente
categorie['recent'].append(exploit)
# Salvare i dati categorizzati
per categoria, exploits_list in categorie.items():
se exploits_list:
categoria_dir = f'$term_dir/\{category\} '
os.makedirs(category_dir, exist_ok=True)
con apertura (f'\{category_dir\}/exploits.json', 'w') come f:
json.dump(exploits_list, f, indent=2)
# Create download list
con apertura (f'\{category_dir\}/download_list.txt', 'w') come f:
per exploit in exploits_list[:20]: # Limita a 20 per categoria
f.write(f)\{exploit.get('EDB-ID', '')\\\n)
stampa(f) [+] \{category\}: \{len(exploits_list)\} exploits)
stampa(f) [+] Categorizzazione completata per $search_term")
EOF
# Download exploits by category
per categoria_dir in "$term_dir"/*; do
se [ -d "$category_dir" ] && [-f "$category_dir/download_list.txt" ]; allora
categoria_name=$(nome base "$category_dir")
echo " [+] Scarica $category_name exploits"
mentre legga -r edb_id; do
se [ -n "$edb_id"]; allora
ricercasploit -m "$edb_id" -o "$category_dir/" 2>/dev/null
#
< "$category_dir/download_list.txt"
#
Fatto
ritorno 0
#
# Funzione per creare indice di raccolta
creare_collection_index()
echo "[+] Creare indice di raccolta"
local index_file="$OUTPUT_DIR/collection_index.html"
Python
importazione json
importazione
importazione globo
da datatime import datetime
da collezioni importare defaultdict
# Raccogli tutti i dati di exploit
All_exploits = []
term_stats = defaultdict(lambda: defaultdict(int)
per risultati_file in glob.glob('$OUTPUT_DIR/*/search_results.json'):
term_name = os.path.basename(os.path.dirname(results_file))
prova:
con aperto (results_file, 'r') come f:
dati = json.load(f)
sfrutta = data.get('RESULTS_EXPLOIT', [])
all_exploits.extend(exploits)
# Calculate statistics
term_stats[term_name]['total'] = len(exploits)
per lo sfruttamento nelle imprese:
piattaforma = exploit.get('Platform', 'Unknown')
exploit_type = exploit.get('Type', 'Unknown')
term_stats[term_name]['platforms'][platform] += 1
term_stats[term_name]['types'][exploit_type] += 1
eccetto:
continuare
# Generare l'indice HTML
html_content = f""
Oh! DOCTYPE html
Traduzione:
<
Exploit Collection: $COLLECTION_NAME
< >
*
Traduzione:
Collezione: COLLECTION_NAME
Generated: \{datetime.now().strftime('%Y-%m-%d %H:%M:%S')\}
Termini di ricerca: Traduzione:
< >
>
Traduzione:
\{len(all_exploits)\
> < > > > > > > > > > > > > > > > > > > > > > > > < > > > > > > > > > > > > > > > > > > < > > > < > > > > > > > > > > > > > > > > > < > > > > > > < > > > > > > > > > > > < > > > > > > > > > < < > > > > > > < > > > > > > > > > > > > > > > > > > > > > > >
< >
Traduzione:
\{len(term_stats)\}
Termini di ricerca
< >
Traduzione:
\{len(set(e.get('Platform', 'Unknown') per e in all_exploits)
Platforms
< >
Traduzione:
\{len(set(e.get('Type', 'Unknown') per e in all_exploits)
Tipologie di distribuzione
< >
< >
Contenuto della colonna
""
# Aggiungi i dettagli per ogni termine di ricerca
per term_name, statistiche in term_stats.items():
html_content += f"
>
< > > > > > > > > > > > > > > > > > > > < > > > > > > > > > > > > > > > > > > > > > > > > > < > > > < > > > > > > > > > > > > > > > > < > > > > > > > > > > > > > > > > > > > > > > > > > > > > > < < > > > > > > < > > > > > > > > > > > > > > > > > > > > > >
< < > > Totale Sfruttamento: < > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ι > > > > < > > ι > > > > > > > > > > > > > < > > > > > > < > > > > > > > > < > > > > > > > > > > < > > > < > > > > > > < > > > > > > > > > > > > > > > < > > > > > > Traduzione:
Categories Disponibile:
""
# List available categories
term_dir = f"$OUTPUT_DIR/\{term_name\}"
per categoria in ['remote', 'local', 'webapps', 'dos', 'windows', 'linux', 'php', 'recent']:
categoria_percorso = f"\{term_dir\}/\{category\}"
se os.path.exists(category_path):
exploit_count = 0
prova:
con apertura(f)\{category_path\}/exploits.json, 'r') come f:
sfrutta = json.load(f)
exploit_count = len(exploits)
eccetto:
pass
html_content += f"
< > > > > > > > >
\{exploit_count\} sfrutta
< >
""
html_content += ""
< >
< >
""
html_content += ""
Istruzioni per l'uso
>
< > Struttura della direzione
*
< > > > > > > > > > > > > > > > > > > > < > > > > > > > > > > > > > > > > > > > > > < > > > < > > > < > > > > > > > > > > > > < > > > < > > > < > > < > > > > > > > > > < > > > > > > > > > < < > < < > > > > > > > > > > > > < > > > > > > > > > < < > > > > > - Risultati del termine di ricerca individuale
< > > > ricerca/categoria/ < > > - Sfruttati categorizzati per tipo/piattaforma
> > ricerca_term/category/exploits.json - Esplodere metadati
> Ricerca/categoria/[EDB-ID].* - File di exploit scaricati
< >
Comandi di accesso rapidi
Preferito
# Visualizza tutti gli exploit remoti
trovare. -name "remote" -type d
# Elenca tutti i file di exploit scaricati
-name "*.c" -o -name "*.py" -o -name "*.rb" -o -name "*.pl"
# Ricerca all'interno della raccolta
grep -r "buffer overflow" .
# Conteggio sfrutta per tipo
trovare. -name "exploits.json" -exec jq -r '. - C
< >
< >
< >
< >
""
con aperto('$index_file', 'w') come f:
f.write (html_content)
stampa(f)[+] Indice di raccolta generato: $index_file")
EOF
#
# Funzione per creare una collezione portatile
creare_portable_collection() *
echo "[+] Creazione di archivio di raccolta portatile"
archivio locale_name="$\{COLLECTION_NAME\}_exploit_collection_$(data +%Y%m%d).tar.gz"
# Create README
> "$OUTPUT_DIR/README.md" <
# Collezione Exploit: $COLLECTION_NAME
Generato: $(data)
Termini di ricerca: $SEARCH_TERMS
## Struttura del repertorio
- **Ricerca_term/** Risultati del termine di ricerca individuale
- ** Ricerca/categoria/** Sfruttati categorizzati per tipo/piattaforma
- ** Ricerca/categoria/esplosi. I metadati dell'esplosione
- **Cerca/categoria/[EDB-ID]. File di exploit scaricati
## Categorie
- **remote**: exploit di esecuzione del codice remoto
- **local**: sfrutta l'escalation dei privilegi locali
- **webapps**: exploit delle applicazioni Web
- **dos**: negazione degli exploit di servizio
- **finestre**: exploit specifici di Windows
- **linux**: exploit Linux-specifici
- **php**: exploit specifici per PHP
- **recent**: exploit recenti (ultimi 2 anni)
## Utilizzo
1. Estrarre l'archivio nella posizione desiderata
2. Open collection_index.html per una panoramica
3. Navigare a categorie specifiche per gli exploit mirati
4. Verificare il codice exploit prima dell'uso
5. Assicurarsi una corretta autorizzazione prima di testare
## Avviso legale
Questi exploit sono forniti solo per scopi di test educativi e autorizzati.
Usa solo contro i sistemi che possiedi o hai esplicito permesso scritto per testare.
L'uso non autorizzato può violare leggi e regolamenti locali.
EOF
# Create archive
tar -czf "$archive_name" -C "$(dirname "$OUTPUT_DIR")" "$(basename "$OUTPUT_DIR")"
echo "[+] Collezione portatile creata: $archive_name"
echo " Dimensione archivio: $(du -h "$archive_name"|cut -f1)"
#
# Esecuzione principale
echo "[+] Iniziare la raccolta e l'organizzazione di exploit"
echo "[+] Nome della collezione: $COLLECTION_NAME"
echo "[+] Termini di ricerca: $SEARCH_TERMS"
# Controllare le dipendenze
Se! comando -v searchsploit &> /dev/null; poi
echo "[-] SearchSploit non trovato. Si prega di installare ExploitDB prima."
uscita 1
#
# Elaborare ogni termine di ricerca
IFS='',' read -ra TERMS ` `` П < < Пoдия "$SEARCH_TERMS"
per termine "$\{TERMS[@]\}"; do
# Trim whitespace
term=$(echo "$term"|xargs)
Collect_exploits "$term"
Fatto
# Crea indice di raccolta e archivio
creare_collection_index
creare_portable_collection
echo "[+] Collezione Exploit completata"
echo "[+] Risultati salvati in: $OUTPUT_DIR"
echo "[+] Aprire $OUTPUT_DIR/collection_index.html per la panoramica"
Traduzione:
#!/bin/bash
# Monitoraggio continuo per nuove imprese
CONFIG_FILE="exploit_monitoring.conf"
LOG_DIR="exploit_monitoring_logs"
ALERT_EMAIL="security@company.com"
CHECK_INTERVAL=3600 # 1 ora
mkdir -p "$LOG_DIR"
# Creare la configurazione predefinita
Se...
> ``$CONFIG_FILE' <
# Sfrutta la configurazione di monitoraggio
# Obiettivi di monitoraggio (uno per linea)
MONITOR_TARGETS="
Apache
No.
WordPress
PHP
Windows 10
Linux kernel
OpenSSL
"
# Impostazioni di avviso
ALERT_ON_NEW_EXPLOITS=true
ALERT_ON_HIGH_SEVERITY=true
MINIMUM_SEVERITY_THRESHOLD=5
# Impostazioni del database
UPDATE_DATABASE=true
UPDATE_INTERVAL=86400 # 24 ore
# Impostazioni di notifica
EMAIL_ALERTS=true
#
DISCORD_WEBHOOK="
EOF
echo "Created $CONFIG_FILE - configurare le impostazioni di monitoraggio"
uscita 1
#
fonte "$CONFIG_FILE"
# Funzione per aggiornare ExploitDB
aggiornamento_database()
echo "[+] Aggiornamento database ExploitDB"
aggiornamento locale_log="$LOG_DIR/database_update_$(data +% Y%m%d_%H%M%S).log"
ricercasploit -u > "$update_log" 2>&1
Se...
echo " [+] Database aggiornato con successo"
ritorno 0
Altro
eco " [-] Aggiornamento database fallito"
ritorno 1
#
#
# Funzione per verificare nuovi exploit
)
target locale="$1"
timestamp locale=$(data +%Y%m%d_%H%M%S)
corrente locale_results="$LOG_DIR/$\{target\}_$\{timestamp\}.json"
locale precedente_results="$LOG_DIR/$\{target\}_previous.json"
echo "[+] Controllare nuovi exploit: $target"
# Get current exploits
ricercasploit -j "$target" > "$current_results"
Se...
eco " [-] Nessun exploit trovati per: $target"
ritorno 1
#
# Compare with previous results
se [ -f "$previous_results" ]; allora
# Extract exploit IDs
corrente locale_ids=$(jq -r '.RESULTS_EXPLOIT[]?.["EDB-ID"]'"$current_results" 2>/dev/null|sort)
locale precedente_ids=$(jq -r '.RESULTS_EXPLOIT[]?.["EDB-ID"]"$previous_results" 2>/dev/null|sort)
# Find new exploits
locale new_exploits=$(comm -23 <(echo "$current_ids") <(echo "$previous_ids"))
se [ -n "$new_exploits"]; allora
locale new_count=$(echo "$new_exploits"|wc -l)
echo " [!] Trovato $new_count nuovi exploit per: $target"
# Get details of new exploits
nuovi_exploits_details="$LOG_DIR/$\{target\}_new_$\{timestamp\}.json"
Python
importazione json
# Leggi i risultati attuali
con apertura('$current_results', 'r') come f:
dati = json.load(f)
sfrutta = data.get('RESULTS_EXPLOIT', [])
new_ids = ""$new_exploits"".strip().split('\n')
# Filtra nuovi exploits
new_exploits = [e per e in exploits if e.get('EDB-ID') in new_ids]
# Salvare nuovi exploit
con apertura('$new_exploits_details', 'w') come f:
json.dump(new_exploits, f, indent=2)
print(f"Nuovi exploit salvati: $new_exploits_details")
EOF
# Send alert
se ["$ALERT_ON_NEW_EXPLOITS" = "true" ]; allora
send_alert "NEW_EXPLOITS" "$target" "$new_count" "$new_exploits_details"
#
ritorno 0
Altro
echo " [+] Nessun nuovo exploit trovati per: $target"
#
Altro
echo " [+] Prima scansione per: $target"
#
# Update previous results
cp "$current_results" "$previous_results"
ritorno 0
#
# Funzione per valutare la gravità dello sfruttamento
valutazione()
locali exploits_file="$1"
target locale="$2"
Python
importazione json
prova:
con aperto('$exploits_file', 'r') come f:
sfrutta = json.load(f)
se non è instance(esplorazioni, elenco):
exploits = exploits.get('RESULTS_EXPLOIT', [])
# Severity scoring
severity_score = 0
Alto_severity_count = 0
per lo sfruttamento nelle imprese:
titolo = exploit.get('Title', '').lower()
exploit_type = exploit.get('Type', '').lower()
# High severity indicators
se qualsiasi(parola chiave in titolo per parola chiave in ['remote', 'rce', 'buffer overflow', 'privilege escalation']):
Traduzione: 3
Condividi su Google 1
elif 'remote' in exploit_type:
Traduzione: 2
Condividi su Google 1
elif any(parola chiave in titolo per parola chiave in ['dos', 'denial of service']):
Traduzione: 1
Altro:
Traduzione: 0
stampa(f"Severity score: \{severity_score\}")
print(f"High severity exploits: \{high_severity_count\}
# Check threshold
se la gravità_score >= - Cosa?
stampa("ALERT_THRESHOLD_EXCEEDED")
eccetto l'eccezione come e:
stampa(f"Valutazione della gravità: \{e\}")
EOF
#
# Funzione per inviare avvisi
Inserzione()
locale alert_type="$1"
target locale="$2"
conta locale="$3"
dettagli locali_file="$4"
soggetto locale="[EXPLOIT ALERT] $alert_type: $target"
messaggio locale="Alert: $count new exploits found for $target at $(date)"
echo "[!] Avviso di invio: $subject"
# Email alert
se [$EMAIL_ALERTS] = "vero" ] && [ -n "$ALERT_EMAIL"]; allora
se [ -f "$details_file" ]; allora
| echo "$message" | mail -s "$subject" -A "$details_file" "$ALERT_EMAIL" 2>/dev/null | | \ |
echo "Email alert fail"
Altro
echo "$message"|mail -s "$subject" "$ALERT_EMAIL" 2>/dev/null
echo "Email alert fail"
#
#
# Slack alert
se [ -n "$SLACK_WEBHOOK" ]; allora
curl -X POST -H 'Content-type: applicazione/json' \
--dati "\"text\":\"$subject: $message\"\"\}" .
"$SLACK_WEBHOOK" 2>/dev/null "Slack alert fail"
#
# Discord alert
se [ -n "$DISCORD_WEBHOOK" ]; allora
curl -X POST -H 'Content-type: applicazione/json' \
--dati "\"content\":\"$subject: $message\"\"\}" .
"$DISCORD_WEBHOOK" 2>/dev/null "Discord alert fail"
#
#
# Funzione per generare report di monitoraggio
genera_monitoring_report()
echo "[+] Generando report di monitoraggio"
rapporto locale_file="$ LOG_DIR/monitoring_report_$(data +%Y%m%d).html"
Python
importazione json
importazione globo
importazione
da datatime import datetime, timedelta
da collezioni importare defaultdict
# Raccogli dati di monitoraggio
monitoraggio_data = defaultdict(list)
Total_new_exploits = 0
# Trova tutti i nuovi file exploit dalle ultime 24 ore
cutoff_time = datetime.now() - timedelta(hours=24)
per il nuovo_file in glob.glob('$LOG_DIR/*_new_*.json'):
prova:
# Extract timestamp from filename
nome file = 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')
se file_time >= cutoff_time:
# Extract target name
target = filename.split('_new_')[0]
con aperto(new_file, 'r) come f:
sfrutta = json.load(f)
monitoraggio_data[target].extend(exploits)
total_new_exploits += len(exploits)
eccetto:
continuare
# Generare report HTML
html_content = f""
Oh! DOCTYPE html
Traduzione:
<
Exploit Monitoring Report
< >
*
Traduzione:
Exploit Monitoring Report
Generated: \{datetime.now().strftime('%Y-%m-%d %H:%M:%S')\}
Monitoring Periodo: Ultimi 24 ore
< >
Traduzione:
Traduzione:
< < > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > < > > > < > > < > > > > > > > > > > > > > > > > > < > > > > > > > > > > > > > > > > > > > > > > > > > > < > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >
< > Destinazioni interessate: \{len(monitoring_data)\}
< >
""
se monitor_data:
html_content += " New Exploits by Target
per obiettivo, sfrutta in monitoraggio_data.items():
html_content += f"
Traduzione:
Traduzione:
> Nuovi sviluppi: \{len(exploits)\}
*
< > > > > > > > > > > Titolo Platform | > > > Data di assunzione / >
""
per exploit in exploits[:10]: # Mostra top 10
html_content += f"
>
< > > > > > > > > > > > > > > > > > > > > > > > > > > > >
| \{exploit.get('Title', '')\}
| \{exploit.get('Platform', '')\}
| \{exploit.get('Type', '')\}
| \{exploit.get('Date', ''')\}
<
""
html_content += ""
< >
< >
""
Altro:
html_content += ""
Traduzione:
✅ No Nuovi risultati
Non sono stati rilevati nuovi exploit nelle ultime 24 ore per gli obiettivi monitorati.
< >
""
html_content += ""
< >
< >
""
con apertura('$report_file', 'w') come f:
f.write (html_content)
stampa(f)[+] Rapporto di monitoraggio generato: $report_file")
EOF
#
# Funzione per pulire i vecchi registri
pulizia_logs()
echo "[+] Pulire vecchi registri di monitoraggio"
# Keep logs for 30 days
trovare "$LOG_DIR" -name "*.json" -mtime +30 -delete
trovare "$LOG_DIR" -name "*.log" -mtime +30 -delete
trovare "$LOG_DIR" -name "*.html" -mtime +7 - Destinazione
#
# Ciclo di monitoraggio principale
echo "[+] Avviare il monitoraggio continuo degli exploit"
echo "[+] intervallo di controllo: $(CHECK_INTERVAL / 60) minuti"
Traduzione:
mentre è vero; fare
echo "[+] Inizio ciclo di monitoraggio a $(data)"
# Update database if needed
corrente_time=$(data +%s)
se [$UPDATE_DATABASE" = "vero" ] && [$(current_time - last_update))) -ge $UPDATE_INTERVAL ]; allora
se update_database; allora
ultimo_update=$current_time
#
#
# Check each monitored target
echo "$MONITOR_TARGETS"|while read -r target; do
# Skip empty lines
Traduzione:
check_new_exploits "$target"
Fatto
# Generate daily report and cleanup
generare_monitoring_report
cleanup_logs
echo "[+] ciclo di monitoraggio completato a $(data)"
echo "[+] Successivo check in $(CHECK_INTERVAL / 60) minuti"
sonno "$CHECK_INTERVAL"
Fatto
Traduzione:
# Cerca moduli Metasploit utilizzando SearchSploit
ricercasploit metasploit apache
# Trova exploit con moduli Metasploit
| ricercasploit -j apache | jq -r '.RESULTS_EXPLOIT[] | select(.Title | contains("Metasploit")) | .["EDB-ID"] ' |
# Cross-reference con il database Metasploit
msfconsole -q -x "search edb:12345; exit"
Traduzione:
# Utilizzare SearchSploit con risultati della scansione Nmap
| nmap -sV target.com | grep -E "^[0-9]+/tcp" | while read line; do |
servizio=$(echo "$line"|awk '\{print $3\}')
versione=$(echo "$line"|awk '\{print $4" "$5\}')
eco "Ricerca degli exploit per: $service $version"
ricercasploit "$service $version"
Fatto
# Crea script Nmap utilizzando SearchSploit
cat > searchsploit.nse <
Nmap locale = richiedere "nmap"
shortport locale = richiedono "shortport"
stdnse locale = richiedono "stdnse"
descrizione = [[
Utilizza SearchSploit per trovare exploit per i servizi rilevati.
]
autore = "Security Researcher"
licenza = "Same as Nmap--See https://nmap.org/book/man-legal.html"
categorie = \{"scoperta", "sicuro"\}
portrule = shortport.version_port_or_service()
azione = funzione (host, port)
servizio locale = porto.service
versione locale = porta.version
se servizio e versione allora
cmd locale = stringa. formato("searchsploit '%s %s'", servizio, versione.version o "")
risultato locale = os.execute(cmd)
ritorno string.format("SearchSploit query: %s", cmd)
fine
Ritorno nil
fine
EOF
Traduzione:
# Risultati di Export SearchSploit per Burp Suite
| ricercasploit -j web | jq -r '.RESULTS_EXPLOIT[] | select(.Type | contains("webapps")) | .Title' > burp_payloads.txt |
# Creare Burp Suite estensione payload elenco
| ricercasploit --type webapps -j | jq -r '.RESULTS_EXPLOIT[] | .["EDB-ID"]' |
ricercasploit -m "$id" -o /tmp/burp_exploits/
Fatto
Traduzione:
# Database non trovato
ricercasploit --percorso
ls -la /opt/exploitdb/
# Ricostruire database
ricercasploit - Ricostruire
# Fissare le autorizzazioni
sudo chown -R $USER:$USER /opt/exploitdb/
# Aggiornamento manuale del database
cd /opt/exploitdb && git pull
Traduzione:
# Nessun risultato trovato
ricercasploit - Controllo.
ricercasploit --stats
# Cancella cache
rm -rf ~/.searchsploit_cache
# Ricerca del debito
ricercasploit --debug apache
# Verifica i termini di ricerca
searchsploit -e "exact match"
ricercasploit -i "case insensibile"
Traduzione:
# Permesso negato
sudo chmod +x /opt/exploitdb/sploit di ricerca
# File non trovato
ricercasploit -p 12345
ls -la /opt/exploitdb/exploits/
# Questioni di copia
ricercasploit -m 12345 -o /tmp/
ls -la /tmp/
Traduzione:
# Lente ricerche
searchsploit --platform linux apache # Limit platform
searchsploit -t apache # Title only
ricercasploit apache|head -20 # Risultati limite
# Grande database
du -sh /opt/exploitdb/
git gc --aggressiva # Cleanup git repo
# Problemi di memoria
ulimit -v 1000000 # Limita la memoria virtuale
Traduzione:
### Analisi dei risultati di ricerca
Traduzione:
## Gestione esplosiva
### Copiare e scaricare gli obiettivi
Traduzione:
### Visualizza e Esamina Esplosioni
#
### Organizzazione Exploit
Traduzione:
## Gestione dei database
### Aggiornamenti del database
Traduzione:
### Informazioni sul database
Traduzione:
### Manutenzione del database
Traduzione:
## Strumenti di automazione
### Vulnerabilità automatizzata Valutazione
Traduzione:
### Collezione Exploit e Organizzazione
Traduzione:
### Monitoraggio continuo per nuovi sviluppi
Traduzione:
## Integrazione con strumenti di sicurezza
### Integrazione Metasploit
Traduzione:
### Integrazione Nmap
Traduzione:
### Integrazione Burp Suite
Traduzione:
## Risoluzione dei problemi
### Questioni comuni
#### Problemi del database
Traduzione:
#### Problemi di ricerca
Traduzione:
#### Problemi di accesso ai file
Traduzione:
### Problemi di prestazione
Traduzione:
## Risorse
- [SearchSploit GitHub Repository](__LINK_9__)
- [ExploitDB Website](___LINK_9__)
- [Documentazione di sicurezza offensiva](__LINK_9__)
- [SearchSploit Manual](___LINK_9__)
- [Exploit Development Resources](__LINK_9__)
- [CVE Database]
- [Database di vulnerabilità nazionale](__LINK_9__]
---
*Questo foglio di scacchi fornisce un riferimento completo per l'utilizzo SearchSploit per la ricerca di exploit e la valutazione della vulnerabilità. Assicurarsi sempre di avere una corretta autorizzazione prima di utilizzare qualsiasi exploit in qualsiasi ambiente. *
| | |