Domande colloquio Junior Security Engineer

Introduzione

Un colloquio da Junior Security Engineer verifica spesso se sai spiegare i concetti di base e applicarli a casi reali: dare priorità alle vulnerabilità, leggere alert SIEM, proteggere le password, controllare TLS e rispondere con calma agli incidenti.

Usa queste domande per allenare risposte concise che colleghino il concetto all'azione che svolgeresti nel ruolo.

Fondamenti di sicurezza

1. Spiega la Triade CIA.

Risposta: La Triade CIA è il fondamento della sicurezza delle informazioni:

Confidenzialità (Confidentiality):

Solo gli utenti autorizzati possono accedere ai dati
Ottenuta tramite: crittografia, controlli di accesso, autenticazione

Integrità (Integrity):

I dati rimangono accurati e non modificati
Ottenuta tramite: hashing, firme digitali, checksum

Disponibilità (Availability):

I sistemi e i dati sono accessibili quando necessario
Ottenuta tramite: ridondanza, backup, protezione DDoS

Loading diagram...

Esempi di violazioni:

Confidenzialità: Violazione dei dati che espone le informazioni dei clienti
Integrità: Attaccante che modifica i registri finanziari
Disponibilità: Attacco DDoS che mette fuori uso il sito web

Rarità: Molto comune Difficoltà: Facile

OWASP Top 10

2. Nomina tre elementi della OWASP Top 10 e spiegane il significato.

Risposta: La OWASP Top 10 elenca i rischi di sicurezza più critici per le applicazioni web:

1. Injection (SQL Injection): Un attaccante inserisce codice dannoso nelle query.

# Codice vulnerabile
username = request.GET['username']
query = f"SELECT * FROM users WHERE username = '{username}'"
# Attacco: username = "admin' OR '1'='1"

# Codice sicuro (query parametrizzata)
cursor.execute("SELECT * FROM users WHERE username = %s", (username,))

2. Broken Access Control (Controllo degli accessi interrotto): Gli utenti possono accedere a risorse a cui non dovrebbero.

# Vulnerabile: Nessun controllo di autorizzazione
@app.route('/admin/users/<user_id>')
def get_user(user_id):
    return User.query.get(user_id)

# Sicuro: Controllo dell'autorizzazione
@app.route('/admin/users/<user_id>')
@require_admin
def get_user(user_id):
    if not current_user.is_admin:
        abort(403)
    return User.query.get(user_id)

3. Cross-Site Scripting (XSS): Un attaccante inietta script dannosi nelle pagine web.

<!-- Vulnerabile -->
<div>Benvenuto, {{ username }}</div>

<!-- Attacco -->
username = "<script>alert('XSS')</script>"

<!-- Sicuro (escape output) -->
<div>Benvenuto, {{ username | escape }}</div>

Rarità: Molto comune Difficoltà: Media

3. Come esegui la gestione delle vulnerabilità?

Risposta: La gestione delle vulnerabilità è un processo continuo di identificazione, valutazione e correzione delle debolezze della sicurezza. Una buona risposta junior cita inventario degli asset, gravità, sfruttabilità, esposizione, impatto sul business, responsabilità della remediation e verifica.

Non basarti solo sul punteggio CVSS. Dai priorità alle vulnerabilità già sfruttate, esposte a internet, presenti su asset critici o facili da concatenare con altre debolezze.

Processo:

Loading diagram...

Scansione delle vulnerabilità:

# Scansione delle vulnerabilità con Nmap
nmap --script vuln 192.168.1.100

# Scansione OpenVAS
openvas-start
# Accedi all'interfaccia web all'indirizzo https://localhost:9392

# Scansione Nessus (commerciale)
# Configura tramite interfaccia web

Esempio Nessus:

# Automatizza la scansione di Nessus
import requests
import time

class NessusScanner:
    def __init__(self, url, access_key, secret_key):
        self.url = url
        self.headers = {
            'X-ApiKeys': f'accessKey={access_key}; secretKey={secret_key}'
        }
    
    def create_scan(self, name, targets):
        data = {
            'uuid': 'template-uuid',  # Basic Network Scan
            'settings': {
                'name': name,
                'text_targets': targets
            }
        }
        response = requests.post(
            f'{self.url}/scans',
            headers=self.headers,
            json=data,
            verify=False
        )
        return response.json()['scan']['id']
    
    def launch_scan(self, scan_id):
        requests.post(
            f'{self.url}/scans/{scan_id}/launch',
            headers=self.headers,
            verify=False
        )
    
    def get_results(self, scan_id):
        response = requests.get(
            f'{self.url}/scans/{scan_id}',
            headers=self.headers,
            verify=False
        )
        return response.json()

