ICSpector: Framework di analisi forense ICS di Microsoft

Il framework Microsoft ICS Forensics Tools è un framework forense open-source che consente l'analisi dei metadati e dei file di progetto dei PLC industriali.
Il framework offre agli investigatori un modo comodo per scansionare i PLC e identificare eventuali artefatti sospetti all'interno degli ambienti ICS, che possono essere utilizzati per controlli manuali, attività di monitoraggio automatico o operazioni di risposta agli incidenti per rilevare dispositivi compromessi.
Essendo uno strumento open-source, ICS Forensics Tools consente agli investigatori di esaminare l'output e personalizzarlo in base alle proprie esigenze specifiche.

Per Iniziare

Queste istruzioni ti permetteranno di ottenere una copia del progetto in esecuzione sulla tua macchina locale per scopi di sviluppo e test.

git clone https://github.com/microsoft/ics-forensics-tools.git

Prerequisiti

• Installare Python >= 3.9: https://www.python.org/downloads
• Installare Microsoft Visual C++ 14.0. Ottenerlo con "Build Tools for Visual Studio": https://visualstudio.microsoft.com/downloads/

Installazione

• Installare i requisiti Python

  pip install -r requirements.txt
  

Utilizzo

Argomenti generali dell'applicazione:

Args	Descrizione	Obbligatorio / Opzionale
-h, --help	mostra questo messaggio di aiuto ed esci	Opzionale
-s, --save-config	Salva il file di configurazione per un uso futuro facile	Opzionale
-c, --config	Percorso del file di configurazione, default è config.json	Opzionale
-o, --output-dir	Directory in cui salvare i file generati, default è output	Opzionale
-v, --verbose	Salva l'output in un file oltre che nella console	Opzionale
-p, --multiprocess	Esecuzione in modalità multiprocesso per numero di plugin/analizzatori	Opzionale

Argomenti specifici del plugin:

Args	Descrizione	Obbligatorio / Opzionale
-h, --help	mostra questo messaggio di aiuto ed esci	Opzionale
--ip	Percorso del file degli indirizzi, CIDR o indirizzi IP csv (colonna ip obbligatoria). aggiungere altre colonne per informazioni aggiuntive su ogni IP (username, password, ecc.)	Obbligatorio
--port	Numero porta	Opzionale
--transport	tcp/udp	Opzionale
--analyzer	Nome dell'analizzatore da eseguire	Opzionale

Esempi di esecuzione dalla riga di comando

 python driver.py -s -v PluginName --ip ips.csv
 python driver.py -s -v PluginName --ip ips.csv --analyzer AnalyzerName
 python driver.py -s -v -c config.json --multiprocess

Esempio di importazione come libreria

from forensic.client.forensic_client import ForensicClient
from forensic.interfaces.plugin import PluginConfig
forensic = ForensicClient()
plugin = PluginConfig.from_json({
    "name": "PluginName",
    "port": 123,
    "transport": "tcp",
    "addresses": [{"ip": "192.168.1.0/24"}, {"ip": "10.10.10.10"}],
    "parameters": {
    },
    "analyzers": []
})
forensic.scan([plugin])

Architettura

Aggiungere Plugin

Durante lo sviluppo locale, assicurati di contrassegnare la cartella src come "Sources root"

• Crea una nuova directory sotto la cartella plugins con il nome del tuo plugin
• Crea un nuovo file Python con il nome del tuo plugin
• Usa il seguente template per scrivere il tuo plugin e sostituisci 'General' con il nome del tuo plugin

from pathlib import Path
from forensic.interfaces.plugin import PluginInterface, PluginConfig, PluginCLI
from forensic.common.constants.constants import Transport


class GeneralCLI(PluginCLI):
    def __init__(self, folder_name):
        super().__init__(folder_name)
        self.name = "General"
        self.description = "Descrizione Generale del Plugin"
        self.port = 123
        self.transport = Transport.TCP

    def flags(self, parser):
        self.base_flags(parser, self.port, self.transport)
        parser.add_argument('--general', help='Argomento aggiuntivo generale', metavar="")


class General(PluginInterface):
    def __init__(self, config: PluginConfig, output_dir: Path, verbose: bool):
        super().__init__(config, output_dir, verbose)

    def connect(self, address):
        self.logger.info(f"{self.config.name} connetti")

    def export(self, extracted):
        self.logger.info(f"{self.config.name} esporta")

• Assicurati di importare il tuo nuovo plugin nel file __init__.py sotto la cartella plugins
• Nella classe ereditata da PluginInterface ci sono i parametri 'config', puoi usarli per accedere a qualsiasi dato disponibile nell'oggetto PluginConfig (nome plugin, indirizzi, porta, transport, parametri).
  Ci sono 2 funzioni obbligatorie (connect, export).
  • La funzione connect riceve un singolo indirizzo IP ed estrae qualsiasi informazione rilevante dal dispositivo e la restituisce.
  • La funzione export riceve le informazioni estratte da tutti i dispositivi e qui puoi esportarle in un file.
• Nella classe ereditata da PluginCLI devi specificare nella funzione init le informazioni predefinite relative a questo plugin.
  C'è una singola funzione obbligatoria (flags), in cui devi chiamare base_flags, e puoi aggiungere eventuali flag aggiuntivi che desideri avere.

Aggiungere Analizzatori

• Crea una nuova directory sotto la cartella analyzers con il nome del plugin correlato al tuo analizzatore.
• Crea un nuovo file Python con il nome del tuo analizzatore
• Usa il seguente template per scrivere il tuo plugin e sostituisci 'General' con il nome del tuo analizzatore

from pathlib import Path
from forensic.interfaces.analyzer import AnalyzerInterface, AnalyzerConfig


class General(AnalyzerInterface):
    def __init__(self, config: AnalyzerConfig, output_dir: Path, verbose: bool):
        super().__init__(config, output_dir, verbose)
        self.plugin_name = 'General'
        self.create_output_dir(self.plugin_name)

    def analyze(self):
      pass