Come ho già ribadito più volte, la sicurezza è fondamentale in qualsiasi contesto. La puoi applicare a qualsiasi cosa (sicurezza della Terra, sicurezza dello Stato, sicurezza nell’informatica, sicurezza della tua casa).
Qualsiasi cosa si faccia, semplice o meno, ha comunque un rischio e quindi dobbiamo procedere sempre con la massima sicurezza altrimenti tutto quello che si fa svanisce nel vuoto.
Qui in particolare si parlerò di sicurezza informatica.
Quando si può definire un sito sicuro?
“Nel momento stesso in cui ti connetti, sei già esposto.”
Una frase che può sembrare drastica, ma che descrive perfettamente la natura del web moderno.
La sicurezza online non è mai uno stato assoluto: è un equilibrio dinamico tra minacce in continua evoluzione e misure di protezione sempre più sofisticate. Per questo motivo, definire un sito “sicuro” non significa semplicemente che non è stato violato o che utilizza un certificato HTTPS. La sicurezza è un insieme di condizioni tecniche, organizzative e comportamentali che devono coesistere per ridurre al minimo i rischi.
La prima cosa che dovremmo fare è proteggere la comunicazione. Ci dobbiamo affidare a siti terzi che analizzano la rete, ma non esserne completamente succubi.
Cercare Ip Malevoli Pubblici
Un piccola precauzione è per esempio trovare o scovare in rete tutti gli ip che al momento risultano insicuri sulle varie piattaforme pubbliche.
Qui di seguito una piccola classe PHP per generare lista degli ip malevoli.
<?php
class BlockIPGenerator {
private string $dir;
private string $finalFile;
public function __construct(string $directory = null) {
$this->dir = $directory ? rtrim($directory, '/') . '/' : __DIR__ . '/firewall/';
$this->finalFile = $this->dir . 'malicious_ips.txt';
if (!is_dir($this->dir)) {
mkdir($this->dir, 0755, true);
}
}
/**
* Avvia l'intero processo
*/
public function update(): bool {
$this->downloadSources();
$this->extractSFS();
$this->mergeLists();
$this->cleanupTempFiles();
return true; authenticated using a saved recover
}
/**
* Scarica tutte le liste
*/
private function downloadSources(): void {
$sources = [
// Liste malevoli
'sfs.zip' => 'https://www.stopforumspam.com/downloads/listed_ip_1.zip',
'spamhaus.txt' => 'https://www.spamhaus.org/drop/drop.txt',
'tor.txt' => 'https://check.torproject.org/torbulkexitlist',
'emerging.txt' => 'https://rules.emergingthreats.net/fwrules/emerging-Block-IPs.txt',
// Proxy anonimi
'proxyscrape_http.txt' => 'https://api.proxyscrape.com/v2/?request=displayproxies&protocol=http&timeout=10000&country=all&ssl=all&anonymity=all',
'proxylist_http.txt' => 'https://www.proxy-list.download/api/v1/get?type=http',
'proxylist_socks4.txt' => 'https://www.proxy-list.download/api/v1/get?type=socks4',
'proxylist_socks5.txt' => 'https://www.proxy-list.download/api/v1/get?type=socks5',
'openproxy_http.txt' => 'https://openproxy.space/list/http',
'openproxy_socks4.txt' => 'https://openproxy.space/list/socks4',
'openproxy_socks5.txt' => 'https://openproxy.space/list/socks5',
// JSON
'geonode.json' => 'https://proxylist.geonode.com/api/proxy-list?limit=500&anonymityLevel=elite,anonymous'
];
foreach ($sources as $file => $url) {
$this->download($url, $file);
}
}
/**
* Scarica un singolo file remoto
*/
private function download(string $url, string $file): void {
$path = $this->dir . $file;
$data = @file_get_contents($url);
if ($data !== false) {
file_put_contents($path, $data);
}
}
/**
* Estrae StopForumSpam ZIP
*/
private function extractSFS(): void {
$zipFile = $this->dir . 'sfs.zip';
if (!file_exists($zipFile)) {
return;
}
$zip = new ZipArchive();
if ($zip->open($zipFile) === true) {
$inner = $zip->getNameIndex(0);
$content = $zip->getFromName($inner);
file_put_contents($this->dir . 'sfs.txt', $content);
$zip->close();
}
}
/**
* Unisce tutte le liste e genera malicious_ips.txt
*/
private function mergeLists(): void {
$files = [
'sfs.txt',
'spamhaus.txt',
'tor.txt',
'emerging.txt',
'proxyscrape_http.txt',
'proxylist_http.txt',
'proxylist_socks4.txt',
'proxylist_socks5.txt',
'openproxy_http.txt',
'openproxy_socks4.txt',
'openproxy_socks5.txt'
];
$ips = [];
// Se esiste già il file finale, includilo
if (file_exists($this->finalFile)) {
$existing = file($this->finalFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
foreach ($existing as $ip) {
if (ip2long($ip) !== false) {
$ips[$ip] = true;
}
}
}
// Parsing file testuali
foreach ($files as $file) {
$path = $this->dir . $file;
if (!file_exists($path)) {
continue;
}
$content = file_get_contents($path);
if (preg_match_all('/\b(?:\d{1,3}\.){3}\d{1,3}\b/', $content, $matches)) {
foreach ($matches[0] as $ip) {
if (ip2long($ip) !== false) {
$ips[$ip] = true;
}
}
}
}
// Parsing JSON Geonode
$geoFile = $this->dir . 'geonode.json';
if (file_exists($geoFile)) {
$json = json_decode(file_get_contents($geoFile), true);
if (!empty($json['data'])) {
foreach ($json['data'] as $proxy) {
if (!empty($proxy['ip']) && ip2long($proxy['ip']) !== false) {
$ips[$proxy['ip']] = true;
}
}
}
}
// Ordina e salva
$final = array_keys($ips);
sort($final, SORT_STRING);
file_put_contents($this->finalFile, implode(PHP_EOL, $final) . PHP_EOL);
}
/**
* Cancella tutti i file temporanei tranne malicious_ips.txt
*/
private function cleanupTempFiles(): void {
$files = glob($this->dir . '*');
foreach ($files as $file) {
if ($file !== $this->finalFile) {
unlink($file);
}
}
}
}
Possiamo utilizzare la classe con in piccoli index.php nella stessa cartella.
<?php
require_once 'BlockIPGenerator.php';
$generator = new BlockIPGenerator(__DIR__ . '/firewall');
$generator->update();
echo "Blacklist aggiornata.\n";
Per concludere inseriamo nella cartella un Makefile che utilizza docker per avviare l’applicativo. Basterà scrivere make ed avrete la vostra prima lista di ip insicuri (se rilevate questi ip buttateli subito fuori).
# Nome del container temporaneo
CONTAINER_NAME=php-runner
# Immagine PHP già presente sul sistema
IMAGE=php:8.2-cli
# UID e GID locali
UID_LOCAL=$(shell id -u)
GID_LOCAL=$(shell id -g)
# Comando PHP da eseguire
PHP_CMD=php index.php
# Esegue index.php con user locale
run:
docker run --rm -it \
--name $(CONTAINER_NAME) \
-u $(UID_LOCAL):$(GID_LOCAL) \
-v $(PWD):/app \
-w /app \
$(IMAGE) \
$(PHP_CMD)
# Entra nella shell del container con user locale
shell:
docker run --rm -it \
--name $(CONTAINER_NAME) \
-u $(UID_LOCAL):$(GID_LOCAL) \
-v $(PWD):/app \
-w /app \
$(IMAGE) \
/bin/sh
# Esegue un comando PHP arbitrario
exec:
docker run --rm -it \
-u $(UID_LOCAL):$(GID_LOCAL) \
-v $(PWD):/app \
-w /app \
$(IMAGE) \
php $(cmd)
Una piccola parte di sicurezza è così conclusa.
C’è molto altro da fare come ratelimit, rilevazione ip sniffing, post con tecnica honeypot, e tantissimo altro.
I sorgenti dello script li trovate in git ip malevoli.
Lascia un commento