# Utilizzo
scanner = NessusScanner('https://nessus:8834', 'access_key', 'secret_key')
scan_id = scanner.create_scan('Weekly Scan', '192.168.1.0/24')
scanner.launch_scan(scan_id)

Gestione delle patch:

# Gestione delle patch Linux
# Ubuntu/Debian
sudo apt update
sudo apt list --upgradable
sudo apt upgrade -y

# CentOS/RHEL
sudo yum check-update
sudo yum update -y

# Patching automatizzato
sudo apt install unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

Matrice di priorità:

Punteggio CVSS	Sfruttabilità	Criticità dell'asset	Priorità
Critico (9-10)	Exploit pubblico	Produzione	P1 (Immediata)
Alto (7-8.9)	PoC disponibile	Produzione	P2 (1 settimana)
Medio (4-6.9)	Nessun exploit	Interno	P3 (1 mese)
Basso (0-3.9)	Nessun exploit	Sviluppo/Test	P4 (Ciclo successivo)

Monitoraggio della correzione:

# Monitoraggio delle vulnerabilità
class VulnerabilityTracker:
    def __init__(self):
        self.vulnerabilities = []
    
    def add_vulnerability(self, vuln):
        self.vulnerabilities.append({
            'id': vuln['id'],
            'severity': vuln['severity'],
            'asset': vuln['asset'],
            'status': 'open',
            'discovered': datetime.now(),
            'sla_deadline': self.calculate_sla(vuln['severity'])
        })
    
    def calculate_sla(self, severity):
        sla_days = {
            'critical': 7,
            'high': 30,
            'medium': 90,
            'low': 180
        }
        return datetime.now() + timedelta(days=sla_days[severity])
    
    def get_overdue(self):
        return [v for v in self.vulnerabilities 
                if v['status'] == 'open' and 
                datetime.now() > v['sla_deadline']]

Rarità: Comune Difficoltà: Facile-Media

Nozioni di base sulla crittografia

4. Qual è la differenza tra crittografia simmetrica e asimmetrica?

Risposta:

Crittografia simmetrica:

Stessa chiave per crittografare e decrittografare
Veloce
Esempi: AES, DES, 3DES

Crittografia asimmetrica:

La chiave pubblica crittografa, la chiave privata decrittografa
Più lenta
Esempi: RSA, ECC

# Crittografia simmetrica (AES)
from cryptography.fernet import Fernet

# Genera la chiave
key = Fernet.generate_key()
cipher = Fernet(key)

# Crittografa
encrypted = cipher.encrypt(b"Secret message")

# Decrittografa
decrypted = cipher.decrypt(encrypted)

# Crittografia asimmetrica (RSA)
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

# Genera la coppia di chiavi
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()

# Crittografa con la chiave pubblica, decrittografa con la chiave privata

Casi d'uso:

Simmetrica: Crittografia di grandi quantità di dati (file, database)
Asimmetrica: Scambio di chiavi, firme digitali, SSL/TLS

Rarità: Molto comune Difficoltà: Facile-Media

5. Come funziona SSL/TLS e come gestisci i certificati?

Risposta: SSL/TLS crittografa i dati in transito tra client e server.

Handshake TLS:

Loading diagram...

Come funziona:

Client Hello: Il client invia le suite di cifratura supportate
Server Hello: Il server sceglie la cifratura, invia il certificato
Verifica del certificato: Il client convalida la catena di certificati
Scambio di chiavi: Stabilisce un segreto condiviso
Comunicazione crittografata: Utilizza la crittografia simmetrica

Componenti del certificato:

# Visualizza i dettagli del certificato
openssl x509 -in certificate.crt -text -noout

# Il certificato contiene:
# - Soggetto (nome del dominio)
# - Emittente (CA)
# - Periodo di validità
# - Chiave pubblica
# - Firma

Gestione dei certificati:

Genera CSR (Certificate Signing Request):

# Genera la chiave privata
openssl genrsa -out private.key 2048

# Genera CSR
openssl req -new -key private.key -out request.csr

# Visualizza CSR
openssl req -text -noout -verify -in request.csr

Certificato autofirmato (Test):

# Genera certificato autofirmato
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes

# Combina per l'uso del server
cat cert.pem key.pem > server.pem

Installa il certificato:

# Nginx
server {
    listen 443 ssl;
    server_name example.com;
    
    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
}

# Apache
<VirtualHost *:443>
    ServerName example.com
    
    SSLEngine on
    SSLCertificateFile /etc/apache2/ssl/cert.pem
    SSLCertificateKeyFile /etc/apache2/ssl/key.pem
    SSLCertificateChainFile /etc/apache2/ssl/chain.pem
    
    SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1
    SSLCipherSuite HIGH:!aNULL:!MD5
</VirtualHost>

Errori di configurazione comuni:

1. Protocolli deboli:

# Errato: Consente SSLv3, TLSv1.0
ssl_protocols SSLv3 TLSv1 TLSv1.1 TLSv1.2;

# Corretto: Solo TLS moderno
ssl_protocols TLSv1.2 TLSv1.3;

2. Cifratura debole:

# Testa la configurazione SSL
sslscan example.com
nmap --script ssl-enum-ciphers -p 443 example.com

# Oppure usa strumenti online
# https://www.ssllabs.com/ssltest/

3. Certificati scaduti:

# Controlla la scadenza del certificato
openssl s_client -connect example.com:443 -servername example.com < /dev/null 2>/dev/null | \
    openssl x509 -noout -dates

# Monitora la scadenza
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null | \
    openssl x509 -noout -enddate

Automazione dei certificati (Let's Encrypt):

# Installa certbot
sudo apt install certbot python3-certbot-nginx

# Ottieni il certificato
sudo certbot --nginx -d example.com -d www.example.com

# Rinnovo automatico (cron)
0 0 * * * certbot renew --quiet

Risoluzione dei problemi:

# Testa la connessione TLS
openssl s_client -connect example.com:443 -servername example.com

# Verifica la catena di certificati
openssl verify -CAfile ca-bundle.crt certificate.crt

# Controlla che il certificato corrisponda alla chiave privata
openssl x509 -noout -modulus -in cert.pem | openssl md5
openssl rsa -noout -modulus -in key.pem | openssl md5
# Gli hash dovrebbero corrispondere

Rarità: Comune Difficoltà: Media

Firewall

6. Spiega la differenza tra firewall stateful e stateless.

Risposta:

Firewall Stateless:

Esamina ogni pacchetto in modo indipendente
Nessun tracciamento della connessione
Più veloce ma meno sicuro
Esempio: Filtro di pacchetti di base

Firewall Stateful:

Tiene traccia dello stato della connessione
Ricorda i pacchetti precedenti
Più sicuro
Esempio: Firewall moderni

# iptables (stateful)
# Consenti connessioni stabilite
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Consenti nuove connessioni SSH
iptables -A INPUT -p tcp --dport 22 -m state --state NEW -j ACCEPT

# Elimina tutto il resto
iptables -A INPUT -j DROP

Stati della connessione:

NEW: Primo pacchetto della connessione
ESTABLISHED: Parte di una connessione esistente
RELATED: Correlato a una connessione esistente
INVALID: Non corrisponde a nessuno stato

Rarità: Comune Difficoltà: Media

SIEM

7. Cos'è un SIEM e perché è importante?

Risposta: SIEM (Security Information and Event Management) centralizza la raccolta e l'analisi dei log.

Funzioni principali:

Raccolta dei log: Raccoglie i log da più fonti
Normalizzazione: Standardizza i formati dei log
Correlazione: Identifica modelli e relazioni
Avvisi: Notifica in caso di attività sospette
Reporting: Conformità e analisi forense

Loading diagram...

Casi d'uso:

Rileva attacchi di forza bruta
Identifica l'esfiltrazione di dati
Monitora l'accesso privilegiato
Reporting di conformità (PCI-DSS, HIPAA)

Strumenti SIEM popolari:

Splunk
ELK Stack (Elasticsearch, Logstash, Kibana)
IBM QRadar
ArcSight

Rarità: Comune Difficoltà: Media

8. Qual è la differenza tra IDS e IPS?

Risposta: IDS (Intrusion Detection System) e IPS (Intrusion Prevention System) monitorano il traffico di rete alla ricerca di minacce.

Differenze chiave:

Caratteristica	IDS	IPS
Azione	Rileva e avvisa	Rileva e blocca
Posizionamento	Out-of-band (passivo)	Inline (attivo)
Impatto	Nessuna interruzione del traffico	Può bloccare il traffico legittimo
Risposta	Manuale	Automatica
Falsi positivi	Meno critici	Più critici

Implementazione IDS:

Loading diagram...

Implementazione IPS:

Loading diagram...

Configurazione Snort (IDS/IPS):

# Installa Snort
sudo apt install snort

# Configura la rete
sudo vi /etc/snort/snort.conf
# Imposta HOME_NET
ipvar HOME_NET 192.168.1.0/24
ipvar EXTERNAL_NET !$HOME_NET

# Esegui in modalità IDS
sudo snort -A console -q -c /etc/snort/snort.conf -i eth0

# Esegui in modalità IPS (inline)
sudo snort -Q -c /etc/snort/snort.conf -i eth0

Regole Snort:

# Sintassi della regola
# action protocol src_ip src_port -> dst_ip dst_port (options)

# Rileva SQL injection
alert tcp any any -> $HOME_NET 80 (msg:"SQL Injection Attempt"; \
    content:"UNION SELECT"; nocase; sid:1000001; rev:1;)

# Rileva la scansione delle porte
alert tcp any any -> $HOME_NET any (msg:"Port Scan Detected"; \
    flags:S; threshold:type both, track by_src, count 20, seconds 60; \
    sid:1000002; rev:1;)

# Rileva la forza bruta SSH
alert tcp any any -> $HOME_NET 22 (msg:"SSH Brute Force"; \
    flags:S; threshold:type both, track by_src, count 5, seconds 60; \
    sid:1000003; rev:1;)

# Blocca IP dannoso (modalità IPS)
drop tcp 203.0.113.50 any -> $HOME_NET any (msg:"Blocked Malicious IP"; \
    sid:1000004; rev:1;)

Suricata (Alternativa moderna):

# Installa Suricata
sudo apt install suricata

# Aggiorna le regole
sudo suricata-update

# Esegui Suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0

# Visualizza gli avvisi
sudo tail -f /var/log/suricata/fast.log

Analisi degli avvisi:

# Analizza gli avvisi Snort
import re
from collections import Counter

def analyze_snort_alerts(log_file):
    alerts = []
    
    with open(log_file, 'r') as f:
        for line in f:
            # Analizza l'avviso
            match = re.search(r'\[\*\*\] \[(\d+):(\d+):(\d+)\] (.+?) \[\*\*\]', line)
            if match:
                alerts.append({
                    'sid': match.group(1),
                    'message': match.group(4),
                    'line': line
                })
    
    # Avvisi principali
    alert_counts = Counter([a['message'] for a in alerts])
    print("Top 10 Alerts:")
    for alert, count in alert_counts.most_common(10):
        print(f"{count:5d} - {alert}")
    
    return alerts

# Utilizzo
alerts = analyze_snort_alerts('/var/log/snort/alert')

Firme di attacco comuni:

# SQL Injection
content:"' OR 1=1--";
content:"UNION SELECT";

# XSS
content:"<script>";
content:"javascript:";

# Command Injection
content:";cat /etc/passwd";
content:"|whoami";

# Directory Traversal
content:"../../../";

# Shellshock
content:"() { :; };";

Migliori pratiche:

Aggiorna regolarmente le firme
Ottimizza le regole per ridurre i falsi positivi
Monitora l'IPS per il traffico legittimo bloccato
Integra con SIEM per la correlazione
Esegui test in modalità IDS prima di abilitare IPS

Rarità: Comune Difficoltà: Media

Migliori pratiche di sicurezza

9. Come proteggi le password?

Risposta: Sicurezza delle password a più livelli:

1. Hashing (non crittografia):

import hashlib
import os

def hash_password(password):
    # Genera il salt
    salt = os.urandom(32)
    
    # Hash della password con il salt
    key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode('utf-8'),
        salt,
        100000  # iterazioni
    )
    
    # Memorizza salt + hash
    return salt + key

def verify_password(stored_password, provided_password):
    salt = stored_password[:32]
    stored_key = stored_password[32:]
    
    key = hashlib.pbkdf2_hmac(
        'sha256',
        provided_password.encode('utf-8'),
        salt,
        100000
    )
    
    return key == stored_key

2. Politica delle password:

Preferire password o passphrase lunghe alle regole di complessità forzata
Consentire password manager, incolla e autofill
Bloccare password note come compromesse o troppo comuni
Richiedere MFA dove possibile
Forzare il reset quando ci sono segnali di compromissione, non solo per una scadenza periodica

3. Sicurezza aggiuntiva:

Autenticazione a più fattori (MFA)
Blocco dell'account dopo tentativi falliti
Misuratore della forza della password
Rilevamento di violazioni (API Have I Been Pwned)

Mai:

Memorizzare le password in testo semplice
Utilizzare hashing deboli (MD5, SHA1)
Hash senza salt

Rarità: Molto comune Difficoltà: Media

Incident Response

10. Quali sono le fasi della risposta agli incidenti?

Risposta: Ciclo di vita della risposta agli incidenti NIST:

1. Preparazione:

Sviluppa un piano IR
Forma il team
Imposta strumenti e monitoraggio

2. Rilevamento e analisi:

Identifica gli incidenti
Analizza la portata e l'impatto
Dai priorità alla risposta

3. Contenimento:

A breve termine: Isola i sistemi interessati
A lungo termine: Applica patch, ricostruisci i sistemi

4. Eradicazione:

Rimuovi il malware
Chiudi le vulnerabilità
Rafforza le difese

5. Ripristino:

Ripristina i sistemi
Monitora per la reinfezione
Ritorna alle normali operazioni

6. Post-Incidente:

Documenta le lezioni apprese
Aggiorna le procedure
Migliora le difese

Loading diagram...

Rarità: Comune Difficoltà: Media

Conclusione

Per un colloquio da Junior Security Engineer, preparati a spiegare le basi e a mostrare come le useresti in un ambiente reale. Concentrati su:

Fondamenti: Triade CIA, least privilege, autenticazione, autorizzazione
OWASP: Broken access control, errori crittografici, injection, logging e monitoring
Gestione delle vulnerabilità: Contesto degli asset, sfruttabilità, remediation, verifica
Crittografia e TLS: Crittografia, hashing, certificati, impostazioni moderne dei protocolli
Strumenti difensivi: Firewall, SIEM, IDS/IPS, tuning degli alert
Sicurezza delle password: Hashing, salt, MFA, controlli su password compromesse
Incident response: Preparazione, rilevamento, contenimento, ripristino, lesson learned

Allenati con esempi concreti da lab, progetti, stage o ambienti personali. I recruiter non si aspettano che tu conosca ogni tool; vogliono vedere ragionamento chiaro, priorità sensate e comunicazione onesta.

Consigli di carriera recenti

Domande di Colloquio per Junior Security Engineer

Introduzione

Fondamenti di sicurezza

1. Spiega la Triade CIA.

OWASP Top 10

2. Nomina tre elementi della OWASP Top 10 e spiegane il significato.

3. Come esegui la gestione delle vulnerabilità?

Nozioni di base sulla crittografia

4. Qual è la differenza tra crittografia simmetrica e asimmetrica?

5. Come funziona SSL/TLS e come gestisci i certificati?

Firewall

6. Spiega la differenza tra firewall stateful e stateless.

SIEM

7. Cos'è un SIEM e perché è importante?

8. Qual è la differenza tra IDS e IPS?

Migliori pratiche di sicurezza

9. Come proteggi le password?

Incident Response

10. Quali sono le fasi della risposta agli incidenti?

Conclusione

Consigli di carriera settimanali che funzionano davvero

Consigli di carriera settimanali che funzionano davvero

Post Correlati

Domande da colloquio Junior SRE con risposte

Domande da colloquio per Junior Machine Learning Engineer

Domande da colloquio per junior GCP cloud engineer

Il Tuo Prossimo Colloquio Dista Solo un Curriculum

Condividi questo post

Batti il Tasso di Rifiuto ATS del 75%