...
Pregătire interviuri

100 de întrebări de interviu Securitate cibernetică, cu răspunsuri

Întrebările despre Securitate cibernetică care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs securitate cibernetică: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 148 minde citit
Întrebări de interviu Securitate cibernetică cu răspunsuri

La interviurile pentru roluri de securitate cibernetică (analist SOC junior, specialist în securitate IT, inginer de securitate, administrator de sistem cu responsabilități de securitate) și tot mai des la cele pentru dezvoltatori sau DevOps, fundamentele tehnice ale securității se verifică în trei feluri. Primul este teoria: principii, protocoale de rețea, criptografie, autentificare. Al doilea sunt întrebările practice: „ce vulnerabilitate are acest cod”, „ce reguli de firewall ai scrie”, „ce înseamnă acest vector CVSS”. Al treilea sunt scenariile: un incident, o cheie scăpată pe internet, un furnizor care cere acces, unde se urmărește cum gândești și în ce ordine acționezi.

La nivel de junior se așteaptă să explici corect conceptele de bază și să recunoști vulnerabilitățile clasice: diferența dintre HTTP și HTTPS, ce face un salt, de ce un cookie de sesiune are nevoie de anumite atribute, cum arată o injecție de comenzi sau un path traversal. La nivel mid contează să știi de ce un control funcționează și unde se oprește: limitele interogărilor parametrizate, CSP strict, revocarea certificatelor, scanarea autentificată. La nivel senior discuția se mută spre arhitectură și compromisuri: unde se termină TLS-ul, cum proiectezi backupuri care supraviețuiesc unui administrator compromis, cum conduci răspunsul la un CVE critic. Toate răspunsurile sunt scrise din perspectivă defensivă: cum previi, cum detectezi și cum corectezi.

Cum să folosești pagina: încearcă să răspunzi singur, apoi citește răspunsul scurt și explicația detaliată. Rulează comenzile și exemplele de cod doar pe sisteme proprii sau într-un laborator local (o mașină virtuală Linux, un container, o aplicație de test), niciodată pe sisteme pentru care nu ai autorizare. Întrebările sunt grupate pe teme și ordonate de la junior la senior, iar ultima secțiune conține situații din practică, cu modele de răspuns structurate. Pentru munca de zi cu zi a unui analist SOC (SIEM, triaj de alerte, investigații) există pagina separată dedicată acestui rol.

Principii de bază

1 Junior

Ce înseamnă clasificarea datelor și cum influențează ea controalele de securitate?

Răspuns scurt: Clasificarea datelor împarte informațiile pe niveluri de sensibilitate (de exemplu public, intern, confidențial, restricționat), iar fiecare nivel primește reguli proprii de acces, stocare, transmitere și ștergere.

Nu toate datele merită aceeași protecție. Dacă tratezi totul ca „secret”, controalele devin prea scumpe și oamenii le ocolesc. Dacă tratezi totul ca „public”, pierzi exact datele care contează. Clasificarea datelor rezolvă problema: stabilești câteva niveluri și pentru fiecare definești ce înseamnă protecție suficientă.

Un model frecvent folosit:

  • Public: broșuri, pagini de pe site. Integritatea contează, confidențialitatea nu.
  • Intern: proceduri, organigrame. Acces doar pentru angajați.
  • Confidențial: date personale ale clienților, contracte, cod sursă. Acces pe bază de nevoie, criptare la transmitere.
  • Restricționat: chei de criptare, date medicale, date de card. Acces nominal, criptare la repaus, jurnalizare a fiecărui acces.

Clasificarea are nevoie de un proprietar al datelor (data owner), de obicei o persoană din business, nu din IT, care decide nivelul și aprobă accesul. IT-ul implementează controalele: permisiuni, criptare, DLP (Data Loss Prevention, unelte care blochează scurgerea datelor clasificate), politici de retenție.

În practică, clasificarea te ajută și la incidente: dacă un laptop pierdut conținea doar date interne, reacția e alta decât dacă avea o bază cu date personale, unde intră în discuție obligații legale de notificare. Fără clasificare nu poți răspunde rapid la întrebarea „ce s-a pierdut de fapt”.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi că securitatea pornește de la valoarea datelor, nu de la unelte. Greșeala tipică este să enumeri niveluri fără să spui ce control diferă între ele.

2 Junior

Ce este suprafața de atac a unui sistem și cum o reduci?

Răspuns scurt: Suprafața de atac este totalitatea punctelor prin care un atacator poate interacționa cu sistemul: porturi deschise, servicii, endpoint-uri de API, conturi, dependențe. O reduci eliminând tot ce nu e necesar și restrângând accesul la ce rămâne.

Fiecare serviciu care ascultă pe un port, fiecare endpoint public, fiecare cont activ și fiecare bibliotecă inclusă în aplicație este un loc unde poate exista o vulnerabilitate. Cu cât sunt mai multe, cu atât probabilitatea ca unul să fie vulnerabil crește. De aceea reducerea suprafeței de atac este una dintre cele mai ieftine măsuri de securitate: nu trebuie să aperi ce nu există.

Suprafața se împarte de obicei în:

  • de rețea: porturi și servicii expuse, interfețe de administrare;
  • software: endpoint-uri, funcționalități, dependențe, pluginuri;
  • umană: conturi, angajați care pot fi ținta phishing-ului, furnizori cu acces.

Măsuri concrete:

  • dezinstalezi pachetele și dezactivezi serviciile nefolosite;
  • închizi porturile la firewall și legi serviciile interne doar de 127.0.0.1 sau de rețeaua privată;
  • scoți interfețele de administrare (de exemplu panoul de admin al unui CMS) de pe internet sau le pui în spatele unui VPN;
  • dezactivezi conturile vechi și pe cele de test;
  • elimini dependențele nefolosite din proiect;
  • dezactivezi funcționalitățile „de debug” în producție.

Un pas util este inventarul: nu poți reduce ce nu știi că ai. Scanează periodic propriile adrese IP și compară rezultatul cu lista de servicii care ar trebui să fie expuse.

Ce urmărește intervievatorul: Se verifică dacă gândești preventiv și pragmatic. Candidații greșesc când vorbesc doar despre porturi și uită de conturi, dependențe și funcționalități nefolosite.

3 Junior

Care este diferența dintre separarea sarcinilor (separation of duties) și principiul need-to-know?

Răspuns scurt: Separarea sarcinilor împarte o operațiune critică între mai multe persoane, ca nimeni să nu o poată duce singur la capăt. Need-to-know limitează accesul la informații doar la cele necesare pentru sarcina curentă, chiar dacă persoana are nivelul de autorizare.

Ambele principii limitează puterea unei singure persoane, dar pe axe diferite.

Separarea sarcinilor privește acțiunile. Exemplul clasic este financiar: cine introduce o plată nu o poate și aproba. În IT: dezvoltatorul care scrie codul nu își aprobă singur pull request-ul și nu face singur deploy în producție; administratorul care gestionează logurile nu ar trebui să le poată șterge pe cele care îi înregistrează propriile acțiuni. Scopul este ca o fraudă sau o greșeală gravă să necesite complicitatea a două persoane, ceea ce o face mult mai puțin probabilă.

Need-to-know privește informația. Un angajat poate avea, formal, acces la date confidențiale, dar vede doar dosarele clienților cu care lucrează. Un inginer de suport vede istoricul tichetelor unui client, nu tot CRM-ul.

Implementări tehnice tipice:

  • reguli de branch protection care cer aprobarea altei persoane;
  • fluxuri de aprobare în doi pași pentru operațiuni sensibile (numit uneori „four-eyes principle”);
  • roluri separate pentru administrarea sistemului și administrarea auditului;
  • filtrare la nivel de rând în baza de date, după echipă sau client.

Ambele completează privilegiul minim: privilegiul minim spune „cât de puțin acces”, separarea sarcinilor spune „nu tot accesul la un singur om”.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi principii de control al accesului dincolo de least privilege. Greșeala frecventă este confundarea celor două sau reducerea lor la „fiecare are doar ce îi trebuie”.

4 Junior

Ce înseamnă „security through obscurity” și de ce nu e suficientă ca protecție?

Răspuns scurt: Înseamnă să te bazezi pe faptul că atacatorul nu cunoaște detaliile sistemului (un port neobișnuit, un URL ascuns, un algoritm secret). Ascunderea poate reduce zgomotul, dar odată descoperit secretul, protecția dispare complet.

Exemple tipice: panoul de administrare mutat la /admin-x93k/ fără autentificare puternică, SSH mutat pe portul 2222, un algoritm de criptare „propriu” pe care nimeni nu îl cunoaște. Toate pornesc de la ideea că atacatorul nu va ghici.

Problema este că secretele de acest tip se scurg ușor: URL-ul apare în istoricul browserului, într-un log, într-un fișier JavaScript; un port neobișnuit este găsit de orice scanare completă; un algoritm propriu poate fi analizat prin inginerie inversă a aplicației.

Principiul lui Kerckhoffs, formulat pentru criptografie, spune că un sistem trebuie să rămână sigur chiar dacă atacatorul știe tot despre el, cu excepția cheii. Cheia este ușor de schimbat; designul sistemului nu este. Asta e diferența esențială: un secret bun este mic, aleator și înlocuibil.

Ascunderea nu este inutilă dacă este un strat în plus, nu singura apărare. Mutarea SSH pe alt port reduce numărul de încercări automate din loguri, ceea ce face alertele mai ușor de citit. Ascunderea versiunii serverului din headere reduce informația gratuită pentru atacator. Dar SSH trebuie să aibă în continuare autentificare cu chei, iar serverul trebuie să fie actualizat.

Regula de răspuns la interviu: obscuritatea poate reduce probabilitatea unui atac oportunist, nu impactul unui atac țintit.

Ce urmărește intervievatorul: Se verifică dacă știi să distingi un control real de unul aparent. Candidații greșesc fie respingând total ascunderea, fie prezentând-o ca protecție principală.

5 Junior

Ce înseamnă „fail-open” și „fail-closed” și ce alegi pentru un sistem de autorizare?

Răspuns scurt: Fail-open înseamnă că, la o eroare, sistemul permite accesul; fail-closed înseamnă că îl refuză. Pentru autorizare alegi fail-closed: dacă nu poți verifica permisiunea, răspunsul este „nu”.

Orice control de securitate poate eșua: serviciul de autorizare nu răspunde, fișierul de configurare lipsește, o excepție neprevăzută apare în cod. Întrebarea este ce se întâmplă atunci.

Un exemplu de bug clasic de tip fail-open:

PYTHON
def are_acces(user, resursa):
    try:
        return serviciu_permisiuni.verifica(user, resursa)
    except Exception:
        log.warning("serviciu indisponibil")
        return True   # GREȘIT: la eroare, oricine trece

Corect este return False în ramura de eroare. Dacă un atacator poate provoca eroarea (de exemplu trimițând un input care crapă parserul sau supraîncărcând serviciul), un sistem fail-open îi oferă acces.

Nu orice sistem trebuie să fie fail-closed. Decizia ține de ce prioritate are, în acel context, confidențialitatea față de disponibilitate:

  • autorizare, autentificare, verificarea semnăturilor: fail-closed;
  • ușile unei clădiri la incendiu: fail-open (siguranța oamenilor primează);
  • un filtru de spam care nu răspunde: adesea fail-open, ca să nu blochezi tot emailul, dar cu alertă.

Ce contează este ca alegerea să fie conștientă și documentată, nu un efect secundar al unui catch scris în grabă. Principiul înrudit este secure defaults: configurația implicită trebuie să fie cea sigură, iar relaxarea ei să ceară o acțiune explicită.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că te gândești la cazurile de eroare, nu doar la cel fericit. Greșeala tipică este un catch care întoarce succes sau o configurație care, dacă lipsește, dezactivează verificarea.

6 Mid

Cum clasifici controalele de securitate după funcție (preventive, detective, corective) și după natură (administrative, tehnice, fizice)?

Răspuns scurt: După funcție: preventivele opresc incidentul, detectivele îl semnalează, corectivele limitează efectul și refac starea. După natură: administrative (politici, instruire), tehnice (firewall, criptare) și fizice (încuietori, camere). Un program bun combină toate tipurile.

Clasificarea te ajută să vezi golurile. Dacă ai doar controale preventive, nu vei afla când au fost ocolite. Dacă ai doar detecție, vei afla repede, dar nu vei opri nimic.

După funcție:

  • preventive: MFA, firewall, validarea input-ului, patching;
  • detective: alerte în SIEM, IDS, verificarea integrității fișierelor, revizuirea logurilor;
  • corective: restaurarea din backup, izolarea automată a unui host, revocarea unui token;
  • uneori se adaugă descurajante (bannere legale, camere vizibile) și compensatorii (un control alternativ când cel standard nu poate fi aplicat).

După natură:

  • administrative: politica de parole, procedura de onboarding și offboarding, instruirea anti-phishing;
  • tehnice (logice): criptare, ACL-uri, EDR;
  • fizice: acces cu card în camera serverelor, distrugerea discurilor.

Cele două axe se combină. Instruirea anti-phishing este administrativă și preventivă. O cameră video este fizică și detectivă. Un backup testat este tehnic și corectiv.

La interviu, un exemplu bun este să iei un risc concret, de pildă furtul de parole prin phishing, și să arăți câte un control din fiecare categorie: instruire și MFA (preventive), alertă la autentificare din țară neobișnuită (detectivă), resetare forțată a parolei și revocarea sesiunilor (corective).

Ce urmărește intervievatorul: Se verifică dacă gândești în straturi și știi să acoperi un risc complet. Greșeala frecventă este să enumeri doar controale tehnice preventive.

7 Mid

Ce este threat modeling și cum ai aplica STRIDE pe o aplicație web simplă cu login și încărcare de fișiere?

Răspuns scurt: Threat modeling este analiza structurată a ce poate merge prost într-un sistem, făcută de obicei în faza de design. STRIDE e o listă de categorii de amenințări (Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege) pe care o parcurgi pentru fiecare componentă.

Un model de amenințări răspunde la patru întrebări: ce construim, ce poate merge prost, ce facem în privința asta și am făcut o treabă suficient de bună. Pornești de la o diagramă de flux a datelor: utilizator, browser, server web, bază de date, stocare de fișiere și granițele de încredere dintre ele (de exemplu între internet și server).

Aplicat pe exemplu:

  • Spoofing (uzurparea identității): cineva se loghează ca alt utilizator. Măsuri: MFA, protecție la credential stuffing.
  • Tampering (modificare): fișierul încărcat sau parametrii cererii sunt modificați. Măsuri: validare pe server, verificarea tipului real al fișierului.
  • Repudiation (negare): un utilizator neagă că a șters ceva. Măsuri: loguri de audit cu identitate și timp.
  • Information disclosure: fișierele unui utilizator sunt accesibile altuia. Măsuri: verificarea proprietarului la fiecare descărcare, URL-uri care nu pot fi ghicite.
  • Denial of service: încărcări de fișiere uriașe. Măsuri: limită de dimensiune și rate limiting.
  • Elevation of privilege: un fișier încărcat este executat pe server. Măsuri: stocare în afara directorului web, fără permisiuni de execuție.

Rezultatul este o listă de amenințări cu măsuri și responsabili, care intră în backlog. Valoarea cea mai mare apare când exercițiul se face înainte de implementare, când schimbarea designului este ieftină.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți gândi sistematic ca un apărător, nu doar reactiv. Greșeala tipică este să recitezi acronimul fără să-l aplici pe componente concrete.

8 Senior

Ce înseamnă principiul „complete mediation” și cum îl încalcă un cache de permisiuni sau o problemă TOCTOU?

Răspuns scurt: Complete mediation cere ca fiecare acces să fie verificat de fiecare dată, nu doar la prima cerere. Un cache de permisiuni prea lung sau o verificare separată de folosire (TOCTOU) lasă ferestre în care accesul nu mai e corect.

Principiul vine din lucrarea clasică a lui Saltzer și Schroeder despre protecția informației. Ideea: autorizarea nu e un eveniment unic, ci o condiție care trebuie să fie adevărată la momentul fiecărui acces.

Încălcarea prin cache: aplicația citește rolurile utilizatorului la login și le ține în sesiune 12 ore. Dacă între timp contul este dezactivat sau un rol este retras, utilizatorul continuă să aibă acces până expiră sesiunea. Soluții: durată scurtă pentru cache, invalidare explicită la schimbarea permisiunilor, verificarea stării contului la operațiunile sensibile.

Încălcarea prin TOCTOU (time-of-check to time-of-use): verifici o condiție, apoi folosești resursa, iar între cele două momente starea se schimbă.

PYTHON
import os
if os.access(cale, os.W_OK):      # verificare
    with open(cale, "w") as f:    # folosire
        f.write(date)

Într-un program cu privilegii, între access și open cineva poate înlocui fișierul cu un link simbolic spre un fișier sensibil. Corect este să faci operația direct, cu drepturile potrivite, și să tratezi eroarea, sau să folosești opțiuni atomice precum O_NOFOLLOW și O_EXCL.

Aceeași clasă de probleme apare în aplicații web: verifici soldul, apoi debitezi contul, în două tranzacții separate. Soluția este ca verificarea și acțiunea să fie atomice (o singură tranzacție cu blocare sau o actualizare condiționată).

Ce urmărește intervievatorul: Se verifică înțelegerea profundă a autorizării și a concurenței. Greșeala frecventă la nivel senior este să proiectezi verificări corecte logic, dar neatomice sau bazate pe date vechi.

Rețele pentru securitate

9 Junior

Ce înseamnă notația 10.20.0.0/24, câte adrese conține și de ce contează notația CIDR în regulile de firewall?

Răspuns scurt: /24 înseamnă 24 de biți pentru rețea și 8 pentru hosturi: 256 de adrese, de la 10.20.0.0 la 10.20.0.255, dintre care 254 utilizabile. O greșeală de prefix într-o regulă de firewall poate deschide accesul unei rețele mult mai mari.

O adresă IPv4 are 32 de biți. Prefixul după slash spune câți biți de la stânga sunt ficși (rețeaua). Restul pot varia. Numărul de adrese este 2 la puterea (32 minus prefix):

  • /32: o singură adresă (un host);
  • /24: 256 de adrese;
  • /16: 65.536 de adrese;
  • /8: aproximativ 16,7 milioane;
  • /0: tot internetul.

Într-o rețea clasică, prima adresă (10.20.0.0) identifică rețeaua, iar ultima (10.20.0.255) este adresa de broadcast, deci rămân 254 pentru hosturi.

De ce contează în securitate: regulile de firewall, grupurile de securitate din cloud și listele de acces folosesc CIDR. Diferența dintre a permite SSH din 203.0.113.10/32 (biroul tău) și din 203.0.113.0/16 este diferența dintre un IP și zeci de mii, iar 0.0.0.0/0 înseamnă oricine de pe internet. Greșelile frecvente:

  • se scrie /16 în loc de /32 din neatenție;
  • se folosește 0.0.0.0/0 „temporar” pentru depanare și rămâne așa;
  • se presupune că o adresă dintr-o plajă e „internă”, deși plaja e publică.

Poți verifica rapid în Python:

PYTHON
import ipaddress
net = ipaddress.ip_network("10.20.0.0/24")
print(net.num_addresses)                              # 256
print(ipaddress.ip_address("10.20.1.5") in net)       # False

Ce urmărește intervievatorul: Se verifică dacă stăpânești calculul de bază de rețea, fără de care nu poți citi sau scrie reguli de acces. Greșeala tipică este să nu știi cât de mare e o plajă dată.

Eroarea, în practică:ufw: WARN: Rule changed after normalizationufw: ERROR: Bad source address

10 Junior

Ce sunt adresele IP private (RFC 1918) și de ce NAT-ul nu este un firewall?

Răspuns scurt: Adresele private (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) nu sunt rutate pe internet și sunt folosite în rețele interne. NAT-ul traduce aceste adrese într-o adresă publică; efectul secundar că blochează conexiunile inițiate din afară nu înlocuiește un firewall cu reguli explicite.

RFC 1918 rezervă trei plaje pentru uz intern: 10.0.0.0/8, 172.16.0.0/12 și 192.168.0.0/16. Routerele de pe internet nu transmit pachete cu aceste destinații, așa că mai multe organizații pot folosi aceleași adrese în interior.

NAT (Network Address Translation) rescrie adresa sursă a pachetelor care ies, astfel încât multe dispozitive interne să folosească o singură adresă publică. Routerul ține o tabelă cu conexiunile active, ca să știe cui să trimită răspunsurile. O conexiune nouă venită din afară nu are intrare în tabelă, deci nu știe unde să meargă și este aruncată. De aici impresia că NAT-ul „protejează”.

De ce nu e suficient:

  • NAT-ul nu filtrează traficul de ieșire: un calculator infectat poate comunica liber cu un server de comandă și control.
  • Port forwarding-ul și UPnP pot deschide automat porturi spre interior, adesea fără ca administratorul să știe.
  • Cu IPv6, de multe ori nu mai există NAT, iar dispozitivele au adrese publice; dacă te bazai pe NAT, dintr-odată totul e expus.
  • NAT-ul nu are reguli, jurnalizare sau inspecție; un firewall are.

Concluzia practică: în spatele NAT-ului tot ai nevoie de un firewall cu politică explicită de tip „default deny”, pentru intrare și, ideal, și pentru ieșire.

Ce urmărește intervievatorul: Intervievatorul verifică dacă distingi un mecanism de adresare de un control de securitate. Greșeala frecventă este afirmația „suntem în spatele NAT-ului, deci suntem protejați”.

11 Junior

Ce este ICMP și de ce blocarea completă a lui pe firewall poate crea probleme?

Răspuns scurt: ICMP este protocolul de mesaje de control și erori din IP, folosit de ping și traceroute, dar și pentru semnalarea „destinație inaccesibilă” sau „pachet prea mare”. Dacă blochezi tot ICMP-ul, poți strica descoperirea MTU-ului pe cale și diagnoza rețelei.

ICMP (Internet Control Message Protocol) nu transportă date ale aplicațiilor, ci mesaje despre rețea. Câteva tipuri importante:

  • Echo Request / Echo Reply (tip 8 și 0): folosite de ping;
  • Destination Unreachable (tip 3): routerul spune că nu poate livra pachetul; subtipul 4, „fragmentation needed”, este esențial;
  • Time Exceeded (tip 11): TTL-ul a ajuns la zero, folosit de traceroute.

Mulți administratori blochează tot ICMP-ul „pentru securitate”, ca serverele să nu răspundă la ping. Efectul neplăcut apare la Path MTU Discovery: când un pachet e prea mare pentru o legătură de pe drum și are bitul „Don't Fragment”, routerul trimite înapoi un ICMP tip 3 cod 4. Dacă mesajul e blocat, emițătorul nu află și continuă să trimită pachete mari care se pierd. Simptomul clasic: conexiunea se stabilește, paginile mici se încarcă, dar transferurile mari sau anumite site-uri prin VPN se blochează.

În IPv6 situația este și mai strictă: ICMPv6 este necesar pentru descoperirea vecinilor și autoconfigurare, iar blocarea lui strică rețeaua.

Abordarea echilibrată este filtrarea selectivă: permiți tipurile necesare (3, 11 și, pentru diagnoză internă, 0 și 8), limitezi rata pentru echo, ca să nu fie folosite în atacuri de tip flood, și blochezi tipurile rar folosite, precum redirect, la marginea rețelei.

Ce urmărește intervievatorul: Se verifică dacă înțelegi efectele secundare ale unei reguli de securitate. Greșeala tipică este blocarea totală a ICMP-ului urmată de ore de depanare a unor conexiuni care „merg pe jumătate”.

12 Junior

Ce tipuri de înregistrări DNS cunoști și care dintre ele sunt relevante pentru securitate?

Răspuns scurt: Cele de bază sunt A și AAAA (nume către IPv4 și IPv6), CNAME (alias), MX (servere de email), NS (servere autoritare) și TXT (text liber). Pentru securitate contează TXT (SPF, verificări de domeniu), CAA (cine poate emite certificate) și CNAME-urile rămase spre servicii șterse.

Înregistrările uzuale:

  • A și AAAA: asociază un nume cu o adresă IPv4, respectiv IPv6.
  • CNAME: face un nume alias al altui nume, de exemplu shop.firma.ro spre firma.platforma-ecommerce.com.
  • MX: serverele care primesc email pentru domeniu.
  • NS: serverele DNS autoritare pentru zonă.
  • TXT: text arbitrar, folosit pentru politici de email și pentru dovada că deții un domeniu.
  • CAA: lista autorităților de certificare care au voie să emită certificate pentru domeniu.
  • PTR: rezoluția inversă, de la IP la nume.

Aspecte de securitate:

  • CAA reduce riscul ca o altă autoritate de certificare să emită un certificat pentru domeniul tău. O autoritate conformă verifică această înregistrare înainte de emitere.
  • CNAME-uri „atârnate” (dangling): dacă blog.firma.ro arată spre un serviciu cloud pe care l-ai șters, altcineva poate revendica acel nume în serviciul respectiv și poate servi conținut pe subdomeniul tău. Atacul se numește subdomain takeover. Prevenția: ștergi înregistrarea DNS înainte de a șterge resursa și verifici periodic zona.
  • TXT expune uneori ce servicii folosește firma (verificările de domeniu), informație utilă unui atacator pentru phishing țintit.

Comanda de verificare:

BASH
dig +short CAA firma.ro
dig +short CNAME blog.firma.ro

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi DNS și dincolo de „nume către IP”. Greșeala frecventă este să ignori riscul înregistrărilor uitate, care apare des în inventarele reale.

13 Junior

Ce este un reverse proxy și ce beneficii de securitate aduce în fața unei aplicații?

Răspuns scurt: Un reverse proxy (de exemplu Nginx, HAProxy, Caddy) primește cererile clienților în locul aplicației și le transmite mai departe spre serverele din spate. Ascunde aplicația de internet, centralizează TLS-ul, limitarea ratei și headerele de securitate.

Diferența față de un proxy obișnuit (forward proxy): forward proxy-ul stă în fața clienților și îi reprezintă când ies pe internet; reverse proxy-ul stă în fața serverelor și le reprezintă când sunt accesate.

Beneficii de securitate:

  • Aplicația nu e expusă direct: serverul de aplicație ascultă doar pe rețeaua internă sau pe 127.0.0.1, iar pe internet se vede doar proxy-ul.
  • TLS centralizat: certificatele și configurarea protocoalelor se fac într-un singur loc.
  • Limitarea ratei și a dimensiunii cererilor, utilă împotriva abuzurilor simple.
  • Headere de securitate adăugate uniform (HSTS, X-Content-Type-Options).
  • Filtrare: poți bloca accesul la căi interne (de exemplu /actuator sau /admin) din afară.

Exemplu Nginx:

server {
    listen 443 ssl;
    server_name app.firma.ro;
    client_max_body_size 10m;
    location /admin { deny all; }
    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Atenție la un efect secundar: aplicația vede acum IP-ul proxy-ului. Dacă ia IP-ul clientului din X-Forwarded-For, trebuie să aibă încredere în acest header doar când vine de la proxy-ul tău; altfel un client poate trimite un header fals și ocoli limitările pe IP.

Ce urmărește intervievatorul: Se verifică dacă știi componentele uzuale ale unei arhitecturi web și rolul lor defensiv. Greșeala tipică este încrederea oarbă în X-Forwarded-For.

14 Junior

Ce este un bastion host (jump server) și de ce îl folosești pentru administrarea serverelor?

Răspuns scurt: Un bastion host este un singur server, întărit și monitorizat, prin care treci ca să ajungi la serverele interne. Astfel, porturile de administrare (SSH, RDP) nu sunt expuse pe fiecare server, ci doar pe bastion, eventual doar prin VPN.

Fără bastion, fiecare server care trebuie administrat de la distanță are portul 22 sau 3389 deschis spre internet sau spre o rețea largă. Fiecare devine o țintă pentru încercări de autentificare și pentru vulnerabilități în serviciul de acces.

Cu un bastion:

  • serverele interne acceptă SSH doar din adresa bastionului;
  • bastionul este singurul punct expus, cu autentificare puternică (chei plus MFA);
  • toate sesiunile trec prin el, deci pot fi jurnalizate și, la nevoie, înregistrate;
  • revocarea accesului unei persoane se face într-un singur loc.

Cu OpenSSH, trecerea prin bastion se face cu ProxyJump, fără să copiezi cheia privată pe bastion:

# ~/.ssh/config
Host bastion
    HostName bastion.firma.ro
    User ana
Host db-*
    ProxyJump bastion
    User ana

Acum ssh db-01 trece automat prin bastion. Evită ForwardAgent yes pe bastion: dacă bastionul este compromis, cine are root pe el poate folosi agentul tău pentru a se autentifica în numele tău cât timp ești conectat.

Bastionul trebuie tratat ca un sistem foarte sensibil: minim de software instalat, actualizări prompte, fără alte roluri. Alternativele moderne sunt serviciile de acces gestionat din cloud (de exemplu AWS Systems Manager Session Manager) sau soluțiile de tip ZTNA, care elimină complet porturile de administrare deschise.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi cum se administrează sigur o flotă de servere. Greșeala frecventă este agent forwarding-ul activat pe bastion.

15 Junior

Ești conectat la un Wi-Fi public. Ce poate vedea un observator din rețea când accesezi un site prin HTTP și ce poate vedea când îl accesezi prin HTTPS?

Răspuns scurt: Prin HTTP vede tot: URL-ul complet, headerele, cookie-urile, formularele și conținutul. Prin HTTPS vede doar metadate: IP-ul serverului, de obicei numele domeniului (din DNS și din SNI), momentul și volumul traficului, nu și calea, parametrii sau conținutul.

Cu HTTP, cererea circulă în clar. Un observator pe aceeași rețea, sau operatorul punctului de acces, poate citi linia de cerere (GET /cont?id=123), headerele, inclusiv Cookie cu identificatorul de sesiune, datele trimise prin formulare și răspunsul complet. Poate și modifica traficul, de exemplu să injecteze cod în pagină.

Cu HTTPS, TLS criptează tot ce ține de HTTP: metoda, calea, query string-ul, headerele, cookie-urile și corpul. Rămân totuși vizibile:

  • adresa IP a serverului (din headerul IP);
  • numele domeniului: din interogarea DNS, dacă DNS-ul nu e criptat, și din câmpul SNI (Server Name Indication) al handshake-ului TLS, trimis în clar ca serverul să știe ce certificat să prezinte;
  • dimensiunea și ritmul traficului, din care uneori se pot deduce lucruri;
  • certificatul serverului, în TLS 1.2 (în TLS 1.3 este criptat).

Pentru a reduce și aceste scurgeri există DNS criptat (DoH, DoT) și Encrypted Client Hello (ECH), care criptează și SNI-ul, încă în curs de adoptare.

Concluzia de interviu: HTTPS protejează conținutul și integritatea, nu faptul că ai vizitat un anumit domeniu. Un VPN mută această vizibilitate de la rețeaua locală la furnizorul VPN, nu o elimină.

Ce urmărește intervievatorul: Se verifică dacă înțelegi exact ce protejează TLS. Greșeala frecventă este afirmația că HTTPS ascunde complet ce site vizitezi.

16 Junior

Care este diferența dintre WPA2-Personal, WPA3-Personal și WPA2/WPA3-Enterprise pentru o rețea Wi-Fi de firmă?

Răspuns scurt: WPA2-Personal folosește o parolă comună (PSK) și permite ghicirea offline a parolei dacă se capturează handshake-ul. WPA3-Personal folosește SAE, rezistent la acest atac. Enterprise (802.1X) autentifică fiecare utilizator sau dispozitiv individual printr-un server RADIUS și este alegerea potrivită pentru o firmă.

WPA2-Personal (PSK): toți folosesc aceeași parolă. Problemele: oricine pleacă din firmă o știe în continuare, nu poți revoca accesul unei singure persoane, iar dacă parola este slabă, un atacator care captează handshake-ul poate încerca parole offline, fără să interacționeze cu rețeaua.

WPA3-Personal înlocuiește schimbul PSK cu SAE (Simultaneous Authentication of Equals). Fiecare încercare de parolă cere o interacțiune cu punctul de acces, deci ghicirea offline nu mai funcționează, și oferă forward secrecy: cine află parola mai târziu nu poate decripta traficul capturat anterior. Parola rămâne însă comună.

Enterprise (802.1X): fiecare utilizator sau dispozitiv se autentifică individual, cu credențiale de domeniu sau, mai bine, cu certificate (EAP-TLS). Punctul de acces întreabă un server RADIUS. Avantaje:

  • revoci accesul unei persoane fără să schimbi nimic pentru ceilalți;
  • știi cine a fost conectat și când;
  • poți plasa utilizatorii în VLAN-uri diferite după rol.

Capcană importantă la Enterprise: clienții trebuie configurați să verifice certificatul serverului RADIUS. Altfel, un punct de acces fals cu același nume de rețea poate colecta credențialele.

Recomandare practică: Enterprise cu certificate pentru angajați, o rețea separată de tip guest, izolată de rețeaua internă, pentru vizitatori, și WPA3 acolo unde dispozitivele îl suportă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să recomanzi o configurație potrivită unei organizații. Greșeala tipică este o singură parolă Wi-Fi pentru toată firma, schimbată rar.

17 Mid

Ce este un atac SYN flood și cum îl atenuează mecanismul SYN cookies?

Răspuns scurt: SYN flood trimite multe SYN-uri, adesea cu surse false, fără să finalizeze handshake-ul, ca să umple coada de conexiuni a serverului. SYN cookies codifică starea în numărul de secvență din SYN-ACK, deci serverul alocă memorie doar la un ACK valid.

La un handshake normal, serverul primește SYN, răspunde cu SYN-ACK și păstrează o intrare în coada de backlog până sosește ACK-ul. Coada are dimensiune limitată. Dacă un atacator trimite foarte multe SYN-uri cu IP-uri sursă falsificate, SYN-ACK-urile pleacă spre adrese care nu răspund, intrările stau în coadă până la timeout, iar clienții legitimi nu mai pot deschide conexiuni.

SYN cookies schimbă strategia când coada se umple: serverul nu mai păstrează starea, ci o codifică în numărul de secvență inițial al SYN-ACK-ului. Valoarea este derivată criptografic din IP-uri, porturi, un timestamp și un secret al serverului. Când vine ACK-ul, serverul verifică dacă numărul confirmat corespunde unei valori pe care ar fi putut-o genera și abia atunci creează conexiunea. Un client care nu a primit SYN-ACK-ul (pentru că IP-ul său a fost falsificat) nu poate produce ACK-ul corect.

Pe Linux:

BASH
sysctl net.ipv4.tcp_syncookies          # 1 = activ când coada e plină (implicit)
sysctl net.ipv4.tcp_max_syn_backlog

Limitări: cookie-ul are spațiu puțin, așa că unele opțiuni TCP pot fi pierdute sau reduse, iar mecanismul nu ajută împotriva atacurilor volumetrice care saturează lățimea de bandă. Pentru acelea este nevoie de filtrare în amonte, la furnizor sau la un serviciu anti-DDoS.

Ce urmărește intervievatorul: Se verifică dacă înțelegi handshake-ul TCP la nivel de stare internă, nu doar ca diagramă. Greșeala frecventă este să crezi că SYN cookies opresc orice tip de DDoS.

18 Mid

Scrie un set minim de reguli nftables pentru un server web: implicit totul blocat la intrare, SSH permis doar din 192.0.2.0/28, HTTP și HTTPS permise de oriunde.

Răspuns scurt: Creezi un lanț de intrare cu politica drop, accepți traficul pe loopback și conexiunile deja stabilite, apoi deschizi explicit 22 doar pentru rețeaua de administrare și 80, 443 pentru toată lumea. Ordinea și regula pentru conexiuni stabilite sunt esențiale.

#!/usr/sbin/nft -f
flush ruleset

table inet filter {
    chain input {
        type filter hook input priority 0; policy drop;

        iif "lo" accept
        ct state established,related accept
        ct state invalid drop

        ip saddr 192.0.2.0/28 tcp dport 22 ct state new accept
        tcp dport { 80, 443 } ct state new accept

        icmp type { echo-request, destination-unreachable, time-exceeded } limit rate 10/second accept
        icmpv6 type { nd-neighbor-solicit, nd-neighbor-advert, nd-router-advert, packet-too-big, echo-request } accept
    }
    chain forward {
        type filter hook forward priority 0; policy drop;
    }
    chain output {
        type filter hook output priority 0; policy accept;
    }
}

Explicații:

  • policy drop face ca orice nu e permis explicit să fie aruncat.
  • Familia inet acoperă IPv4 și IPv6 în același tabel; uitarea IPv6 e o greșeală frecventă.
  • ct state established,related accept permite răspunsurile la conexiunile pe care serverul le-a inițiat și pachetele aferente conexiunilor deja acceptate. Fără această regulă, serverul nu ar mai primi răspunsurile DNS sau pe cele de la depozitele de actualizări.
  • Loopback-ul trebuie permis, altfel serviciile locale care comunică prin 127.0.0.1 nu mai funcționează.
  • ICMP-ul necesar (inclusiv packet-too-big pentru IPv6) rămâne permis.

Când aplici reguli pe un server la distanță, ai grijă să nu te blochezi singur: rulezi întâi nft -c -f fisier pentru verificarea sintaxei și ai un mecanism de revenire automată (de exemplu un job programat care resetează regulile peste câteva minute dacă nu confirmi) sau acces la consolă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți transforma conceptul de „default deny” în reguli funcționale. Greșelile tipice sunt lipsa regulii pentru conexiuni stabilite, uitarea IPv6 și blocarea propriei sesiuni SSH.

Eroarea, în practică:ssh: Connection timed outiptables: unknown option "--dport"

19 Mid

Ce este filtrarea traficului de ieșire (egress filtering) și de ce e importantă chiar dacă traficul de intrare e bine controlat?

Răspuns scurt: Egress filtering înseamnă să controlezi ce conexiuni pot iniția sistemele tale spre exterior. Reduce exfiltrarea de date, comunicarea malware-ului cu serverele de comandă și abuzul serverelor compromise, iar blocările din loguri devin un semnal de detecție.

Majoritatea organizațiilor filtrează atent intrarea și lasă ieșirea complet liberă. Dar după o compromitere aproape orice atac are nevoie de ieșire: malware-ul descarcă etapa următoare, contactează serverul de comandă și control, trimite datele furate. Un server de baze de date nu are niciun motiv să deschidă conexiuni HTTPS spre adrese aleatorii de pe internet.

Cum se aplică practic:

  • Servere: politică implicită de blocare la ieșire, cu excepții pentru ce e necesar: depozitele de actualizări, DNS-ul intern, API-urile partenerilor. Uneori prin proxy de ieșire cu listă de domenii permise.
  • Stații de lucru: traficul web trece printr-un proxy sau filtru care blochează categorii riscante și domenii nou înregistrate; restul porturilor sunt închise.
  • DNS: clienții au voie să folosească doar resolverele interne; cererile DNS directe spre exterior sunt blocate, ca să poți monitoriza și filtra rezoluțiile.
  • SMTP: portul 25 spre exterior permis doar serverelor de email, ca o stație infectată să nu trimită spam.

Beneficiul de detecție este la fel de important ca blocarea: o încercare respinsă a unui server de a contacta o adresă necunoscută este un semnal puternic în logurile firewall-ului.

Dificultatea reală este operațională: trebuie să știi ce comunicări sunt legitime. De obicei pornești în mod de monitorizare, construiești lista din trafic real, apoi treci la blocare.

Ce urmărește intervievatorul: Se verifică dacă gândești și la faza de după compromitere. Greșeala frecventă este să consideri că firewall-ul servește doar pentru a ține atacatorii afară.

20 Mid

Ce protejează DNSSEC și ce protejează DNS over HTTPS (DoH) sau DNS over TLS (DoT)? Se înlocuiesc unul pe altul?

Răspuns scurt: DNSSEC garantează autenticitatea și integritatea răspunsurilor DNS prin semnături, dar nu le criptează. DoH și DoT criptează canalul dintre client și resolver, pentru confidențialitate, dar nu dovedesc că datele vin nealterate de la sursa autoritară. Sunt complementare.

DNSSEC adaugă semnături digitale în zonele DNS. Fiecare zonă își semnează înregistrările, iar zona părinte garantează cheia zonei copil (prin înregistrarea DS), formând un lanț de încredere până la rădăcină. Un resolver care validează DNSSEC poate detecta un răspuns falsificat, de exemplu prin cache poisoning, unde un atacator încearcă să introducă în cache-ul unui resolver o adresă greșită pentru un domeniu. DNSSEC nu criptează: oricine pe drum vede ce nume cauți.

DoT (portul 853) și DoH (prin HTTPS, portul 443) criptează conversația dintre client și resolver. Observatorul din rețeaua locală nu mai vede numele interogate și nu le poate modifica pe drum. Dar resolverul vede tot și poate minți; iar între resolver și serverele autoritare traficul este de obicei tot necriptat.

Deci:

  • DNSSEC: „răspunsul e cel publicat de proprietarul domeniului”;
  • DoH/DoT: „nimeni dintre mine și resolver nu vede sau nu modifică cererea”.

Implicație pentru o organizație: dacă browserele folosesc DoH direct spre un furnizor public, ocolesc resolverul intern și, odată cu el, filtrarea și jurnalizarea DNS pe care se bazează echipa de securitate. De aceea multe firme configurează prin politici ca browserele să folosească resolverul intern (care poate oferi el însuși DoH) și blochează resolverele DoH externe cunoscute.

Ce urmărește intervievatorul: Intervievatorul verifică dacă distingi integritatea de confidențialitate într-un caz concret. Greșeala tipică este să crezi că DoH face DNSSEC inutil sau invers.

21 Senior

Rețeaua firmei e gândită doar pentru IPv4, dar sistemele de operare au IPv6 activ implicit. Ce riscuri apar și ce faci?

Răspuns scurt: Sistemele pot primi adrese și rute IPv6 de la un router fals și pot comunica pe căi pe care controalele gândite pentru IPv4 nu le văd. Fie gestionezi IPv6 la fel de atent (firewall, monitorizare, RA Guard), fie îl dezactivezi controlat.

Windows, macOS și majoritatea distribuțiilor Linux au IPv6 activ și îl preferă când e disponibil. Chiar dacă rețeaua nu are IPv6 configurat, fiecare interfață are o adresă link-local (fe80::/10) și ascultă mesaje Router Advertisement.

Riscuri concrete:

  • Router Advertisement fals: un dispozitiv din rețea anunță că este router IPv6 și, eventual, server DNS. Clienții își configurează automat adrese și pot trimite trafic prin el, o formă de om-la-mijloc care nu apare deloc în monitorizarea IPv4.
  • Reguli de firewall doar pentru IPv4: serviciul blocat cu iptables rămâne accesibil prin IPv6 dacă nimeni nu a scris reguli ip6tables sau dacă nu s-a folosit familia inet în nftables.
  • Puncte oarbe în monitorizare: IDS-ul, SIEM-ul și listele de IP-uri blocate pot ignora traficul IPv6.
  • Tuneluri automate (Teredo, 6to4 pe sisteme vechi) care trec prin firewall încapsulate în IPv4.

Ce faci:

  • decizi explicit: fie implementezi IPv6 complet, fie îl dezactivezi unde nu e necesar; varianta de mijloc, „există dar nu ne uităm”, este cea periculoasă;
  • activezi RA Guard și DHCPv6 Guard pe switch-uri, echivalentele pentru IPv6 ale protecțiilor DHCP;
  • scrii reguli de firewall pentru ambele familii și verifici cu o scanare IPv6 a propriilor servere;
  • adaugi traficul IPv6 în colectarea de loguri.

Microsoft recomandă să nu dezactivezi complet IPv6 pe Windows, ci să preferi IPv4 prin politică, deoarece unele componente se bazează pe el.

Ce urmărește intervievatorul: Se verifică dacă vezi controalele de securitate ca sistem, cu punctele lui oarbe. Greșeala tipică la nivel senior este să proiectezi totul pentru IPv4 și să ignori stiva paralelă.

22 Senior

Proiectează expunerea pe internet a unei aplicații web cu load balancer, servere de aplicație și bază de date. Unde se termină TLS-ul și ce compromisuri implică fiecare variantă?

Răspuns scurt: Expui doar load balancerul (eventual după CDN sau WAF), iar aplicația și baza de date stau în subrețele private, cu fluxuri minime. TLS-ul se termină la load balancer, se re-criptează sau trece neatins până la aplicație, după conformitate și modelul de amenințare.

O structură tipică pe trei niveluri:

  • Margine: CDN sau WAF, apoi load balancerul, singurele componente cu adresă publică.
  • Aplicație: servere în subrețea privată, care acceptă trafic doar de la load balancer, pe portul aplicației.
  • Date: baza de date în altă subrețea privată, care acceptă conexiuni doar de la serverele de aplicație, pe portul bazei de date. Fără acces la internet, nici la ieșire.

Administrarea se face prin bastion sau prin acces gestionat, nu prin porturi deschise.

Unde se termină TLS-ul:

  • La load balancer (offloading): certificatele sunt într-un singur loc, LB-ul poate inspecta HTTP (rutare pe căi, WAF, loguri detaliate), serverele lucrează mai puțin. Dezavantaj: traficul intern circulă în clar, deci cine ajunge în rețeaua internă îl poate citi.
  • Re-criptare: LB-ul termină TLS-ul clientului și deschide o nouă conexiune TLS spre aplicație. Păstrezi inspecția și ai criptare internă, cu costul gestionării certificatelor interne.
  • Passthrough (L4): LB-ul nu decriptează, doar transmite TCP. Criptare cap-coadă până la aplicație, dar pierzi inspecția HTTP și WAF-ul la acel nivel.

Standarde ca PCI DSS cer criptarea datelor de card pe rețelele publice deschise, iar evaluatorii și arhitecturile moderne de tip Zero Trust cer tot mai des criptare și pe rețelele interne. O alegere echilibrată frecventă este re-criptarea, cu mTLS între servicii acolo unde datele sunt sensibile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți proiecta o arhitectură defensivă și justifica compromisurile. Greșeala frecventă este presupunerea că rețeaua internă este de încredere, așa că traficul poate circula în clar fără discuție.

Criptografie, certificate și TLS

Exersează capitolul cu exerciții reale: Curs Cybersecurity online →
23 Junior

De ce un dezvoltator nu ar trebui să își scrie propriul algoritm de criptare sau propria implementare de AES?

Răspuns scurt: Pentru că securitatea unui algoritm se dovedește doar prin ani de analiză publică, iar implementarea corectă are capcane subtile (moduri de operare, padding, atacuri prin timp de execuție). Folosești biblioteci verificate, cu interfețe de nivel înalt.

Regula „don't roll your own crypto” are două părți.

Algoritmul: un algoritm nou pare sigur pentru autorul lui, pentru că autorul nu vede cum l-ar sparge. AES, SHA-2 sau ChaCha20 au rezistat ani de criptanaliză publică făcută de specialiști. Un XOR cu o cheie repetată sau o „amestecare” proprie de octeți poate fi spartă de multe ori în câteva ore.

Implementarea: chiar cu un algoritm bun, poți greși foarte ușor:

  • alegi un mod de operare nepotrivit sau refolosești vectorul de inițializare;
  • verifici integritatea după decriptare sau deloc, ceea ce deschide atacuri de tip padding oracle;
  • compari valori secrete cu operații care durează diferit în funcție de date, permițând atacuri prin timp;
  • generezi chei cu un generator de numere aleatoare necriptografic;
  • lași cheile în memorie sau în loguri.

Ce faci în schimb: folosești biblioteci mature, cu interfețe care fac alegerile corecte implicit. Exemple: libsodium (și legăturile ei pentru diverse limbaje), cryptography în Python cu Fernet sau AESGCM, Tink de la Google, API-urile standard ale platformei. Pentru transport folosești TLS, nu un protocol propriu.

PYTHON
from cryptography.fernet import Fernet
cheie = Fernet.generate_key()
f = Fernet(cheie)
token = f.encrypt(b"date secrete")   # criptare + autentificare
print(f.decrypt(token))

Ce urmărește intervievatorul: Se verifică maturitatea: știi că în criptografie detaliile contează și că încrederea vine din analiză publică. Greșeala tipică este o „criptare” făcută cu XOR sau Base64.

24 Junior

Ce proprietăți trebuie să aibă o funcție hash criptografică și de ce MD5 și SHA-1 nu mai sunt acceptate pentru semnături sau certificate?

Răspuns scurt: Trebuie să reziste la preimagine (nu afli intrarea din hash), la a doua preimagine și la coliziuni (nu găsești două intrări cu același hash). Pentru MD5 și SHA-1 există coliziuni practice, deci se pot crea documente diferite cu aceeași amprentă.

O funcție hash criptografică primește date de orice lungime și produce o valoare de lungime fixă. Proprietățile cerute:

  • determinism: aceeași intrare dă mereu același rezultat;
  • rezistență la preimagine: dat fiind un hash, este practic imposibil să găsești o intrare care îl produce;
  • rezistență la a doua preimagine: dată fiind o intrare, nu poți găsi alta cu același hash;
  • rezistență la coliziuni: nu poți găsi nicio pereche de intrări diferite cu același hash;
  • efectul de avalanșă: o schimbare de un bit modifică aproximativ jumătate din biții rezultatului.

MD5 are coliziuni care se generează în câteva secunde pe un laptop. Au fost folosite în practică pentru certificate false și pentru malware semnat (cazul Flame). SHA-1 a avut prima coliziune publică în 2017 (proiectul SHAttered), iar ulterior s-au demonstrat coliziuni cu prefix ales, deci mult mai utile unui atacator. Browserele și autoritățile de certificare au renunțat la certificatele SHA-1.

De ce contează coliziunile la semnături: semnătura se aplică pe hash-ul documentului. Dacă poți crea două documente cu același hash, unul inofensiv și unul malițios, obții semnătura pe primul și o folosești pentru al doilea.

Ce folosești azi: SHA-256, SHA-384 sau SHA-512 (familia SHA-2), SHA-3 sau BLAKE2/BLAKE3. MD5 mai apare la sume de control împotriva erorilor accidentale, nu împotriva unui adversar.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi de ce un algoritm devine depășit, nu doar lista algoritmilor interziși. Greșeala frecventă este confuzia între coliziune și preimagine.

Eroarea, în practică:sha256sum: computed checksum did NOT matchno mutual signature supported

25 Junior

Ce problemă rezolvă un salt la hash-urile parolelor și ce este un pepper?

Răspuns scurt: Saltul este o valoare aleatoare unică per parolă, stocată lângă hash: aceeași parolă dă hash-uri diferite, iar tabelele precalculate (rainbow tables) devin inutile. Pepper-ul este un secret comun, ținut în afara bazei, ca hash-urile furate singure să nu poată fi atacate.

Fără salt, două conturi cu parola Vara2024! au același hash în baza de date. Un atacator care fură baza:

  • vede imediat ce conturi împart parola;
  • folosește rainbow tables sau dicționare de hash-uri precalculate: calculează o dată hash-urile pentru milioane de parole comune și le caută pe toate dintr-odată.

Saltul (de exemplu 16 octeți aleatori, generați cu un generator criptografic) se concatenează cu parola înainte de hashing. Nu este secret, se stochează în clar lângă hash. Efectul: fiecare cont trebuie atacat separat, iar precalcularea devine inutilă. Algoritmii moderni (bcrypt, scrypt, Argon2) generează și stochează saltul automat, în același șir cu hash-ul:

$2b$12$C6UzMDM.H6dfI/f/IKcEeO5xUz1rU6F4hR5f6lY0bQe2Zk1nJxQ9u
 ^  ^  ^ salt (22 caractere)  ^ hash
 |  cost
 algoritm

Pepper-ul este un secret comun tuturor parolelor, ținut în configurația aplicației, într-un manager de secrete sau într-un HSM, nu în baza de date. Dacă atacatorul fură doar baza (de exemplu printr-o injecție SQL), fără pepper nu poate testa parole. O variantă frecventă este să aplici un HMAC cu pepper-ul înainte de hashing sau să criptezi hash-ul cu o cheie externă.

Nici saltul, nici pepper-ul nu compensează un algoritm rapid: un SHA-256 cu salt se testează în continuare cu miliarde de încercări pe secundă pe GPU.

Ce urmărește intervievatorul: Se verifică dacă înțelegi rolul fiecărui element, nu doar rețeta. Greșeala tipică este să crezi că saltul trebuie ținut secret sau că un salt global pentru toți utilizatorii este suficient.

26 Junior

Ce informații conține un certificat X.509 și cum le verifici din linia de comandă pentru un site?

Răspuns scurt: Un certificat conține subiectul și numele de domeniu (în extensia Subject Alternative Name), emitentul, perioada de valabilitate, cheia publică, utilizările permise și semnătura emitentului. Îl inspectezi cu openssl s_client combinat cu openssl x509.

Câmpurile importante:

  • Subject și, mai ales, Subject Alternative Name (SAN): numele pentru care e valid certificatul. Browserele moderne verifică doar SAN-ul, nu Common Name.
  • Issuer: autoritatea care l-a semnat.
  • Validity: notBefore și notAfter.
  • Public Key: cheia publică a serverului (RSA, ECDSA).
  • Key Usage și Extended Key Usage: pentru ce poate fi folosit (autentificare server, client, semnare de cod).
  • Basic Constraints: dacă este sau nu o autoritate de certificare (CA:TRUE).
  • Semnătura emitentului peste toate câmpurile de mai sus.

Verificarea unui site:

BASH
openssl s_client -connect exemplu.ro:443 -servername exemplu.ro </dev/null 2>/dev/null \
  | openssl x509 -noout -subject -issuer -dates -ext subjectAltName

-servername trimite SNI, necesar când pe același IP sunt mai multe site-uri; fără el poți primi alt certificat decât cel așteptat. Pentru întregul lanț și rezultatul validării:

BASH
openssl s_client -connect exemplu.ro:443 -servername exemplu.ro -showcerts </dev/null
# caută linia: Verify return code: 0 (ok)

La un audit verifici: numele din SAN corespund domeniilor folosite, data de expirare nu este apropiată, cheia are dimensiune adecvată (RSA de cel puțin 2048 de biți sau ECDSA P-256), algoritmul de semnătură nu este SHA-1, iar lanțul este complet. Expirarea certificatelor este una dintre cele mai frecvente cauze de indisponibilitate, de aceea se monitorizează automat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să inspectezi concret un certificat, nu doar ce este PKI. Greșeala tipică este uitarea parametrului -servername și analizarea certificatului greșit.

Eroarea, în practică:unable to get local issuer certificatecertificate has expired

27 Junior

Care este diferența dintre criptarea în tranzit, criptarea la repaus și criptarea end-to-end?

Răspuns scurt: Criptarea în tranzit protejează datele cât circulă prin rețea (de exemplu TLS). Criptarea la repaus le protejează pe disc sau în baza de date. End-to-end înseamnă că doar capetele comunicării (expeditorul și destinatarul) au cheile, iar serverele intermediare nu pot citi conținutul.

Fiecare tip acoperă alt scenariu de atac.

În tranzit: TLS între browser și server, între aplicație și baza de date, SSH, VPN. Protejează împotriva interceptării și modificării pe rețea. Datele ajung însă în clar la server.

La repaus: criptarea discului (BitLocker, LUKS), criptarea volumelor din cloud, criptarea transparentă a bazei de date (TDE), criptarea backupurilor. Protejează când mediul fizic ajunge la cine nu trebuie: laptop furat, disc aruncat, snapshot copiat. Nu protejează când atacatorul are acces la sistemul pornit: pentru aplicația care rulează, datele sunt decriptate transparent. O injecție SQL citește datele în clar chiar dacă baza este criptată la repaus.

Criptarea la nivel de aplicație (sau de câmp): aplicația criptează anumite câmpuri, de exemplu codul numeric personal, înainte să le scrie în bază. Un administrator de bază de date sau un backup furat nu vede valorile.

End-to-end: în aplicații de mesagerie precum Signal sau WhatsApp, cheile sunt doar pe dispozitivele utilizatorilor. Serverul transportă mesaje criptate pe care nu le poate citi. Dezavantaj: serverul nu poate căuta în conținut, nu poate scana și nu poate recupera mesajele dacă utilizatorul își pierde cheile.

La interviu, legătura importantă este cu modelul de amenințare: întrebi de cine te protejezi (rețea, furt fizic, administratori, furnizorul de cloud) și alegi stratul potrivit.

Ce urmărește intervievatorul: Se verifică dacă știi exact ce scenariu acoperă fiecare tip de criptare. Greșeala frecventă este să crezi că o bază criptată la repaus protejează împotriva unei injecții SQL.

28 Mid

Ce este un HMAC și de ce nu este sigur să calculezi integritatea unui mesaj ca SHA256(cheie + mesaj)?

Răspuns scurt: HMAC este un cod de autentificare a mesajului construit din hash și cheie, într-o structură în doi pași. SHA256(cheie + mesaj) permite atacul de extindere a lungimii: din hash-ul unui mesaj se calculează hash-ul mesajului prelungit, fără cheie.

Un MAC (Message Authentication Code) dovedește că mesajul a fost produs de cineva care deține cheia și că nu a fost modificat. Se folosește la webhook-uri semnate, la cookie-uri semnate, la tokenuri și la API-uri care verifică cererile.

SHA-256, ca și SHA-1 și MD5, are structura Merkle-Damgård: hash-ul final este starea internă după procesarea ultimului bloc. Dacă știi H(cheie || mesaj) și lungimea totală, poți continua calculul de la acea stare adăugând alte date, obținând un hash valid pentru cheie || mesaj || padding || date_noi, fără să cunoști cheia. Acesta este length extension attack.

HMAC evită problema prin construcția: H((K xor opad) || H((K xor ipad) || mesaj)). Hash-ul interior este „închis” de cel exterior, iar extinderea nu mai funcționează.

Verificarea corectă a unui webhook în Python:

PYTHON
import hmac, hashlib

def semnatura_valida(secret: bytes, corp: bytes, semnatura_hex: str) -> bool:
    calculat = hmac.new(secret, corp, hashlib.sha256).hexdigest()
    return hmac.compare_digest(calculat, semnatura_hex)

Două detalii: semnătura se calculează pe corpul brut al cererii, exact cum a sosit (nu pe JSON-ul re-serializat), iar comparația se face în timp constant cu compare_digest.

SHA-3 și BLAKE2 nu au această vulnerabilitate, dar HMAC rămâne alegerea standard și interoperabilă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi de ce o construcție criptografică „evidentă” poate fi greșită. Greșeala tipică este concatenarea simplă a cheii cu mesajul și comparația cu ==.

29 Mid

Un client Python dă eroarea „unable to get local issuer certificate” când se conectează la un server intern, deși în browser site-ul pare în regulă. Ce înseamnă și cum rezolvi corect?

Răspuns scurt: Clientul nu poate construi lanțul de la certificatul serverului la o rădăcină cunoscută: lipsește intermediarul sau rădăcina e o autoritate internă. Configurezi serverul să trimită lanțul complet sau adaugi rădăcina internă în depozitul clientului, nu dezactivezi verificarea.

Un certificat de server este semnat de obicei de o autoritate intermediară, care este semnată de o autoritate rădăcină. Clientul are în depozitul de încredere doar rădăcinile. Ca să valideze, trebuie să primească de la server certificatul propriu plus intermediarele, apoi să urce lanțul până la o rădăcină cunoscută, verificând semnătura fiecărei verigi, perioada de valabilitate și restricțiile.

De ce browserul funcționează: browserele păstrează în cache intermediare văzute anterior și unele le descarcă automat pe baza extensiei AIA din certificat. Bibliotecile precum OpenSSL, folosite de Python, nu fac asta. Un server configurat doar cu certificatul final „merge în browser” și cade în scripturi.

Diagnostic:

BASH
openssl s_client -connect intern.firma.ro:443 -servername intern.firma.ro -showcerts </dev/null

Dacă vezi un singur certificat în lanț, serverul nu trimite intermediarul. Soluția este pe server: în Nginx, ssl_certificate trebuie să indice fișierul cu certificatul plus intermediarele (fullchain).

Dacă rădăcina este o autoritate internă a firmei, o adaugi explicit în client:

PYTHON
import requests
requests.get("https://intern.firma.ro", verify="/etc/ssl/firma-root-ca.pem")

Sau o instalezi în depozitul de încredere al sistemului. Varianta verify=False face conexiunea vulnerabilă la orice om-la-mijloc și nu este o soluție.

Ce urmărește intervievatorul: Se verifică dacă înțelegi validarea lanțului în practică. Greșeala tipică este dezactivarea verificării certificatelor în loc de repararea configurării.

Eroarea, în practică:unable to get local issuer certificateself-signed certificate

30 Mid

Cum se revocă un certificat compromis înainte de expirare și de ce revocarea funcționează imperfect în practică?

Răspuns scurt: Autoritatea de certificare publică revocarea prin liste de revocare (CRL) sau prin răspunsuri OCSP. În practică, mulți clienți nu verifică revocarea sau o ignoră dacă serverul de verificare nu răspunde, de aceea industria se mută spre OCSP stapling și spre certificate cu durată scurtă.

Dacă cheia privată a unui server este furată, certificatul rămâne valid din punct de vedere criptografic până la notAfter. Revocarea anunță clienții să nu-l mai accepte.

Mecanisme:

  • CRL (Certificate Revocation List): o listă semnată de autoritate cu numerele de serie revocate, descărcată periodic. Poate deveni mare și are întârziere.
  • OCSP (Online Certificate Status Protocol): clientul întreabă autoritatea despre un anumit certificat. Probleme: latență suplimentară, autoritatea află ce site-uri vizitezi, iar dacă serverul OCSP nu răspunde, majoritatea clienților fac „soft-fail”, adică acceptă certificatul. Un atacator care poate face om-la-mijloc poate bloca și interogarea OCSP.
  • OCSP stapling: serverul obține periodic un răspuns OCSP semnat și îl atașează la handshake. Clientul nu mai contactează autoritatea.
  • Must-Staple: o extensie în certificat care cere clientului să refuze conexiunea fără răspuns OCSP atașat.

Direcția actuală este reducerea duratei de viață a certificatelor. Organismul CA/Browser Forum a aprobat în 2025 reducerea treptată a duratei maxime pentru certificatele publice TLS, până la 47 de zile în 2029. Let's Encrypt a anunțat renunțarea la OCSP în favoarea CRL-urilor. Browserele folosesc și liste agregate de revocare distribuite prin actualizări (de exemplu CRLite în Firefox).

Consecința practică: automatizează reînnoirea certificatelor (ACME) și tratează compromiterea unei chei ca incident: revoci, reemiți cu o cheie nouă și investighezi cum s-a scurs.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi limitele reale ale PKI, nu doar teoria. Greșeala frecventă este să crezi că revocarea are efect instant pentru toți clienții.

Eroarea, în practică:nginx: "ssl_stapling" ignored, no OCSP responder URL

31 Mid

Ce s-a schimbat în TLS 1.3 față de TLS 1.2 și de ce contează pentru securitate?

Răspuns scurt: TLS 1.3 a eliminat algoritmii și mecanismele slabe (schimbul de chei RSA static, CBC, RC4, SHA-1, compresia, renegocierea), impune forward secrecy, criptează mai mult din handshake și reduce handshake-ul la un singur drum dus-întors.

Principalele diferențe:

  • Doar schimb de chei efemer: în TLS 1.2 se putea folosi schimbul de chei RSA, în care clientul criptează secretul cu cheia publică a serverului. Cine obținea ulterior cheia privată putea decripta tot traficul capturat. TLS 1.3 permite doar (EC)DHE, deci forward secrecy este obligatoriu.
  • Suite de cifrare reduse: rămân doar algoritmi AEAD (criptare cu autentificare integrată): AES-GCM, ChaCha20-Poly1305, AES-CCM. Au dispărut CBC (sursa atacurilor de tip padding oracle precum Lucky13), RC4, 3DES și MD5/SHA-1 în semnături.
  • Handshake mai rapid: o singură călătorie dus-întors (1-RTT) în loc de două.
  • Mai mult criptat: certificatul serverului și majoritatea mesajelor de handshake sunt criptate după schimbul de chei.
  • Eliminări: compresia (atacul CRIME), renegocierea, formatele personalizate de grupuri Diffie-Hellman.
  • Protecție la downgrade: valori speciale în câmpul random al serverului permit detectarea încercărilor de a forța o versiune mai veche.

Un mecanism nou de urmărit este 0-RTT (early data): clientul care revine poate trimite date în primul pachet. Aceste date pot fi retrimise de un atacator (replay), deci trebuie permise doar pentru cereri idempotente, cum ar fi un GET fără efecte.

Recomandare uzuală de configurare: TLS 1.2 și 1.3 activate, cu suite moderne pentru 1.2, iar TLS 1.0 și 1.1 dezactivate (sunt declarate depreciate prin RFC 8996).

Ce urmărește intervievatorul: Se verifică dacă cunoști evoluția protocolului și motivele ei. Greșeala tipică este să spui doar „e mai rapid” fără să explici ce clase de atacuri au dispărut.

Eroarea, în practică:curl: (35) tlsv1 alert protocol versioncurl: (35) sslv3 alert handshake failure

32 Mid

Ce problemă de securitate are acest cod care generează tokenuri de resetare a parolei și cum îl corectezi?

PYTHON
import random, string

def token_resetare():
    alfabet = string.ascii_letters + string.digits
    return ''.join(random.choice(alfabet) for _ in range(8))

Răspuns scurt: Modulul random folosește un generator pseudo-aleator neconceput pentru securitate (Mersenne Twister), a cărui stare poate fi reconstruită din suficiente valori observate. În plus, 8 caractere sunt prea puține. Folosești secrets.token_urlsafe(32) și stochezi tokenul ca hash, cu expirare scurtă.

Modulul random din Python folosește Mersenne Twister. Este bun pentru simulări, nu pentru secrete: starea sa internă poate fi reconstruită dacă un atacator observă suficiente ieșiri (de exemplu cerând multe tokenuri pentru conturile proprii), iar apoi ieșirile următoare pot fi prezise. Documentația Python avertizează explicit să nu fie folosit în scopuri de securitate.

A doua problemă este lungimea: 62 de caractere posibile, 8 poziții, aproximativ 48 de biți. Cu un endpoint fără limitare a încercărilor, spațiul poate deveni accesibil unui atacator răbdător.

Varianta corectă:

PYTHON
import secrets, hashlib
from datetime import datetime, timedelta, timezone

def creeaza_token_resetare():
    token = secrets.token_urlsafe(32)                   # 256 de biți aleatori
    token_hash = hashlib.sha256(token.encode()).hexdigest()
    expira = datetime.now(timezone.utc) + timedelta(minutes=30)
    return token, token_hash, expira   # tokenul pleacă pe email, în bază se scrie doar hash-ul

Modulul secrets (Python 3.6+) folosește sursa de aleatorism criptografic a sistemului de operare. Alte reguli pentru tokenurile de resetare:

  • stochează doar hash-ul tokenului, ca o bază scursă să nu ofere tokenuri valide; un SHA-256 simplu este suficient aici, pentru că tokenul are entropie mare, spre deosebire de o parolă;
  • expirare scurtă și utilizare unică;
  • invalidează tokenurile anterioare la emiterea unuia nou și la schimbarea parolei.

Echivalentele în alte limbaje: SecureRandom în Java, crypto.randomBytes în Node.js, random_bytes în PHP.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferența dintre aleatorism statistic și criptografic. Greșeala frecventă este folosirea random, Math.random() sau a unui timestamp pentru tokenuri.

33 Senior

De ce refolosirea unui nonce cu AES-GCM este catastrofală și cum eviți asta într-un sistem care criptează multe mesaje cu aceeași cheie?

Răspuns scurt: Același nonce cu aceeași cheie produce același flux de cheie: textele clare se pot deduce, iar cheia de autentificare poate fi recuperată, deci mesajele pot fi falsificate. Previi prin nonce-uri aleatoare în limite de volum, contoare sigure, AES-GCM-SIV și rotirea cheilor.

AES-GCM combină modul contor (CTR) pentru confidențialitate cu GHASH pentru autentificare. Fluxul de cheie depinde doar de cheie și de nonce (IV, de obicei 96 de biți). Dacă două mesaje folosesc aceeași pereche:

  • C1 xor C2 = P1 xor P2, deci un text cunoscut îl dezvăluie pe celălalt;
  • mai grav, din două mesaje cu același nonce se poate calcula cheia de autentificare H, iar atacatorul poate produce mesaje noi care trec verificarea. Integritatea dispare complet pentru acea cheie.

Strategii:

  • Nonce aleator de 96 de biți: sigur dacă numărul de mesaje per cheie rămâne mic. Recomandarea NIST SP 800-38D limitează la 2 la puterea 32 invocări per cheie cu IV-uri aleatoare, ca probabilitatea de coliziune să rămână neglijabilă.
  • Nonce determinist (contor): sigur dacă poți garanta că nu se repetă niciodată, inclusiv după restart, în mai multe instanțe paralele sau după restaurarea unui snapshot. Aici apar cele mai multe bug-uri.
  • AES-GCM-SIV (RFC 8452): dacă nonce-ul se repetă, singura scurgere este că atacatorul vede când două mesaje identice au fost criptate identic.
  • XChaCha20-Poly1305: nonce de 192 de biți, suficient de mare ca generarea aleatoare să fie sigură practic la orice volum.
  • Rotirea cheilor sau derivarea unei chei per mesaj sau per fișier dintr-o cheie principală.

În design, cea mai sigură variantă este o bibliotecă de nivel înalt (Tink, libsodium) care alege nonce-ul pentru tine și nu îți permite să-l furnizezi greșit.

Ce urmărește intervievatorul: Se verifică înțelegerea modurilor AEAD dincolo de „folosește GCM”. Greșeala tipică la nivel senior este un contor care se resetează la repornirea serviciului.

34 Senior

Ce este mTLS și când l-ai folosi în locul unui API key pentru autentificarea între servicii?

Răspuns scurt: mTLS (mutual TLS) înseamnă că și clientul prezintă un certificat, nu doar serverul, deci ambele părți se autentifică criptografic în handshake. Îl folosești între servicii interne sau cu parteneri când vrei identități puternice, care nu pot fi copiate dintr-un header și se pot roti automat.

În TLS obișnuit, doar serverul își dovedește identitatea. Clientul se autentifică apoi la nivel de aplicație, cu parolă, token sau API key. Un API key este un secret static: dacă apare într-un log, într-un repository sau într-o captură de trafic, oricine îl poate folosi până este rotit manual.

În mTLS, serverul cere în handshake certificatul clientului și verifică că este semnat de o autoritate în care are încredere. Clientul dovedește că deține cheia privată fără să o trimită. Avantaje:

  • cheia privată nu circulă și nu ajunge în loguri;
  • identitatea este verificată înainte ca aplicația să proceseze vreun octet al cererii;
  • certificatele au durată limitată și pot fi rotite automat;
  • identitatea din certificat (de exemplu un ID SPIFFE de forma spiffe://firma/ns/plati/sa/api) poate fi folosită în politici de autorizare.

Unde se folosește: comunicarea între microservicii prin service mesh (Istio, Linkerd fac mTLS automat), API-uri bancare și de plăți către parteneri, dispozitive IoT, agenți care raportează către un server central.

Costuri reale: ai nevoie de o PKI internă, cu emitere, rotire și revocare automatizate; depanarea e mai grea; load balancerele care termină TLS trebuie configurate să transmită identitatea clientului sau să facă passthrough.

mTLS rezolvă autentificarea, nu autorizarea: după ce știi că cererea vine de la serviciul plati, tot trebuie să verifici ce are voie să facă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți alege mecanismul de autentificare potrivit între sisteme. Greșeala frecventă este să consideri mTLS suficient și pentru autorizare.

Eroarea, în practică:curl: (58) unable to set private key file

35 Senior

Ce este envelope encryption și de ce o folosesc serviciile de tip KMS din cloud?

Răspuns scurt: Datele se criptează local cu o cheie de date (DEK), iar DEK-ul se criptează cu o cheie principală (KEK) care nu iese din KMS sau HSM. Controlul accesului, auditul și rotirea se fac pe cheia principală, fără să treci datele prin KMS.

Problema: vrei să criptezi terabaiți de date, dar cheia principală trebuie să stea într-un HSM sau KMS și nu vrei să trimiți fiecare octet prin rețea spre serviciul de chei.

Fluxul:

  • aplicația cere KMS-ului o cheie de date nouă; primește cheia în clar și aceeași cheie criptată cu KEK-ul (de exemplu GenerateDataKey în AWS KMS);
  • criptează local datele cu DEK-ul (AES-256-GCM), apoi șterge DEK-ul în clar din memorie;
  • stochează datele criptate împreună cu DEK-ul criptat;
  • la citire, trimite DEK-ul criptat la KMS, primește cheia în clar (dacă are permisiunea) și decriptează local.

Beneficii:

  • Controlul accesului centralizat: cine nu are permisiunea Decrypt pe cheia principală nu poate citi datele, chiar dacă are acces la fișiere sau la bucket.
  • Audit: fiecare decriptare de DEK apare în loguri (CloudTrail, de exemplu), deci știi cine a accesat ce.
  • Performanță: criptarea grea se face local.
  • Rotire ieftină: rotirea KEK-ului înseamnă re-criptarea DEK-urilor, nu a tuturor datelor.
  • Ștergere criptografică: dacă distrugi cheia principală, datele devin ilizibile, inclusiv în backupuri.

Atenție la detalii: păstrează în cache DEK-urile în clar cât mai puțin timp și folosește contextul de criptare (date suplimentare autentificate) ca un DEK criptat pentru un client să nu poată fi decriptat în contextul altui client.

Ce urmărește intervievatorul: Se verifică dacă înțelegi cum se gestionează cheile la scară reală. Greșeala tipică este stocarea cheii principale lângă date sau trimiterea tuturor datelor direct prin KMS.

Autentificare, sesiuni și parole

36 Junior

Ce recomandă ghidul NIST SP 800-63B pentru politica de parole și de ce contrazice unele reguli „clasice”?

Răspuns scurt: Recomandă parole lungi (minim 8 caractere, ideal permițând cel puțin 64), verificarea lor față de liste de parole compromise sau comune și renunțarea la schimbarea periodică forțată și la regulile obligatorii de compoziție. Schimbarea se cere doar când există semne de compromitere.

Regulile clasice (minim 8 caractere, o majusculă, o cifră, un simbol, schimbare la 90 de zile) produc parole previzibile: Parola1!, apoi Parola2!. Oamenii adaptează minimul cerut, nu aleg parole mai bune.

NIST SP 800-63B, cu revizia 4 finalizată în 2025, recomandă:

  • lungime minimă de 8 caractere când parola e folosită alături de alt factor și de 15 când este singurul factor; acceptarea a cel puțin 64 de caractere, inclusiv spații și Unicode, ca utilizatorii să poată folosi fraze;
  • fără reguli de compoziție impuse;
  • fără expirare periodică; schimbare doar la indicii de compromitere;
  • verificare față de o listă de blocare: parole din scurgeri cunoscute, cuvinte din dicționar, secvențe (123456, qwerty), numele serviciului;
  • permiterea lipirii (paste), ca managerele de parole să funcționeze;
  • limitarea încercărilor eșuate;
  • fără întrebări de securitate de tip „numele primului animal”.

Pentru verificarea față de parole compromise există serviciul Have I Been Pwned, cu un API de tip k-anonymity: trimiți doar primele 5 caractere ale hash-ului SHA-1 al parolei și primești lista sufixelor care încep așa, deci parola nu părăsește sistemul tău.

La interviu poți încheia cu ideea că parola rămâne factorul cel mai slab și că o politică bună de parole se combină cu MFA.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ești la curent cu recomandările actuale, nu cu folclorul din politici vechi. Greșeala tipică este să recomanzi expirarea la 90 de zile ca bună practică.

Eroarea, în practică:BAD PASSWORD: The password is shorter than...Warning: your password will expire in 5 days.

37 Junior

Cum funcționează codurile TOTP generate de aplicațiile de autentificare și ce se întâmplă dacă ceasul telefonului e decalat?

Răspuns scurt: Serverul și aplicația împart un secret, primit prin cod QR, și calculează fiecare un HMAC peste secret și intervalul curent de 30 de secunde, din care rezultă 6 cifre. Pentru ceasuri decalate, serverul acceptă de obicei și intervalele vecine.

TOTP (Time-based One-Time Password, RFC 6238) se bazează pe HOTP (RFC 4226).

La înrolare, serverul generează un secret aleator și îl afișează ca cod QR, de forma otpauth://totp/Firma:ana?secret=JBSWY3DPEHPK3PXP&issuer=Firma. Aplicația îl salvează. Din acel moment nu mai e nevoie de comunicare între ele.

Calculul codului:

  • T = floor(timp_unix / 30), numărul intervalului curent;
  • HMAC-SHA1(secret, T);
  • din rezultat se extrag 4 octeți după o regulă de „truncare dinamică”, se iau ultimele 6 cifre.

Exemplu cu biblioteca pyotp:

PYTHON
import pyotp
secret = pyotp.random_base32()
totp = pyotp.TOTP(secret)
cod = totp.now()
print(totp.verify(cod, valid_window=1))   # acceptă și intervalul vecin

Despre decalajul de ceas: dacă telefonul este decalat cu un minut, codul lui corespunde altui interval. De aceea serverele acceptă o fereastră mică, de obicei un interval în urmă și unul înainte. O fereastră mare reduce securitatea.

Aspecte de securitate:

  • secretul trebuie stocat criptat pe server; cine îl fură poate genera coduri;
  • un cod folosit trebuie marcat ca utilizat, ca să nu poată fi refolosit în aceeași fereastră;
  • TOTP nu protejează de phishing în timp real: un site fals poate cere codul și îl poate folosi imediat;
  • la înrolare se oferă coduri de recuperare de unică folosință.

Ce urmărește intervievatorul: Se verifică dacă înțelegi mecanismul din spatele unei metode MFA folosite zilnic. Greșeala tipică este credința că aplicația comunică permanent cu serverul.

38 Junior

Ce atribute trebuie să aibă un cookie de sesiune și ce risc acoperă fiecare?

Răspuns scurt: Secure (doar prin HTTPS), HttpOnly (inaccesibil din JavaScript, deci greu de furat prin XSS), SameSite=Lax sau Strict (nu pleacă în majoritatea cererilor de pe alte site-uri) și, ideal, prefixul __Host-, plus o durată de viață rezonabilă.

Un cookie de sesiune bine configurat:

Set-Cookie: __Host-sid=7f3c9a...; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=3600

Ce face fiecare:

  • Secure: browserul trimite cookie-ul doar pe conexiuni HTTPS. Fără el, o singură cerere HTTP (de exemplu un link vechi http://) expune sesiunea în rețea.
  • HttpOnly: document.cookie nu îl vede. Dacă aplicația are o vulnerabilitate XSS, scriptul atacatorului nu poate trimite identificatorul de sesiune în altă parte. XSS-ul rămâne grav (scriptul poate face cereri în numele utilizatorului), dar furtul sesiunii pentru folosire ulterioară devine mai greu.
  • SameSite: Strict nu trimite cookie-ul în nicio cerere venită de pe alt site; Lax îl trimite doar la navigări de nivel superior cu metode sigure, de exemplu un click pe link; None îl trimite oriunde și cere Secure. Chrome tratează cookie-urile fără atribut ca Lax.
  • Prefixul __Host-: browserul acceptă cookie-ul doar dacă are Secure, Path=/ și nu are Domain. Astfel un subdomeniu compromis sau controlat de altcineva nu poate seta sau suprascrie cookie-ul aplicației principale.
  • Domain: dacă îl setezi la .firma.ro, cookie-ul ajunge la toate subdomeniile, inclusiv la cele mai puțin protejate. Omiterea lui îl limitează la host-ul exact.
  • Max-Age sau Expires: lipsa lor face cookie-ul „de sesiune de browser”, dar expirarea reală trebuie impusă pe server.

Valoarea însăși trebuie să fie un identificator aleator lung, fără date în clar despre utilizator.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi apărările concrete la nivel de browser. Greșeala frecventă este setarea atributului Domain larg fără motiv și uitarea Secure în medii mixte HTTP și HTTPS.

Eroarea, în practică:Set-Cookie blocked: "Secure" over HTTPSet-Cookie blocked: SameSite=None without Secure

39 Junior

De ce recomandă echipele de securitate un manager de parole și ce riscuri are el?

Răspuns scurt: Permite parole lungi, aleatoare și unice per cont, ceea ce face credential stuffing-ul inutil, și completează doar pe domeniul corect, ajutând împotriva phishing-ului. Riscul este concentrarea: seiful devine o țintă valoroasă, deci se protejează cu frază lungă și MFA.

Problema reală nu este că oamenii aleg parole slabe pentru un cont, ci că refolosesc aceeași parolă peste tot. Când un site oarecare este spart, atacatorii încearcă acele combinații pe email, VPN și aplicații de firmă. Un om nu poate memora 100 de parole aleatoare; un manager de parole poate.

Beneficii:

  • parole generate aleator, unice per cont;
  • completare legată de domeniu: extensia nu propune parola băncii pe banca-securitate-login.com. Dacă managerul nu sugerează nimic pe un site unde te aștepți să o facă, e un semnal de alarmă;
  • partajare controlată în echipe, în loc de parole trimise pe chat sau ținute în foi de calcul;
  • audit: arată parolele refolosite, slabe sau apărute în scurgeri.

Riscuri și cum se reduc:

  • parola principală trebuie să fie o frază lungă, folosită doar acolo, plus MFA pe cont;
  • compromiterea dispozitivului: un infostealer poate citi seiful deblocat; contează blocarea automată după inactivitate;
  • compromiterea furnizorului: seifurile serioase criptează local, cu o cheie derivată din parola principală (arhitectură zero-knowledge), deci furnizorul stochează doar date criptate. Incidentele publice din industrie au arătat totuși că metadatele, cum ar fi URL-urile, nu sunt întotdeauna criptate și că parolele principale slabe pot fi atacate offline.

În firme se folosesc variante enterprise, cu administrare centrală, recuperare de cont și revocare la plecarea unui angajat.

Ce urmărește intervievatorul: Se verifică dacă poți argumenta o măsură de igienă de bază, inclusiv limitele ei. Greșeala tipică este să spui „ține toate parolele într-un singur loc, deci e riscant” fără să compari cu alternativa reală.

40 Junior

Pagina de login afișează „Utilizator inexistent” sau „Parolă greșită”, în funcție de caz. De ce e o problemă și cum o rezolvi și la resetarea parolei?

Răspuns scurt: Mesajele diferite permit enumerarea utilizatorilor, adică aflarea adreselor care au cont, pentru atacuri țintite. Folosești un mesaj generic la login, același răspuns la resetare („Dacă există un cont, vei primi un email”) și elimini diferențele de timp de răspuns.

Enumerarea utilizatorilor este primul pas pentru multe atacuri: password spraying pe conturi reale, phishing țintit („am văzut că ai cont la noi”) sau dezvăluirea faptului că o persoană folosește un serviciu sensibil.

Locurile unde apare:

  • mesajele de la login;
  • formularul de resetare a parolei („Nu există niciun cont cu acest email”);
  • înregistrarea („Emailul este deja folosit”);
  • coduri HTTP sau structuri JSON diferite în API;
  • timpul de răspuns: dacă utilizatorul nu există, aplicația răspunde imediat; dacă există, calculează hash-ul bcrypt și răspunde mai târziu. Diferența se măsoară ușor.

Rezolvări:

  • mesaj identic pentru login: „Email sau parolă incorecte”;
  • la resetare, același răspuns și același cod HTTP în ambele cazuri; emailul se trimite doar dacă există cont;
  • pentru timp, calculezi oricum un hash pe un șir fictiv când utilizatorul nu există:
PYTHON
HASH_FICTIV = bcrypt.hashpw(b"x", bcrypt.gensalt())

def autentifica(email, parola):
    user = gaseste_user(email)
    h = user.hash_parola if user else HASH_FICTIV
    ok = bcrypt.checkpw(parola.encode(), h)
    return user if (user and ok) else None
  • la înregistrare, poți trimite un email („Cineva a încercat să creeze un cont cu adresa ta”) în loc să afișezi eroarea pe ecran;
  • limitarea ratei pe toate aceste endpoint-uri.

Contează și compromisul cu experiența utilizatorului: unele produse aleg conștient să arate dacă emailul există. Decizia trebuie luată explicit, cu protecții compensatorii.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi scurgerile mici de informație și din canale indirecte. Greșeala frecventă este rezolvarea mesajului de la login și uitarea resetării, a înregistrării și a diferenței de timp.

41 Mid

Ce este session fixation și cum îl previi?

Răspuns scurt: Session fixation înseamnă că atacatorul face victima să folosească un identificator de sesiune pe care îl cunoaște deja, iar după ce victima se autentifică, atacatorul folosește aceeași sesiune. Previi atacul generând un identificator de sesiune nou la autentificare și la orice schimbare de privilegii.

Scenariul: aplicația creează o sesiune pentru vizitatorii anonimi și păstrează același identificator după login. Dacă atacatorul poate impune victimei un identificator cunoscut (printr-un parametru în URL acceptat de aplicație, prin setarea unui cookie de pe un subdomeniu controlat sau printr-o vulnerabilitate XSS), victima se autentifică pe acea sesiune, care devine autentificată și pentru atacator.

Prevenție:

  • Regenerare la login: după autentificarea reușită, invalidezi sesiunea veche și creezi una nouă, copiind doar datele necesare.
PHP
session_start();
if (verifica_credentiale($email, $parola)) {
    session_regenerate_id(true);   // true = șterge sesiunea veche
    $_SESSION['user_id'] = $id;
}

În Spring Security, comportamentul implicit (sessionFixation().changeSessionId()) face acest lucru. În Express cu express-session apelezi req.session.regenerate().

  • Regenerare la schimbarea privilegiilor: când utilizatorul trece în modul administrator sau confirmă din nou parola pentru o operație sensibilă.
  • Nu accepta identificatori de sesiune din URL; doar din cookie.
  • Nu accepta identificatori necunoscuți: dacă clientul trimite un ID pe care serverul nu l-a emis, serverul creează unul nou, nu îl adoptă pe cel primit.
  • Prefixul __Host- la cookie împiedică subdomeniile să seteze cookie-ul aplicației.
  • La logout, sesiunea se distruge pe server, nu doar se șterge cookie-ul din browser.

Majoritatea framework-urilor moderne fac regenerarea automat, dar implementările proprii de sesiune sau configurațiile modificate o pot pierde.

Ce urmărește intervievatorul: Se verifică dacă înțelegi ciclul de viață al unei sesiuni. Greșeala tipică este păstrarea aceluiași ID de sesiune înainte și după autentificare.

42 Mid

Unde e problema în această verificare a unui token API și cum o corectezi?

PYTHON
def verifica_token(primit: str) -> bool:
    return primit == TOKEN_ASTEPTAT

Răspuns scurt: Comparația cu == se oprește la primul caracter diferit, deci durata ei depinde de câte caractere sunt corecte. Prin măsurători repetate, un atacator poate ghici tokenul caracter cu caracter (timing attack). Folosești o comparație în timp constant: hmac.compare_digest.

Comparația obișnuită de șiruri este optimizată: compară octet cu octet și se oprește la prima diferență. Un token care începe cu caracterul corect este respins puțin mai târziu decât unul greșit de la primul caracter. Diferența e de ordinul nanosecundelor, dar cu multe cereri și analiză statistică, mai ales în rețele apropiate sau din același centru de date, un atacator poate determina prefixul corect și apoi caracterul următor. Astfel, spațiul de căutare scade de la exponențial la liniar.

Corectarea:

PYTHON
import hmac

def verifica_token(primit: str) -> bool:
    return hmac.compare_digest(primit.encode(), TOKEN_ASTEPTAT.encode())

compare_digest parcurge întotdeauna toate octeții și durata nu depinde de poziția primei diferențe. Echivalente: MessageDigest.isEqual în Java, crypto.timingSafeEqual în Node.js (care cere buffere de lungimi egale), hash_equals în PHP.

O abordare și mai robustă este să nu compari secretul direct: stochezi hash-ul tokenului și compari hash-ul celui primit. Astfel, chiar dacă baza de date este citită, tokenurile nu sunt expuse, iar timpul comparației nu mai oferă informații despre secretul original.

Alte locuri unde contează: verificarea semnăturilor HMAC la webhook-uri, verificarea codurilor de resetare, compararea tokenurilor CSRF. Hash-urile de parole verificate cu bcrypt.checkpw sau cu funcțiile Argon2 folosesc deja comparații în timp constant.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că și canalele laterale contează. Greșeala frecventă este considerarea problemei pur teoretice.

43 Mid

Cum protejezi formularul de login împotriva ghicirii parolelor fără să le permiți atacatorilor să blocheze intenționat conturile utilizatorilor legitimi?

Răspuns scurt: Blocarea definitivă după câteva încercări îi dă oricui puterea să blocheze conturi. Folosești limitare progresivă: întârzieri crescătoare per cont, limite per IP și per rețea, o provocare suplimentară (CAPTCHA) după un prag, detecția tiparelor distribuite și MFA, care face ghicirea parolei insuficientă.

Blocarea contului după 5 încercări eșuate pare sigură, dar transformă protecția într-un atac: cine știe adresele de email ale angajaților poate bloca toată firma trimițând câte 5 parole greșite pentru fiecare. Situația e și mai gravă dacă deblocarea cere intervenția suportului.

O strategie stratificată:

  • Limitare per cont, cu întârziere progresivă: după câteva eșecuri, următoarea încercare e permisă abia după 1 minut, apoi 5, apoi 15. Contul nu se blochează, dar ghicirea devine foarte lentă. Ghidul NIST cere ca numărul de încercări eșuate să fie limitat la cel mult 100 per cont, cu mecanisme care permit totuși accesul utilizatorului legitim.
  • Limitare per IP și per subrețea: oprește atacurile din puține surse.
  • Detecția atacurilor distribuite: password spraying vine din multe IP-uri, cu puține încercări per cont. Se detectează prin volumul total de eșecuri, prin aceeași parolă încercată pe multe conturi, prin user-agent-uri sau prin IP-uri din rețele de proxy.
  • Provocare suplimentară (CAPTCHA, verificare prin email) doar după un prag sau la scor de risc mare, nu pentru toată lumea.
  • Dispozitive recunoscute: un utilizator care se loghează de pe un dispozitiv cunoscut (cookie de dispozitiv) poate fi tratat cu limite mai permisive decât cererile anonime.
  • MFA: chiar dacă parola este ghicită, contul nu este compromis.
  • Notificare către utilizator la încercări multiple sau la login de pe dispozitiv nou.

Logurile de autentificare eșuată trebuie centralizate, pentru că atacurile distribuite se văd doar în agregat.

Ce urmărește intervievatorul: Se verifică dacă vezi și efectul advers al unui control de securitate. Greșeala tipică este blocarea definitivă a contului ca singură măsură.

Eroarea, în practică:Failed password for invalid userFailed password for root

44 Mid

Descrie un flux sigur de resetare a parolei, de la cererea utilizatorului până la setarea parolei noi.

Răspuns scurt: Răspuns identic la cerere, link cu token aleator de unică folosință, cu expirare scurtă și stocat ca hash, construit cu domeniu fix. La folosire setezi parola nouă după regulile obișnuite, invalidezi tokenurile și sesiunile active și notifici utilizatorul.

Pașii și detaliile care contează:

  • Cererea: formularul primește emailul. Răspunsul este identic, indiferent dacă există sau nu cont, ca să nu permită enumerarea. Endpoint-ul are limitare de rată per email și per IP, altfel poate fi folosit pentru a trimite spam victimei.
  • Generarea tokenului: aleator criptografic, cel puțin 128 de biți. În baza de date stochezi hash-ul lui, utilizatorul, data de expirare (de exemplu 30–60 de minute) și starea „nefolosit”.
  • Linkul: construit cu un domeniu fix din configurație, nu din headerul Host al cererii. Dacă aplicația folosește Host, un atacator poate cere resetarea pentru victimă cu un Host falsificat, iar victima primește un link legitim spre domeniul atacatorului (host header injection).
  • Pagina de resetare: verifică tokenul (hash, expirare, nefolosit). Pagina nu trebuie să încarce resurse externe, pentru că tokenul din URL poate ajunge la terți prin headerul Referer; setezi Referrer-Policy: no-referrer.
  • Parola nouă: aceleași reguli ca la înregistrare, inclusiv verificarea față de parole compromise.
  • După schimbare: marchezi tokenul ca folosit, invalidezi celelalte tokenuri de resetare, închizi toate sesiunile active (dacă atacatorul avea acces, îl pierde) și trimiți un email de notificare cu instrucțiuni pentru cazul în care utilizatorul nu a cerut schimbarea.
  • MFA: dacă contul are MFA, resetarea parolei nu ar trebui să ocolească al doilea factor.

Nu trimite niciodată parola nouă sau veche pe email și nu folosi întrebări de securitate ca singur mecanism de recuperare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți proiecta un flux complet, unde fiecare detaliu închide un atac. Greșeala frecventă este folosirea headerului Host la construirea linkului și lăsarea sesiunilor vechi active.

45 Mid

Explică la nivel de concept cum funcționează autentificarea Kerberos într-o rețea Windows cu Active Directory.

Răspuns scurt: Utilizatorul se autentifică o dată la KDC (controlerul de domeniu) și primește un TGT. Cu el cere tichete de serviciu pentru fiecare resursă. Parola nu circulă prin rețea, iar tichetele au durată limitată.

Kerberos este protocolul implicit de autentificare în domeniile Active Directory. Componente: clientul, serviciul și KDC-ul (Key Distribution Center, rol jucat de controlerul de domeniu), format din serviciul de autentificare (AS) și serviciul de acordare a tichetelor (TGS).

Fluxul simplificat:

  • AS-REQ / AS-REP: la logare, clientul trimite o cerere în care un timestamp este criptat cu o cheie derivată din parola utilizatorului (preautentificare). KDC-ul verifică și întoarce un TGT (Ticket Granting Ticket), criptat cu cheia contului special krbtgt, plus o cheie de sesiune.
  • TGS-REQ / TGS-REP: când utilizatorul accesează un share de fișiere, clientul prezintă TGT-ul și cere un tichet de serviciu pentru acel serviciu (identificat printr-un SPN, Service Principal Name). Tichetul este criptat cu cheia contului care rulează serviciul.
  • AP-REQ: clientul prezintă tichetul serviciului, care îl decriptează cu propria cheie și află cine este utilizatorul și din ce grupuri face parte.

Proprietăți importante pentru securitate:

  • parola nu circulă; se folosesc chei derivate din ea;
  • tichetele au durată limitată (implicit 10 ore pentru TGT);
  • ceasurile trebuie sincronizate (toleranță implicită de 5 minute), altfel autentificarea eșuează;
  • securitatea depinde de cheile conturilor: un cont de serviciu cu parolă slabă sau compromiterea contului krbtgt afectează grav tot domeniul.

Măsuri defensive asociate: parole lungi sau conturi gestionate (gMSA) pentru serviciile cu SPN, criptare AES în loc de RC4, rotirea periodică a parolei krbtgt, monitorizarea evenimentelor 4768 și 4769.

Ce urmărește intervievatorul: Se verifică dacă înțelegi mecanismul de bază al autentificării în rețelele de firmă. Greșeala tipică este confuzia dintre TGT și tichetul de serviciu.

46 Senior

O aplicație single-page păstrează tokenul de acces în localStorage. Ce riscuri vezi și ce arhitectură ai propune?

Răspuns scurt: Orice script de pe pagină, inclusiv un XSS sau o dependență compromisă, poate citi localStorage și exfiltra tokenul, folosibil apoi de oriunde. Mai sigur este modelul backend-for-frontend: tokenurile stau pe server, browserul are doar un cookie HttpOnly, Secure, SameSite.

Riscurile localStorage:

  • este accesibil oricărui script de pe aceeași origine, deci un XSS sau un script terț compromis (analytics, widget de chat) poate citi tokenul;
  • tokenul furat poate fi folosit de pe orice dispozitiv, până la expirare, fără ca atacatorul să mai depindă de pagina victimei;
  • persistă după închiderea browserului.

Alternative, de la mai puțin la mai mult sigur:

  • Token în memorie (variabilă JavaScript) cu refresh token într-un cookie HttpOnly: XSS-ul nu mai poate citi refresh token-ul, dar poate citi tokenul de acces cât timp pagina rulează.
  • Backend-for-Frontend (BFF): un server propriu, pe aceeași origine, face fluxul OAuth, păstrează tokenurile și le atașează la cererile spre API-uri. Browserul are doar un cookie de sesiune HttpOnly; Secure; SameSite=Strict. Ghidul IETF „OAuth 2.0 for Browser-Based Applications” recomandă acest model ca fiind cel mai sigur.

Compromisuri:

  • cu cookie-uri, trebuie tratată protecția CSRF (SameSite ajută, iar pentru operațiile sensibile adaugi tokenuri anti-CSRF sau verifici headerul Origin);
  • BFF-ul este o componentă în plus, de operat și scalat.

Important: niciun mod de stocare nu „rezolvă” XSS-ul. Un script injectat poate face cereri în numele utilizatorului cât timp este pe pagină. Ce câștigi este că atacatorul nu poate lua tokenul cu el. De aceea BFF-ul se combină cu o politică CSP strictă, durate scurte pentru tokenuri și rotirea refresh token-urilor la fiecare folosire.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți cântări compromisuri de arhitectură, nu doar repeta „localStorage e rău”. Greșeala frecventă este să crezi că mutarea în cookie elimină impactul XSS.

Securitatea aplicațiilor web (OWASP)

47 Junior

Care este diferența dintre validarea input-ului și encodarea output-ului și de ce ai nevoie de amândouă?

Răspuns scurt: Validarea verifică la intrare că datele au forma așteptată (tip, lungime, valori permise). Encodarea face, la ieșire, ca datele să fie interpretate ca date, nu ca cod, în contextul exact (HTML, URL, SQL, shell). Validarea reduce riscul, encodarea contextuală îl elimină.

Validarea input-ului răspunde la întrebarea „sunt datele ce mă aștept?”. Bune practici:

  • validare pe server (cea din browser e doar pentru confortul utilizatorului);
  • listă de valori permise (allowlist) în loc de listă de valori interzise: varsta este un întreg între 0 și 150, tara este unul dintre codurile ISO, sortare este pret sau data;
  • limite de lungime și tip.

Problema: multe câmpuri legitime conțin caractere „periculoase”. Numele O'Brien are apostrof, un comentariu poate conține < și >. Nu poți respinge totul.

Encodarea output-ului răspunde la întrebarea „cum fac ca aceste date să nu fie interpretate drept cod acolo unde le pun?”. Depinde de context:

  • în HTML: < devine <, & devine &;
  • într-un atribut HTML: encodare de atribut și ghilimele în jurul valorii;
  • într-un URL: encodare procentuală (encodeURIComponent);
  • în SQL: interogări parametrizate, nu encodare manuală;
  • în comenzi de sistem: liste de argumente, nu șiruri trecute prin shell.

Același șir poate fi sigur într-un context și periculos în altul. De aceea encodarea se face în momentul ieșirii, nu la salvarea în bază: nu știi dinainte unde vor ajunge datele.

În practică, framework-urile moderne fac encodarea implicit (Jinja2, Thymeleaf, React escapează textul), iar vulnerabilitățile apar când dezvoltatorul o ocolește explicit, de exemplu cu |safe, th:utext sau dangerouslySetInnerHTML.

Ce urmărește intervievatorul: Se verifică dacă înțelegi principiul din spatele majorității vulnerabilităților de injecție. Greșeala tipică este „curățarea” input-ului la intrare cu o listă neagră de caractere.

48 Junior

Ce vulnerabilitate are acest cod și cum îl rescrii?

PYTHON
import subprocess
from flask import request

@app.route('/ping')
def ping():
    host = request.args.get('host')
    out = subprocess.check_output(f'ping -c 1 {host}', shell=True)
    return out

Răspuns scurt: Este o injecție de comenzi (command injection): cu shell=True, valoarea primită este interpretată de shell, deci caractere precum ;, && sau $() permit executarea altor comenzi pe server. Rescrii cu listă de argumente, fără shell, și validezi strict valoarea.

Codul construiește un șir și îl dă shell-ului. Shell-ul interpretează metacaractere: separatori de comenzi, redirecționări, substituții. Orice utilizator poate deci adăuga propriile comenzi după numele host-ului, iar ele rulează cu drepturile procesului aplicației. Impactul tipic este compromiterea completă a serverului.

Rescrierea sigură:

PYTHON
import ipaddress, re, subprocess
from flask import request, abort

HOSTNAME = re.compile(r"^(?=.{1,253}$)([a-zA-Z0-9-]{1,63}\.)*[a-zA-Z0-9-]{1,63}$")

@app.route('/ping')
def ping():
    host = request.args.get('host', '')
    try:
        ipaddress.ip_address(host)
    except ValueError:
        if not HOSTNAME.match(host) or host.startswith('-'):
            abort(400)
    rezultat = subprocess.run(
        ['ping', '-c', '1', '--', host],
        capture_output=True, text=True, timeout=5
    )
    return rezultat.stdout

Ce s-a schimbat:

  • lista de argumente fără shell=True: programul ping primește valoarea ca un singur argument, iar metacaracterele nu mai au semnificație;
  • validarea: acceptăm doar o adresă IP sau un nume de host valid;
  • -- marchează sfârșitul opțiunilor, ca o valoare care începe cu - să nu fie interpretată ca opțiune a programului (argument injection);
  • timeout, ca cererile să nu țină procese blocate.

Cel mai bine e să eviți complet comenzile externe când există o bibliotecă pentru aceeași sarcină. Procesul aplicației trebuie să ruleze cu un utilizator fără privilegii, ca impactul unei eventuale greșeli să fie limitat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști o injecție în afara SQL-ului. Greșeala frecventă este să încerci să filtrezi caracterele periculoase în loc să elimini shell-ul.

49 Junior

Unde e vulnerabilitatea în acest endpoint de descărcare și cum o corectezi?

PYTHON
import os
from flask import request, send_file

DIR = '/srv/app/facturi'

@app.route('/descarca')
def descarca():
    nume = request.args.get('fisier')
    return send_file(os.path.join(DIR, nume))

Răspuns scurt: Este path traversal: un nume ca ../../../etc/passwd iese din director, iar os.path.join ignoră complet directorul de bază dacă primește o cale absolută. Corectezi rezolvând calea finală și verificând că rămâne în director (sau folosind send_from_directory) și verificând că utilizatorul are dreptul la acea factură.

Două probleme cu os.path.join:

  • secvențele ../ urcă în ierarhie, deci facturi/../../../etc/passwd ajunge la fișierele sistemului;
  • dacă al doilea argument este absolut, os.path.join('/srv/app/facturi', '/etc/passwd') întoarce pur și simplu /etc/passwd.

Corectarea:

PYTHON
import os
from flask import request, abort, send_from_directory
from flask_login import current_user

DIR = os.path.realpath('/srv/app/facturi')

@app.route('/descarca')
def descarca():
    nume = request.args.get('fisier', '')
    cale = os.path.realpath(os.path.join(DIR, nume))
    if os.path.commonpath([cale, DIR]) != DIR or not os.path.isfile(cale):
        abort(404)
    if not factura_apartine(current_user.id, os.path.basename(cale)):
        abort(404)
    return send_from_directory(DIR, os.path.relpath(cale, DIR))
  • realpath rezolvă .. și legăturile simbolice și dă calea reală;
  • commonpath verifică că rezultatul rămâne în director. O comparație simplă cu startswith('/srv/app/facturi') ar accepta și /srv/app/facturi-vechi;
  • send_from_directory din Flask face și el o verificare sigură;
  • verificarea proprietarului închide a doua problemă: fără ea, orice utilizator poate descărca factura altuia schimbând numele.

Varianta cea mai robustă este să nu primești deloc nume de fișiere de la client: primești un ID de factură, verifici în baza de date că aparține utilizatorului și de acolo afli calea, generată de server.

Ce urmărește intervievatorul: Se verifică dacă știi capcanele lucrului cu căi de fișiere. Greșeala tipică este filtrarea șirului ../, care se ocolește prin encodări sau căi absolute.

50 Junior

Ce problemă de securitate are acest cod JavaScript și cum o rezolvi?

JavaScript
const params = new URLSearchParams(location.search);
const nume = params.get('nume');
document.getElementById('salut').innerHTML = 'Bun venit, ' + nume + '!';

Răspuns scurt: Este un XSS bazat pe DOM: valoarea din URL ajunge în innerHTML, deci un element HTML cu un handler de eveniment execută JavaScript în pagina victimei. Folosești textContent, iar dacă ai nevoie de HTML, îl treci printr-un sanitizer precum DOMPurify.

Vulnerabilitatea apare integral în browser: serverul poate să nu vadă nimic suspect, iar valoarea din URL ajunge direct într-o funcție care interpretează HTML. Aceste funcții se numesc sink-uri periculoase: innerHTML, outerHTML, insertAdjacentHTML, document.write, eval, setTimeout cu șir, atribute href cu valori de tip javascript:.

Un element <script> inserat prin innerHTML nu se execută, dar un element precum o imagine cu sursă invalidă și un atribut onerror se execută. Atacatorul trimite victimei un link cu un astfel de element în parametrul nume, iar codul rulează cu drepturile victimei pe acel site.

Rezolvarea simplă:

JavaScript
document.getElementById('salut').textContent = `Bun venit, ${nume ?? ''}!`;

textContent tratează valoarea ca text, deci < apare pe ecran ca simbol, nu ca început de element.

Dacă ai nevoie să inserezi HTML care vine de la utilizator, de exemplu text formatat:

JavaScript
import DOMPurify from 'dompurify';
el.innerHTML = DOMPurify.sanitize(htmlPrimit);

Măsuri suplimentare:

  • în React, Vue sau Angular, textul este escapat implicit; riscul apare la dangerouslySetInnerHTML, v-html sau la ocolirea sanitizer-ului Angular;
  • o politică CSP strictă limitează ce scripturi pot rula, ca a doua linie de apărare;
  • Trusted Types, suportat în browserele bazate pe Chromium, poate bloca orice atribuire de șiruri simple către innerHTML, obligând echipa să folosească funcții de sanitizare aprobate.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști XSS-ul care nu trece prin server și știi API-urile sigure ale DOM-ului. Greșeala frecventă este să cauți doar <script> în input.

51 Junior

Dă exemple concrete de „security misconfiguration” într-o aplicație web și spune cum le previi sistematic.

Răspuns scurt: Debug activ în producție, stack trace-uri afișate, conturi implicite, listarea directoarelor, endpoint-uri de administrare expuse, stocare publică, headere lipsă. Le previi prin configurații standard versionate, imagini întărite și verificări automate la fiecare deploy.

Configurarea greșită este o categorie din OWASP Top 10 pentru că nu ține de un bug în cod, ci de felul în care e instalat și rulat sistemul. Exemple frecvente:

  • DEBUG = True în Django sau modul de dezvoltare în alte framework-uri: paginile de eroare afișează variabile, setări și uneori secrete;
  • stack trace-uri trimise clientului, care dezvăluie versiuni, căi și interogări;
  • conturi implicite (admin/admin) pe panouri de administrare, baze de date sau echipamente;
  • listarea directoarelor activă pe serverul web;
  • fișiere care nu ar trebui servite: .git/, .env, backupuri .sql sau .zip în directorul public;
  • endpoint-uri de monitorizare expuse public, de exemplu Spring Boot Actuator cu /actuator/env sau /actuator/heapdump;
  • stocare în cloud cu acces public sau baze de date ascultând pe toate interfețele fără autentificare;
  • CORS permisiv, headere de securitate lipsă, TLS vechi activ;
  • servicii și funcționalități nefolosite lăsate active.

Prevenție sistematică:

  • configurație ca cod: aceeași configurație de bază, versionată și revizuită, pentru toate mediile, cu diferențele explicite;
  • imagini standard întărite (CIS Benchmarks) pentru servere și containere;
  • verificări automate în pipeline: scanere de configurație pentru infrastructură ca cod (Checkov, tfsec), scanare DAST pe mediul de test, verificarea că DEBUG e oprit;
  • pagini de eroare generice în producție, cu detaliile doar în loguri;
  • inventar și scanări periodice ale suprafeței expuse.

Ce urmărește intervievatorul: Se verifică dacă știi că multe incidente vin din configurare, nu din cod. Greșeala tipică este să dai un singur exemplu fără o abordare de prevenție.

Eroarea, în practică:nginx: directory index is forbidden

52 Junior

Ce este clickjacking și cum îți protejezi aplicația împotriva lui?

Răspuns scurt: Clickjacking înseamnă că un site malițios încarcă pagina ta într-un iframe invizibil peste propriul conținut, astfel încât utilizatorul crede că apasă pe ceva inofensiv, dar de fapt apasă un buton din aplicația ta, cu sesiunea lui. Te protejezi interzicând încadrarea prin Content-Security-Policy: frame-ancestors sau X-Frame-Options.

Scenariul: utilizatorul este logat în aplicația ta. Vizitează un site care afișează, de exemplu, un buton „Revendică premiul”. Exact sub acel buton, într-un iframe transparent, este încărcată pagina ta cu butonul „Șterge contul” sau „Confirmă transferul”. Click-ul ajunge în iframe, iar browserul trimite cererea cu cookie-urile utilizatorului.

Protecția principală este să spui browserului cine are voie să-ți încadreze paginile:

Content-Security-Policy: frame-ancestors 'none'

Variante:

  • frame-ancestors 'none': nimeni nu poate încadra pagina;
  • frame-ancestors 'self': doar paginile de pe aceeași origine;
  • frame-ancestors 'self' https://portal.partener.ro: o listă explicită.

Headerul mai vechi, încă util pentru browsere vechi:

X-Frame-Options: DENY

(sau SAMEORIGIN). Valoarea ALLOW-FROM este învechită și ignorată de browserele moderne, de aceea pentru liste de origini folosești frame-ancestors.

Măsuri complementare:

  • cookie-urile cu SameSite=Lax sau Strict nu sunt trimise în iframe-uri de pe alte site-uri, deci pagina încadrată apare neautentificată;
  • confirmări suplimentare (reintroducerea parolei, cod MFA) pentru operațiuni ireversibile.

Scripturile de tip „frame busting” (JavaScript care detectează încadrarea) sunt considerate nesigure, pentru că pot fi dezactivate prin atributul sandbox al iframe-ului. Headerele sunt soluția corectă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi un atac care nu depinde de un bug în logica aplicației. Greșeala frecventă este să crezi că X-Frame-Options: ALLOW-FROM mai funcționează.

Eroarea, în practică:CSP: Refused to frame ... frame-ancestors

53 Junior

Ce este un open redirect și de ce contează, deși nu permite direct accesul la date?

Răspuns scurt: Un open redirect apare când aplicația redirecționează utilizatorul spre o adresă luată dintr-un parametru, fără verificare, de exemplu /login?next=https://site-fals.ro. Atacatorul folosește domeniul tău de încredere ca să ducă victimele pe pagini de phishing și, în fluxurile OAuth, poate fura coduri de autorizare.

Exemplu vulnerabil:

PYTHON
@app.route('/login', methods=['POST'])
def login():
    # ... autentificare reușită
    return redirect(request.args.get('next', '/'))

De ce contează:

  • phishing credibil: un link care începe cu domeniul real al băncii trece de verificarea vizuală a utilizatorului și uneori de filtrele de email;
  • OAuth: dacă un endpoint de redirect acceptat ca redirect_uri poate fi deturnat spre un domeniu extern, codul de autorizare sau tokenul pot ajunge la atacator;
  • ocolirea listelor de domenii permise în alte funcționalități, de exemplu un SSRF filtrat pe domeniu, care urmează redirecționarea.

Corectarea: permiți doar căi relative interne sau o listă fixă de destinații.

PYTHON
from urllib.parse import urlparse

def destinatie_sigura(url: str) -> str:
    if not url:
        return '/'
    url = url.replace('\\', '/')
    p = urlparse(url)
    if p.scheme or p.netloc or not url.startswith('/') or url.startswith('//'):
        return '/'
    return url

Verificările acoperă capcanele frecvente: //site-fals.ro este interpretat de browser ca URL absolut (fără schemă), unele browsere tratează backslash-ul ca slash, iar o comparație de tipul „conține numele domeniului meu” acceptă firma.ro.site-fals.ro.

Alternativa cea mai robustă este să nu primești deloc URL-ul, ci un identificator (next=facturi) pe care serverul îl transformă în cale.

Ce urmărește intervievatorul: Se verifică dacă recunoști vulnerabilitățile cu impact indirect și înlănțuirea lor. Greșeala tipică este validarea cu startswith('/'), care acceptă //domeniu-extern.

54 Mid

Aplicația permite sortarea după o coloană aleasă de utilizator. De ce nu poți folosi un parametru de interogare pentru numele coloanei și cum faci codul sigur?

JAVA
String sql = "SELECT id, nume, pret FROM produse ORDER BY " + req.getParameter("sort");

Răspuns scurt: Parametrii pregătiți înlocuiesc doar valori, nu identificatori ca numele coloanelor sau direcția de sortare, așa că mulți revin la concatenare și creează o injecție SQL. Soluția este o listă de valori permise care mapează opțiunea la o coloană fixă din cod.

Interogările parametrizate rezolvă injecția pentru valori: WHERE pret > ? primește un număr care nu poate deveni cod SQL. Dar ORDER BY ? ar sorta după o valoare constantă (practic, deloc), nu după coloana cu acel nume. Același lucru e valabil pentru nume de tabele, ASC și DESC sau LIMIT în unele baze de date.

Concatenarea din exemplu permite oricui să pună orice expresie SQL după ORDER BY, inclusiv subinterogări. Chiar dacă rezultatul nu este afișat direct, un atacator poate extrage date prin diferențe în ordinea rezultatelor sau prin erori.

Varianta sigură:

JAVA
private static final Map<String, String> COLOANE = Map.of(
    "nume", "nume",
    "pret", "pret",
    "nou",  "data_adaugare"
);

String col = COLOANE.getOrDefault(req.getParameter("sort"), "id");
String dir = "desc".equalsIgnoreCase(req.getParameter("dir")) ? "DESC" : "ASC";
String sql = "SELECT id, nume, pret FROM produse ORDER BY " + col + " " + dir + " LIMIT ?";
try (PreparedStatement ps = conn.prepareStatement(sql)) {
    ps.setInt(1, 50);
    ResultSet rs = ps.executeQuery();
}

Concatenarea rămâne, dar se concatenează doar șiruri din cod, niciodată input. Același principiu în ORM-uri: metodele de tip order_by(text(...)) din SQLAlchemy sau orderByRaw din Laravel primesc SQL brut și au nevoie de aceeași listă. Ca strat suplimentar, contul cu care aplicația se conectează la bază are doar drepturile necesare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi limitele interogărilor parametrizate, o sursă reală de injecții în aplicații altfel corecte. Greșeala frecventă este escaparea manuală a numelui coloanei.

55 Mid

Ce face Content Security Policy și de ce o politică cu 'unsafe-inline' în script-src oferă puțină protecție împotriva XSS?

Răspuns scurt: CSP este un header care spune browserului ce scripturi și resurse are voie pagina să încarce și să execute. Cu 'unsafe-inline', scripturile injectate în HTML rulează, adică forma tipică a XSS-ului. O politică eficientă folosește nonce-uri sau hash-uri și 'strict-dynamic'.

CSP este o a doua linie de apărare: dacă cineva reușește să injecteze HTML în pagină, browserul refuză să execute scripturile care nu respectă politica.

O politică frecventă, dar slabă:

Content-Security-Policy: script-src 'self' 'unsafe-inline' https://cdn.exemplu.com

'unsafe-inline' permite elementele script inline și handlerele de tip onclick, deci majoritatea XSS-urilor funcționează în continuare. Listele de domenii au și ele probleme: dacă un CDN permis găzduiește biblioteci vechi sau endpoint-uri JSONP, pot fi folosite pentru a rula cod arbitrar.

O politică strictă, bazată pe nonce:

Content-Security-Policy:
  script-src 'nonce-R4nd0mV4lu3' 'strict-dynamic';
  object-src 'none';
  base-uri 'none';
  frame-ancestors 'none'

Serverul generează un nonce aleator nou la fiecare răspuns și îl pune pe scripturile legitime (atributul nonce al elementului script). Un script injectat nu cunoaște nonce-ul, deci nu rulează. 'strict-dynamic' permite scripturilor de încredere să încarce alte scripturi, ceea ce face politica practică pentru aplicații moderne. object-src 'none' blochează pluginurile, iar base-uri 'none' împiedică schimbarea URL-ului de bază pentru căile relative.

Pentru introducere fără să strici aplicația, folosești întâi Content-Security-Policy-Report-Only cu raportare, analizezi încălcările, muți handlerele inline în fișiere JavaScript, apoi activezi politica. CSP nu înlocuiește encodarea output-ului; o completează.

Ce urmărește intervievatorul: Se verifică dacă știi să deosebești o politică CSP decorativă de una eficientă. Greșeala tipică este adăugarea 'unsafe-inline' ca aplicația să meargă și considerarea problemei rezolvate.

Eroarea, în practică:CSP: Refused to load the scriptCSP: Refused to execute inline script

56 Mid

Un API răspunde cu Access-Control-Allow-Origin egal cu valoarea headerului Origin din cerere și cu Access-Control-Allow-Credentials: true. Ce risc creează?

Răspuns scurt: Orice site vizitat de un utilizator logat poate face cereri spre API cu cookie-urile lui și poate citi răspunsurile, deci poate fura date personale sau tokenuri. CORS trebuie configurat cu o listă exactă de origini permise, verificată pe server.

Same-Origin Policy împiedică o pagină de pe site-rau.ro să citească răspunsurile cererilor spre api.firma.ro. CORS (Cross-Origin Resource Sharing) este mecanismul prin care serverul relaxează controlat această regulă, spunând browserului ce origini pot citi răspunsurile.

Specificația interzice combinația Access-Control-Allow-Origin: * cu credențiale. Ca să ocolească restricția, unele aplicații reflectă orice Origin primit. Rezultatul este echivalent cu „orice site, cu cookie-urile utilizatorului”: o pagină malițioasă face fetch('https://api.firma.ro/profil', {credentials: 'include'}) și citește răspunsul.

Variante greșite frecvente:

  • reflectarea oricărei origini;
  • verificări de tip „se termină cu firma.ro”, care acceptă rauFirma.ro, sau „conține firma.ro”, care acceptă firma.ro.atacator.com;
  • acceptarea originii null, care poate fi trimisă din iframe-uri sandbox sau din fișiere locale.

Configurare corectă:

PYTHON
PERMISE = {"https://app.firma.ro", "https://admin.firma.ro"}

@app.after_request
def cors(resp):
    origin = request.headers.get("Origin")
    if origin in PERMISE:
        resp.headers["Access-Control-Allow-Origin"] = origin
        resp.headers["Access-Control-Allow-Credentials"] = "true"
        resp.headers["Vary"] = "Origin"
    return resp

Vary: Origin împiedică un cache intermediar să servească răspunsul cu headerul unei origini către alta. Reține că CORS controlează doar citirea răspunsurilor din browser; nu este autentificare și nu oprește cererile trimise din afara browserului.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi ce protejează și ce nu protejează CORS. Greșeala frecventă este confuzia dintre CORS și un mecanism de autorizare.

57 Mid

Ce vulnerabilitate are acest endpoint de actualizare a profilului și cum o corectezi?

JavaScript
app.put('/api/profil', auth, async (req, res) => {
  await User.updateOne({ _id: req.user.id }, req.body);
  res.json({ ok: true });
});

Răspuns scurt: Este mass assignment: întregul corp al cererii ajunge în baza de date, deci utilizatorul poate trimite câmpuri pe care nu ar trebui să le controleze, de exemplu rol: "admin", verificat: true sau sold. Corectezi acceptând explicit doar câmpurile permise și validând fiecare valoare.

Formularul de profil din interfață trimite probabil doar nume și telefon, dar API-ul acceptă orice cheie. Un utilizator poate trimite manual:

JSON
{ "nume": "Ana", "rol": "admin", "emailVerificat": true }

iar modelul se actualizează cu toate câmpurile. Problema apare în orice framework care leagă automat datele cererii de obiecte: Mongoose, Rails, Laravel ($fillable lipsă), Spring (@ModelAttribute pe entități), ASP.NET (model binding pe entități).

Corectarea cu o listă de câmpuri permise și validare:

JavaScript
const { z } = require('zod');

const ProfilUpdate = z.object({
  nume: z.string().min(1).max(100).optional(),
  telefon: z.string().regex(/^\+?[0-9 ]{6,20}$/).optional(),
}).strict();   // respinge câmpurile necunoscute

app.put('/api/profil', auth, async (req, res) => {
  const rezultat = ProfilUpdate.safeParse(req.body);
  if (!rezultat.success) return res.status(400).json({ eroare: 'date invalide' });
  await User.updateOne({ _id: req.user.id }, { $set: rezultat.data });
  res.json({ ok: true });
});

Puncte cheie:

  • obiecte de transfer (DTO) separate de entitățile din baza de date, cu doar câmpurile modificabile de utilizator;
  • $set cu date validate, nu obiectul brut; altfel, cu MongoDB, utilizatorul poate trimite și operatori;
  • câmpurile sensibile (rol, sold, stare de verificare) se modifică doar prin endpoint-uri separate, cu autorizare proprie.

Această clasă de probleme intră în OWASP API Security Top 10 la autorizarea la nivel de proprietate a obiectului.

Ce urmărește intervievatorul: Se verifică dacă vezi riscurile legării automate a datelor. Greșeala tipică este să te bazezi pe faptul că interfața nu trimite câmpurile sensibile.

58 Mid

Ce este o vulnerabilitate XXE și cum configurezi un parser XML ca să o eviți?

Răspuns scurt: XXE apare când un parser XML rezolvă entitățile externe definite în documentul primit, ceea ce permite citirea fișierelor de pe server, cereri spre rețeaua internă sau consum excesiv de resurse. O eviți dezactivând DTD-urile și entitățile externe.

XML permite definirea de entități într-un DTD (Document Type Definition). O entitate externă poate face referire la un fișier local sau la un URL. Dacă aplicația primește XML de la utilizatori (importuri, SOAP, SAML, fișiere DOCX sau SVG, care sunt bazate pe XML) și parserul rezolvă aceste entități, conținutul referit poate ajunge în răspuns sau poate fi transmis în altă parte. Variante ale problemei: citirea fișierelor, cereri spre servicii interne (similar SSRF) și „billion laughs”, unde entități imbricate se expandează exponențial și consumă memoria.

Prevenție: dezactivezi DTD-urile complet, dacă nu ai nevoie de ele (aproape niciodată nu ai).

În Java, unde multe parsere sunt vulnerabile implicit:

JAVA
DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
f.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
f.setFeature("http://xml.org/sax/features/external-general-entities", false);
f.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
f.setXIncludeAware(false);
f.setExpandEntityReferences(false);
DocumentBuilder b = f.newDocumentBuilder();

În Python, biblioteca standard xml.etree nu rezolvă entități externe în versiunile actuale, dar documentația recomandă defusedxml pentru date nesigure:

PYTHON
import defusedxml.ElementTree as ET
arbore = ET.fromstring(xml_primit)

În .NET, versiunile moderne au DtdProcessing setat pe Prohibit implicit pentru XmlReader.

Unde poți, folosești JSON pentru date noi, păstrezi bibliotecile XML actualizate și testezi explicit importurile cu fișiere care conțin DTD-uri, ca să verifici că sunt respinse.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că XML-ul are funcționalități periculoase activate implicit în unele parsere. Greșeala frecventă este să uiți că SVG, DOCX și SAML sunt tot XML.

59 Mid

Ce verificări faci pe server la o funcționalitate de încărcare a fișierelor (de exemplu poza de profil)?

Răspuns scurt: Limitezi dimensiunea, verifici tipul real al conținutului, nu doar extensia sau Content-Type, generezi tu numele fișierului, îl stochezi în afara directorului executabil (ideal într-un storage separat), îl servești cu tipul corect și Content-Disposition potrivit și, pentru imagini, le re-procesezi.

Încărcarea de fișiere combină mai multe riscuri: execuție de cod pe server, XSS prin fișiere servite de pe domeniul tău, path traversal prin nume, consum de resurse și distribuirea de malware.

Verificări și măsuri:

  • Dimensiune maximă impusă la proxy și în aplicație.
  • Listă de tipuri permise, verificate după conținut, cu biblioteci care citesc semnătura fișierului (magic bytes), nu după extensie sau după headerul Content-Type trimis de client, pe care îl controlează utilizatorul.
  • Nume generat de server (UUID), cu extensia aleasă de tine după tipul detectat. Numele original, dacă e necesar, se păstrează doar în baza de date.
  • Stocare în afara rădăcinii web sau într-un serviciu de stocare de obiecte, astfel încât un fișier .php sau .jsp să nu poată fi executat niciodată.
  • Servire de pe un domeniu separat (de exemplu fisiere-firma-cdn.net), ca un HTML sau un SVG încărcat să nu ruleze cu cookie-urile aplicației principale.
  • Headere la servire: Content-Type corect, X-Content-Type-Options: nosniff și Content-Disposition: attachment pentru tipurile care nu trebuie afișate în browser.
  • Re-procesarea imaginilor: decodezi și re-encodezi imaginea cu o bibliotecă (Pillow, libvips), ceea ce elimină metadatele (inclusiv coordonatele GPS din EXIF) și conținutul atașat. Bibliotecile de procesare trebuie ținute la zi.
  • SVG: tratat ca document activ; fie îl respingi, fie îl sanitizezi.
  • Arhive: atenție la dezarhivarea care scrie în afara directorului (zip slip) și la arhivele care se expandează enorm.
  • Scanare antimalware pentru fișierele partajate cu alți utilizatori.

Ce urmărește intervievatorul: Se verifică dacă tratezi încărcarea ca suprafață de atac complexă. Greșeala tipică este validarea extensiei și a Content-Type-ului trimis de client.

60 Senior

De ce este periculoasă deserializarea datelor nesigure (de exemplu cu pickle în Python sau ObjectInputStream în Java) și ce alternative ai?

Răspuns scurt: Serializarea nativă poate reconstrui obiecte arbitrare și apela cod la deserializare, deci date controlate de atacator pot duce la execuție de cod. Folosești formate de date (JSON, Protobuf) cu schemă, iar formatul nativ doar cu semnătură verificată și listă de clase permise.

Serializarea nativă salvează obiecte cu tot cu tipul lor, ca să poată fi recreate exact. Problema este că recrearea execută cod:

  • în Python, pickle poate instrui deserializarea să apeleze orice funcție importabilă, prin mecanismul __reduce__. Documentația spune explicit că modulul pickle nu este sigur pentru date nesigure;
  • în Java, ObjectInputStream.readObject instanțiază clase și apelează metode precum readObject din ele. Combinate, clasele din bibliotecile existente pe classpath formează lanțuri de gadget-uri care duc la execuție de comenzi, chiar dacă aplicația nu are niciun cod vulnerabil propriu;
  • probleme similare există cu unserialize în PHP, BinaryFormatter în .NET (declarat învechit și eliminat în .NET 9) și unele configurații YAML (de exemplu yaml.load fără loader sigur în PyYAML).

Unde apare: cookie-uri sau parametri care conțin obiecte serializate, cozi de mesaje, cache-uri partajate, protocoale RMI și JMX, fișiere încărcate.

Alternative și măsuri:

  • formate de date, nu de obiecte: JSON, Protobuf, cu validare după schemă și mapare explicită pe tipuri;
  • yaml.safe_load în loc de yaml.load;
  • dacă formatul nativ e inevitabil: semnătură HMAC pe date, verificată înainte de deserializare, ca doar serverul să poată produce date acceptate;
  • în Java, filtre de deserializare (ObjectInputFilter, din Java 9 și portat în versiuni de întreținere ale Java 8) cu listă de clase permise;
  • scoaterea din classpath a bibliotecilor nefolosite, care reduc lanțurile de gadget-uri disponibile;
  • proces cu privilegii minime și monitorizarea excepțiilor de deserializare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi o clasă de vulnerabilități cu impact critic, des întâlnită în sisteme enterprise. Greșeala frecventă la nivel senior este semnarea datelor după ce au fost deja deserializate.

61 Senior

Aplicația ta descarcă imagini de la un URL dat de utilizator. Ai pus o listă de domenii interzise și blochezi IP-urile private după rezolvarea DNS. De ce poate fi încă vulnerabilă la SSRF și ce arhitectură ai propune?

Răspuns scurt: Validarea se poate ocoli prin redirecționări, DNS rebinding, forme alternative ale adreselor sau IPv6. Soluția robustă este arhitecturală: un serviciu de descărcare izolat, fără rute spre rețeaua internă, cu filtrare la nivel de rețea și IMDSv2 în cloud.

Ocolirile frecvente ale unei validări făcute în aplicație:

  • Redirecționări: URL-ul verificat este extern, dar răspunde cu 302 spre o adresă internă; clientul HTTP urmează redirecționarea fără să mai valideze.
  • DNS rebinding: aplicația rezolvă numele, vede un IP public și aprobă; biblioteca HTTP rezolvă numele din nou la conectare, iar acum primește 127.0.0.1 (atacatorul controlează serverul DNS și setează un TTL foarte mic).
  • Reprezentări alternative: adrese în format zecimal, octal, prescurtat, adrese IPv6 de tip IPv4-mapped (::ffff:127.0.0.1) sau [::1], care trec de expresiile regulate scrise pentru IPv4.
  • Alte scheme: file://, gopher:// sau dict://, dacă biblioteca le suportă.

Măsuri în cod:

  • rezolvi numele o singură dată și te conectezi la IP-ul validat (fixarea adresei pentru conexiune);
  • validezi după normalizare, cu biblioteci care înțeleg toate formele (ipaddress în Python, cu is_private, is_loopback, is_link_local, is_reserved);
  • dezactivezi urmarea automată a redirecționărilor sau revalidezi fiecare pas;
  • permiți doar http și https, cu timeout și limită de dimensiune.

Măsuri de arhitectură, mai importante decât codul:

  • un serviciu de descărcare izolat, într-o rețea fără rute spre resursele interne, cu egress doar spre internet;
  • politici de rețea sau security groups care blochează 169.254.169.254 și subrețelele interne pentru acel serviciu;
  • IMDSv2 în AWS, unde metadatele instanței cer un token obținut printr-o cerere PUT cu header special, ceea ce blochează majoritatea SSRF-urilor simple; plus limitarea hop limit la 1 pentru containere;
  • rolul atașat instanței cu permisiuni minime, ca un eventual acces la credențiale să aibă impact mic.

Ce urmărește intervievatorul: Se verifică dacă înțelegi de ce validarea la nivel de aplicație e fragilă și cum o completezi prin arhitectură. Greșeala tipică la nivel senior este încrederea într-o singură verificare făcută înainte de conectare.

62 Senior

Un cupon de reducere de unică folosință a fost aplicat de 30 de ori de același utilizator, prin cereri trimise simultan. Unde e bug-ul în acest cod și cum îl corectezi?

PYTHON
def aplica_cupon(user_id, cod):
    cupon = db.query("SELECT id, folosit FROM cupoane WHERE cod = %s", (cod,))
    if cupon.folosit:
        raise Eroare("cupon deja folosit")
    db.execute("UPDATE comenzi SET reducere = 50 WHERE user_id = %s AND stare = 'cos'", (user_id,))
    db.execute("UPDATE cupoane SET folosit = TRUE WHERE id = %s", (cupon.id,))

Răspuns scurt: Este o condiție de cursă: cererile paralele citesc toate folosit = FALSE înainte ca vreuna să scrie TRUE. Faci verificarea și marcarea atomice, cu UPDATE ... WHERE folosit = FALSE și verificarea rândurilor afectate, în aceeași tranzacție cu reducerea.

Logica e corectă dacă cererile vin pe rând. Problema este fereastra dintre citire și scriere. Cu 30 de cereri paralele, toate execută SELECT înainte ca prima să ajungă la UPDATE cupoane, iar fiecare aplică reducerea. Este un TOCTOU la nivel de aplicație web, iar OWASP îl încadrează la defecte de logică de business. Astfel de bug-uri apar la cupoane, transferuri, vouchere, limite de retragere și invitații.

Corectarea atomică, folosind baza de date ca arbitru:

PYTHON
def aplica_cupon(user_id, cod):
    with db.transaction():
        rand = db.execute(
            "UPDATE cupoane SET folosit = TRUE, folosit_de = %s, folosit_la = now() "
            "WHERE cod = %s AND folosit = FALSE RETURNING id",
            (user_id, cod)
        ).fetchone()
        if rand is None:
            raise Eroare("cupon invalid sau deja folosit")
        db.execute(
            "UPDATE comenzi SET reducere = 50, cupon_id = %s "
            "WHERE user_id = %s AND stare = 'cos'",
            (rand.id, user_id)
        )

Doar o singură tranzacție poate schimba rândul din FALSE în TRUE; celelalte găsesc condiția falsă și nu primesc niciun rând. RETURNING este sintaxă PostgreSQL; în alte baze verifici numărul de rânduri afectate.

Alte variante: SELECT ... FOR UPDATE pentru blocarea rândului, o constrângere UNIQUE (de exemplu pe cupon_id într-un tabel de utilizări), care face baza de date să refuze a doua inserare, sau chei de idempotență pentru cererile repetate.

Testarea: astfel de bug-uri nu apar la teste secvențiale. Se verifică trimițând cereri paralele în mediul de test, de exemplu cu un script cu asyncio sau cu funcția de trimitere în paralel din Burp Repeater.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi vulnerabilitățile de concurență în logica de business. Greșeala frecventă este rezolvarea cu o verificare suplimentară în cod, care păstrează fereastra de cursă.

Atacuri și malware

Exersează capitolul cu exerciții reale: Curs Cybersecurity online →
63 Junior

Ce este atacul de tip SSL stripping și cum îl previne HSTS?

Răspuns scurt: SSL stripping este un om-la-mijloc care interceptează prima cerere HTTP și ține victima pe HTTP, în timp ce atacatorul vorbește HTTPS cu serverul. HSTS obligă browserul să folosească doar HTTPS pentru domeniu, deci nu mai pleacă nicio cerere HTTP.

Mulți utilizatori tastează firma.ro, nu https://firma.ro. Browserul face întâi o cerere HTTP, iar serverul răspunde cu redirect spre HTTPS. Acea primă cerere este neprotejată. Un atacator poziționat pe rețea (Wi-Fi fals, ARP spoofing, router compromis) o interceptează și, în loc să transmită redirect-ul, face el conexiunea HTTPS cu serverul și îi servește victimei pagina prin HTTP. Victima nu vede eroare de certificat, pentru că nu există certificat, doar lipsește lacătul.

HSTS (HTTP Strict Transport Security) se activează cu un header trimis prin HTTPS:

Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
  • max-age: cât timp (în secunde) browserul ține minte regula;
  • includeSubDomains: regula se aplică și subdomeniilor;
  • preload: semnalează că domeniul poate fi inclus în lista HSTS integrată în browsere.

După prima vizită, browserul transformă intern orice http://firma.ro în https:// înainte să trimită ceva și refuză să continue dacă certificatul e invalid, fără opțiunea „continuă oricum”.

Limita: prima vizită rămâne vulnerabilă. Lista de preload rezolvă și asta: domeniile înscrise (prin hstspreload.org) sunt cunoscute ca HTTPS-only din fabrică în Chrome, Firefox, Safari și Edge.

Atenție înainte de includeSubDomains și preload: toate subdomeniile trebuie să funcționeze pe HTTPS, iar scoaterea din lista de preload durează mult. Se începe cu un max-age mic și se crește treptat.

Ce urmărește intervievatorul: Se verifică dacă înțelegi de ce redirect-ul HTTP spre HTTPS nu e suficient. Greșeala tipică este activarea preload fără să verifici toate subdomeniile.

Eroarea, în practică:You cannot visit ... because the website uses HSTS

64 Junior

Ce sunt domeniile look-alike (typosquatting, homografe) și ce măsuri tehnice poate lua o firmă împotriva lor?

Răspuns scurt: Sunt domenii care imită domeniul legitim: litere inversate, alt TLD, cratime sau caractere din alte alfabete identice vizual (homografe). Te aperi prin înregistrări defensive, monitorizarea domeniilor și certificatelor noi și manageri de parole legați de domeniu.

Exemple pentru firma.ro: frima.ro (litere inversate), firma-ro.com, firma.co, firma-login.ro, flrma.ro (litera „l” în loc de „i”) sau un domeniu în care „a” este litera chirilică „а”, identică vizual. Ultimele sunt domenii internaționalizate (IDN), stocate tehnic în forma punycode, care începe cu xn--.

Folosiri: pagini de phishing, emailuri care par interne, fraude de tip „schimbare de cont bancar” către clienți, distribuirea de malware sub numele firmei.

Măsuri:

  • înregistrare defensivă a variantelor cele mai probabile și a TLD-urilor relevante, redirecționate spre site-ul real;
  • monitorizarea Certificate Transparency: toate certificatele publice sunt înregistrate în jurnale publice, așa că poți primi alerte când cineva obține un certificat pentru un nume asemănător (servicii precum crt.sh sau unelte de monitorizare a brandului);
  • monitorizarea domeniilor nou înregistrate și blocarea lor temporară în proxy-ul web și în filtrul de email;
  • DMARC cu p=reject pe domeniul real; nu oprește domeniile look-alike, dar elimină varianta mai simplă de a falsifica exact domeniul tău;
  • etichete pentru emailuri externe în clientul de email;
  • managere de parole și passkeys, care nu completează credențialele pe un domeniu diferit;
  • proceduri de raportare și eliminare (takedown) prin registrar sau prin furnizorul de găzduire.

Browserele afișează în forma punycode domeniile IDN suspecte care amestecă alfabete, dar regulile nu acoperă toate cazurile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi cum se apără o organizație de phishing la nivel de infrastructură, nu doar prin instruire. Greșeala frecventă este să crezi că DMARC protejează și împotriva domeniilor similare.

65 Junior

Ce este un infostealer și de ce furtul cookie-urilor de sesiune poate ocoli MFA?

Răspuns scurt: Un infostealer este malware care fură rapid parole salvate, cookie-uri, tokenuri și fișiere și le trimite atacatorului. Un cookie de sesiune furat reprezintă o sesiune deja autentificată, inclusiv cu MFA, deci poate fi folosit fără parolă și fără al doilea factor.

Infostealerele ajung de obicei pe calculatoare prin programe piratate, extensii sau actualizări false, reclame malițioase și atașamente. Rulează câteva secunde sau minute, colectează și trimit datele, uneori fără să rămână persistente. Datele sunt apoi vândute pe piețe dedicate și folosite pentru acces inițial în firme.

Ce colectează: parolele salvate în browser, cookie-urile, istoricul, datele de completare automată, tokenurile aplicațiilor (Slack, Discord, Teams), fișiere de configurare VPN și cloud, chei SSH.

De ce MFA nu ajută în acest scenariu: MFA se verifică la autentificare. După aceea, serverul emite un cookie de sesiune și consideră autentificat pe oricine îl prezintă. Atacatorul importă cookie-ul în propriul browser și preia sesiunea, numită de obicei session hijacking sau „pass-the-cookie”.

Măsuri:

  • durate scurte pentru sesiuni la aplicațiile sensibile și reautentificare la operații critice;
  • legarea sesiunii de dispozitiv: politici de acces condiționat care cer dispozitive gestionate și conforme; tehnologii emergente precum Device Bound Session Credentials în Chrome, care leagă cookie-ul de o cheie din TPM-ul dispozitivului;
  • detecție de anomalii: aceeași sesiune folosită din altă țară sau de pe alt user-agent;
  • revocarea tuturor sesiunilor când un dispozitiv este suspectat de infectare, nu doar resetarea parolei;
  • interzicerea salvării parolelor de firmă în browserele personale și a profilurilor personale sincronizate pe dispozitivele de firmă;
  • EDR pe stații și restricții la instalarea de software.

Ce urmărește intervievatorul: Se verifică dacă înțelegi limitele MFA și cum arată o amenințare foarte frecventă azi. Greșeala tipică este răspunsul la incident doar cu schimbarea parolei.

66 Junior

Ce este cryptojacking-ul și ce semne te pot face să-l suspectezi pe un server sau într-un cont de cloud?

Răspuns scurt: Cryptojacking este folosirea neautorizată a resurselor tale pentru minarea de criptomonede. Semne: CPU sau GPU constant la maxim, procese necunoscute, conexiuni spre pool-uri de minare și, în cloud, instanțe noi în regiuni nefolosite și o factură care crește brusc.

Atacatorii aleg cryptojacking-ul pentru că transformă direct accesul în bani, fără să negocieze cu victima. Căile de intrare tipice: servicii expuse cu vulnerabilități cunoscute, interfețe de administrare fără autentificare (Docker API, Kubernetes dashboard, Redis), parole slabe pe SSH, imagini de container compromise și chei de cloud scăpate în repository-uri publice.

Semne pe un server:

  • utilizare constantă a procesorului apropiată de 100%, fără o creștere de trafic care să o explice;
  • procese cu nume care imită procese de sistem sau rulează din /tmp, /dev/shm;
  • joburi cron sau servicii systemd noi, chei SSH adăugate în authorized_keys;
  • conexiuni de ieșire persistente spre porturi neobișnuite sau domenii de tip pool de minare;
  • protecții dezactivate (agentul de monitorizare oprit, reguli de firewall șterse).

Semne în cloud:

  • instanțe noi, adesea de tip GPU, în regiuni pe care firma nu le folosește;
  • creșteri bruște ale costurilor, de aceea alertele de buget sunt și un control de securitate;
  • acțiuni în jurnalul de audit al contului (de exemplu CloudTrail) făcute de chei sau roluri neobișnuite.

Răspunsul: izolezi resursa, păstrezi dovezile, identifici calea de intrare (altfel atacatorul revine), revoci cheile compromise și reconstruiești sistemul dintr-o imagine curată, în loc să ștergi doar procesul. Cryptojacking-ul este adesea doar primul semn vizibil al unui acces care poate fi folosit și pentru altceva.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști un incident frecvent după efectele lui. Greșeala tipică este oprirea procesului și considerarea incidentului închis.

67 Mid

Ce sunt atacurile de tip watering hole, drive-by download și malvertising și cum te aperi de ele?

Răspuns scurt: Watering hole compromite un site vizitat des de ținte. Drive-by download infectează la simpla vizitare a unei pagini. Malvertising livrează conținut malițios prin reclame. Te aperi cu browsere actualizate, filtrare web, utilizatori fără drepturi de admin și restricții de instalare.

Toate trei mută atacul din email spre web, unde utilizatorul nu se așteaptă la pericol.

Watering hole: în loc să atace direct o firmă bine protejată, atacatorul compromite un site pe care angajații ei îl vizitează des: un forum de specialitate, site-ul unei asociații profesionale, un portal de furnizor. Uneori codul malițios se activează doar pentru vizitatorii din plaja de IP-uri a țintei, ca să nu fie descoperit.

Drive-by download: pagina exploatează o vulnerabilitate în browser sau într-o componentă a lui și rulează cod fără interacțiunea utilizatorului. Mai rar azi, datorită actualizărilor automate și sandbox-ului browserelor moderne, dar încă folosit cu vulnerabilități zero-day. Varianta frecventă acum este înșelătoria: pagina cere „actualizarea browserului” sau rularea unei comenzi copiate în fereastra Run sau în terminal pentru a „rezolva o eroare”.

Malvertising: reclame care redirecționează spre pagini malițioase. Un caz frecvent sunt reclamele plătite în motoarele de căutare pentru programe populare, care duc la installere false.

Apărări:

  • browsere și sisteme actualizate rapid, cu actualizări automate;
  • filtrare web și DNS: blocarea domeniilor nou înregistrate și a categoriilor riscante, blocarea reclamelor la nivel de firmă;
  • utilizatori fără drepturi de administrator, AppLocker sau WDAC (Windows Defender Application Control) și liste de aplicații permise;
  • software instalat doar dintr-un portal intern sau din surse oficiale;
  • EDR care detectează procese copil neobișnuite ale browserului;
  • izolarea navigării pentru utilizatorii cu risc mare.

Ce urmărește intervievatorul: Se verifică dacă știi vectori de infectare dincolo de email. Greșeala frecventă este să crezi că un antivirus singur rezolvă problema.

68 Mid

Ce sunt dependency confusion și typosquatting-ul în registrele de pachete și cum îți protejezi pipeline-ul de build?

Răspuns scurt: Typosquatting publică pachete cu nume apropiate de cele populare. Dependency confusion publică în registrul public un pachet cu numele unuia intern, pe care managerul de pachete îl preferă. Te protejezi cu registru intern unic, namespace-uri rezervate și lockfile-uri cu hash-uri.

Atacurile pe lanțul de aprovizionare software vizează codul pe care nu l-ai scris tu, dar pe care îl rulezi.

Typosquatting: pachete ca reqeusts în loc de requests sau cross-env.js în loc de cross-env. Conțin codul original plus un script care rulează la instalare (de exemplu postinstall în npm sau setup.py în Python) și fură variabile de mediu, tokenuri și chei.

Dependency confusion: firma are intern pachetul firma-utils. Atacatorul publică pe npm sau PyPI un pachet firma-utils cu versiune mai mare. Dacă managerul de pachete caută în ambele registre și preferă versiunea cea mai mare, instalează pachetul atacatorului, chiar pe serverele de build. Atacul a fost demonstrat public în 2021 pe sisteme ale unor firme mari.

Protecții:

  • un singur registru (proxy intern precum Artifactory sau Nexus) prin care trec toate pachetele, configurat ca pachetele interne să nu poată fi înlocuite de cele publice;
  • namespace-uri rezervate: scope-uri npm (@firma/utils), revendicarea numelor interne și în registrele publice;
  • lockfile-uri (package-lock.json, poetry.lock) cu hash-uri de integritate, și instalare strictă în CI (npm ci, pip install --require-hashes);
  • dezactivarea scripturilor de instalare unde se poate (npm ci --ignore-scripts);
  • revizuirea fiecărei dependențe noi (popularitate, întreținere, cine o publică);
  • build-uri în medii izolate, cu secrete minime și egress restricționat;
  • SBOM (Software Bill of Materials, lista componentelor) pentru a ști rapid unde e folosit un pachet compromis.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi riscurile din lanțul de build, o zonă tot mai vizată. Greșeala frecventă este să crezi că scanarea CVE-urilor acoperă și pachetele malițioase noi, care nu au CVE.

69 Mid

Ce înseamnă „living off the land” și malware fileless și de ce sunt greu de detectat cu un antivirus clasic?

Răspuns scurt: Living off the land înseamnă folosirea uneltelor legitime ale sistemului (PowerShell, WMI, certutil, rundll32) în locul propriilor executabile; fileless înseamnă execuție în memorie, fără fișiere pe disc. Antivirusul pe semnături nu are ce scana, iar uneltele sunt semnate.

Unelte de sistem folosite des abuziv pe Windows (numite LOLBins, living-off-the-land binaries; proiectul LOLBAS le catalogează): powershell.exe, wmic.exe, mshta.exe, rundll32.exe, regsvr32.exe, certutil.exe (poate descărca fișiere), bitsadmin.exe, programarea de sarcini cu schtasks.exe. Pe Linux, echivalentul este catalogat de proiectul GTFOBins: curl, bash, python, cron.

De ce sunt greu de detectat:

  • executabilele sunt legitime și semnate, deci nu pot fi blocate fără să afectezi administratorii;
  • codul poate rula direct în memorie, de exemplu un script descărcat și executat fără să fie salvat;
  • persistența se poate face prin mecanisme ale sistemului: sarcini programate, chei Run din registru, abonamente WMI;
  • activitatea seamănă cu munca unui administrator.

Ce funcționează în apărare:

  • detecție comportamentală prin EDR: relații părinte-copil neobișnuite (Word care lansează PowerShell), linii de comandă suspecte, conexiuni de rețea ale unor procese care de obicei nu comunică;
  • jurnalizarea PowerShell (Script Block Logging, care înregistrează scripturile după decodare) și integrarea AMSI, interfața prin care Windows trimite scripturile la scanare înainte de execuție;
  • Sysmon pentru crearea de procese cu linia de comandă completă (eveniment ID 1) și pentru conexiuni de rețea;
  • reducerea suprafeței: reguli ASR din Microsoft Defender (de exemplu blocarea proceselor copil create de aplicațiile Office), AppLocker sau WDAC, care pot restricționa unelte nefolosite de utilizatori obișnuiți;
  • PowerShell Constrained Language Mode pentru utilizatorii care nu au nevoie de el complet.

Ce urmărește intervievatorul: Se verifică dacă înțelegi de ce detecția modernă e comportamentală. Greșeala tipică este să propui blocarea completă a PowerShell-ului fără să ții cont de administrarea legitimă.

70 Senior

Cum ai aborda riscul de insider threat într-o firmă, fără să creezi o cultură a suspiciunii?

Răspuns scurt: Pornești de la datele critice, aplici privilegiu minim, separarea sarcinilor și un ciclu corect de onboarding și offboarding, monitorizezi transparent și legal accesul sensibil și lucrezi cu HR și juridicul. Multe incidente sunt neglijențe, nu rea-voință.

Insider threat include trei categorii: angajatul neglijent (trimite un fișier greșit, folosește un serviciu cloud personal), angajatul ale cărui credențiale au fost compromise și, mai rar, angajatul rău-intenționat (furt de date înainte de plecare, sabotaj). Programul trebuie să le acopere pe toate fără să trateze oamenii ca suspecți.

Elemente:

  • Identificarea a ce contează: date de clienți, cod sursă, proprietate intelectuală, acces la plăți. Controalele cele mai stricte se aplică acolo.
  • Prevenție prin design: privilegiu minim, separarea sarcinilor pentru operațiuni financiare și de producție, aprobări în doi pași, acces temporar (just-in-time) pentru drepturi administrative.
  • Ciclul de viață al accesului: revizuiri periodice și revocarea imediată la plecare sau la schimbarea rolului. Conturile rămase active după plecare sunt o cauză frecventă de incidente.
  • Monitorizare proporțională: DLP pe canale de exfiltrare, alerte la descărcări masive, acces neobișnuit la depozitele de cod, folosirea mediilor USB. Cu indicatori comportamentali, nu cu citirea conținutului personal.
  • Cadru legal și transparență: politici comunicate angajaților, informarea despre monitorizare conform GDPR și Codului muncii, evaluare de impact asupra protecției datelor unde e cazul, implicarea juridicului și a HR-ului în fiecare investigație.
  • Cultură: un canal sigur de raportare, instruire practică, proceduri clare care fac calea corectă și cea mai ușoară.

O plecare tensionată dintr-o echipă cu acces privilegiat justifică o revizuire atentă a accesului, făcută în coordonare cu HR, nu supravegherea discretă a unei persoane.

Ce urmărește intervievatorul: Intervievatorul verifică echilibrul între securitate, legalitate și cultura organizațională. Greșeala frecventă la nivel senior este propunerea unei monitorizări extinse fără bază legală sau fără implicarea HR.

Hardening Windows și Linux

71 Junior

Ce înseamnă hardening pentru un server și de unde pornești concret?

Răspuns scurt: Hardening înseamnă reducerea suprafeței de atac și configurarea sigură a unui sistem: elimini ce nu e necesar, aplici actualizările, restrângi accesul și activezi jurnalizarea. Pornești de la un ghid recunoscut, de exemplu CIS Benchmarks sau ghidurile DISA STIG, adaptat rolului serverului.

Instalarea implicită a unui sistem de operare este gândită să funcționeze pentru cât mai multe scenarii, nu să fie sigură pentru scenariul tău. Hardening-ul o adaptează.

Pași tipici:

  • Inventar și rol: ce face serverul și ce trebuie să fie accesibil. Totul pornește de aici.
  • Minimizare: dezinstalezi pachetele și dezactivezi serviciile care nu țin de rol; nu lași compilatoare și unelte de rețea pe un server de producție fără motiv.
  • Actualizări: sistemul la zi, cu proces de actualizare automată sau programată.
  • Conturi și autentificare: fără conturi implicite, autentificare SSH cu chei, MFA pentru administrare, parole locale unice, sudo cu reguli precise.
  • Rețea: firewall local cu politică implicită de blocare, servicii legate doar de interfețele necesare.
  • Sistemul de fișiere: partiții separate pentru /tmp și /var cu opțiuni precum noexec și nosuid, permisiuni corecte pe fișierele sensibile.
  • Jurnalizare și audit: loguri trimise centralizat, sincronizare de timp (NTP), audit pentru acțiunile privilegiate.
  • Parametri de kernel: de exemplu dezactivarea rutării IP dacă serverul nu e router, protecții de rețea prin sysctl.

CIS Benchmarks sunt ghiduri gratuite, detaliate, pentru sisteme de operare, baze de date, servere web și servicii cloud, cu niveluri de strictețe (Level 1, Level 2). Unelte precum OpenSCAP, Lynis sau CIS-CAT verifică automat conformitatea.

Important: aplici modificările întâi pe un mediu de test și automatizezi configurarea (Ansible, imagini de bază), ca toate serverele să fie identice și verificabile.

Ce urmărește intervievatorul: Se verifică dacă ai o abordare structurată și cunoști standardele uzuale. Greșeala tipică este o listă de măsuri disparate, fără referință la un ghid și fără automatizare.

72 Junior

Cum afli ce servicii rulează și ce porturi ascultă pe un server Linux și cum dezactivezi un serviciu inutil astfel încât să nu pornească din nou la restart?

Răspuns scurt: Listezi serviciile active cu systemctl list-units --type=service --state=running și porturile cu ss -tulpn. Oprești serviciul cu systemctl disable --now nume, iar dacă nu trebuie să pornească nici ca dependență, îl blochezi cu systemctl mask sau, mai bine, dezinstalezi pachetul.

Pas cu pas:

BASH
# servicii care rulează acum
systemctl list-units --type=service --state=running

# servicii care pornesc la boot
systemctl list-unit-files --type=service --state=enabled

# porturi TCP/UDP care ascultă și procesul asociat
sudo ss -tulpn

În ieșirea ss, uită-te la adresa locală: 127.0.0.1:5432 înseamnă că serviciul e accesibil doar local, 0.0.0.0:5432 sau *:5432 înseamnă pe toate interfețele, deci posibil din rețea.

Să presupunem că găsești cups (serviciul de imprimare) pe un server web:

BASH
sudo systemctl disable --now cups.service cups.socket
sudo systemctl mask cups.service
  • disable elimină pornirea automată la boot;
  • --now îl și oprește imediat;
  • multe servicii au și unități socket care le pornesc la prima conexiune, de aceea le dezactivezi și pe acelea;
  • mask leagă unitatea de /dev/null, ca să nu poată fi pornită nici manual, nici ca dependență a altui serviciu.

Cea mai curată variantă este dezinstalarea:

BASH
sudo apt purge cups      # Debian/Ubuntu
sudo dnf remove cups     # RHEL/Fedora

Înainte de a opri ceva, verifici cu systemctl list-dependencies --reverse nume.service dacă alt serviciu depinde de el. După modificări, verifici din nou cu ss -tulpn și, ideal, cu o scanare din exterior, pentru că ce vezi local trebuie să corespundă cu ce e expus efectiv prin firewall.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți face efectiv reducerea suprafeței de atac pe un sistem real. Greșeala frecventă este oprirea serviciului fără dezactivare, astfel încât revine după restart.

Eroarea, în practică:ssh: Connection refusedcurl: (7) Couldn't connect to server

73 Junior

Cum organizezi actualizările de securitate pe servere Linux și pe stații Windows ca să nu rămână sisteme neactualizate?

Răspuns scurt: Pe Linux activezi actualizările automate de securitate (unattended-upgrades, dnf-automatic) și planifici restarturile. Pe Windows le gestionezi centralizat (Intune, WSUS, Windows Update for Business), cu inele de implementare. Raportezi centralizat sistemele rămase în urmă.

Cele mai multe compromiteri nu folosesc vulnerabilități necunoscute, ci unele pentru care există patch de luni de zile. Problema nu este lipsa actualizărilor, ci lipsa unui proces care le aplică peste tot.

Linux:

BASH
# Debian / Ubuntu
sudo apt install unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades
# configurare în /etc/apt/apt.conf.d/50unattended-upgrades

# RHEL / Fedora
sudo dnf install dnf-automatic
# în /etc/dnf/automatic.conf: upgrade_type = security, apply_updates = yes
sudo systemctl enable --now dnf-automatic.timer

Actualizările de kernel și ale bibliotecilor de bază (de exemplu glibc, OpenSSL) au efect abia după restart sau după repornirea proceselor care le folosesc. Verifici cu existența fișierului /var/run/reboot-required pe Ubuntu sau cu needs-restarting -r pe RHEL și planifici ferestre de restart. Pentru unele servere critice există livepatching de kernel.

Windows:

  • politici centralizate (Intune, Group Policy, WSUS, Configuration Manager);
  • inele: un grup pilot primește actualizările imediat, apoi grupuri mai mari după câteva zile, ca o actualizare problematică să fie oprită devreme;
  • termene limită după care restartul se face forțat.

Pentru ambele:

  • un raport central cu sistemele care nu au primit actualizări într-un interval definit;
  • actualizarea și a aplicațiilor terțe (browsere, Java, Adobe, aplicații de birou), nu doar a sistemului de operare;
  • un proces de excepție documentat pentru sistemele care nu pot fi actualizate.

Ce urmărește intervievatorul: Se verifică dacă știi că patching-ul este un proces, nu o acțiune ocazională. Greșeala tipică este uitarea restartului după actualizările de kernel și a aplicațiilor terțe.

74 Junior

De ce administratorii Windows ar trebui să folosească un cont separat pentru administrare și ce este Windows LAPS?

Răspuns scurt: Contul separat face ca emailul și navigarea să ruleze fără drepturi de administrator, deci un cont zilnic compromis nu dă direct acces administrativ. Windows LAPS setează automat o parolă unică și rotită periodic pentru administratorul local al fiecărui calculator.

Dacă un administrator își citește emailul și navighează pe internet cu un cont care are drepturi de admin, un singur atașament deschis rulează cu acele drepturi. Separarea conturilor transformă un incident pe o stație obișnuită într-un incident limitat.

Bune practici:

  • cont zilnic fără drepturi administrative; cont adm-nume pentru administrare, fără email și fără navigare pe internet;
  • conturile de administrare se folosesc doar de pe stații dedicate și securizate (PAW, Privileged Access Workstation) pentru sarcinile cele mai sensibile;
  • UAC (User Account Control) rămâne activat: chiar și un administrator rulează implicit cu drepturi standard până confirmă ridicarea;
  • modelul pe niveluri (tiering): conturile care administrează controlerele de domeniu nu se folosesc pe stații de lucru obișnuite.

Problema contului de administrator local: în multe firme, toate calculatoarele au același administrator local cu aceeași parolă, setată din imaginea de instalare. Dacă un atacator obține hash-ul acelei parole de pe un calculator, se poate autentifica pe toate celelalte (tehnica pass-the-hash), deci se mișcă lateral foarte ușor.

Windows LAPS (Local Administrator Password Solution), integrat în Windows din aprilie 2023 pentru versiunile suportate, rezolvă:

  • generează o parolă aleatoare, unică pentru fiecare calculator;
  • o rotește periodic și după folosire;
  • o stochează în Active Directory sau Microsoft Entra ID, cu acces controlat și auditat;
  • în AD poate cripta parola stocată.

Administratorul care are nevoie de acces citește parola pentru acel calculator, iar accesul rămâne înregistrat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi măsurile care opresc mișcarea laterală în rețele Windows. Greșeala frecventă este folosirea aceluiași cont pentru muncă zilnică și administrare.

75 Junior

Cum configurezi fail2ban pentru a proteja SSH-ul și ce limitări are această măsură?

Răspuns scurt: Fail2ban citește logurile de autentificare și, după prea multe eșecuri dintr-un IP într-un interval, îl blochează temporar prin firewall. Reduce zgomotul și ghicirea din puține surse, dar nu oprește atacurile distribuite și nu înlocuiește autentificarea cu chei.

Configurarea se face într-un fișier local, ca să nu fie suprascrisă la actualizări:

# /etc/fail2ban/jail.local
[DEFAULT]
bantime  = 1h
findtime = 10m
maxretry = 5
ignoreip = 127.0.0.1/8 192.0.2.0/28
banaction = nftables-multiport

[sshd]
enabled = true
backend = systemd
  • maxretry eșecuri într-un interval findtime duc la blocare pentru bantime;
  • ignoreip exclude adresele proprii de administrare, ca să nu te blochezi;
  • backend = systemd citește din jurnalul systemd, util pe distribuțiile care nu mai scriu auth.log.

Verificare:

BASH
sudo systemctl enable --now fail2ban
sudo fail2ban-client status sshd
sudo fail2ban-client set sshd unbanip 203.0.113.7

Opțiunea bantime.increment = true crește durata blocării pentru IP-urile recidiviste.

Limitări:

  • atacurile distribuite pe mii de IP-uri, cu puține încercări fiecare, trec de prag;
  • nu ajută dacă parola e slabă și e ghicită din primele încercări;
  • IP-urile partajate (NAT de operator, VPN de firmă) pot bloca utilizatori legitimi;
  • dacă logurile nu sunt citite corect (format schimbat, backend greșit), nu face nimic, fără să te avertizeze.

De aceea fail2ban este un strat suplimentar. Protecția de bază rămâne PasswordAuthentication no, autentificarea cu chei, eventual MFA, și restricționarea portului 22 la rețelele de administrare sau ascunderea lui în spatele unui VPN ori bastion.

Ce urmărește intervievatorul: Se verifică dacă poți configura concret o unealtă de apărare și dacă îi înțelegi limitele. Greșeala tipică este să consideri fail2ban suficient pentru un SSH cu autentificare prin parolă.

Eroarea, în practică:Failed password for invalid userFailed password for root

76 Junior

Ce face umask pe Linux și ce permisiuni primește un fișier nou creat cu umask 027?

Răspuns scurt: umask este masca de biți care elimină permisiuni din cele implicite la crearea fișierelor și directoarelor. Cu 027, un fișier nou (implicit 666) primește 640, adică rw-r-----, iar un director nou (implicit 777) primește 750, adică rwxr-x---.

Programele creează fișiere cerând de obicei permisiunile 666 (citire și scriere pentru toți) și directoare cu 777. Kernelul elimină apoi biții prezenți în umask. Nu este o scădere aritmetică, ci o operație pe biți: permisiunile finale sunt cerute AND NOT umask.

Cu umask 027:

  • primul 0: proprietarul nu pierde nimic;
  • 2: grupul pierde scrierea;
  • 7: ceilalți pierd tot.

Rezultat: fișierele noi sunt 640, directoarele 750.

BASH
umask            # afișează masca curentă, de exemplu 0022
umask 027
touch raport.txt && mkdir arhiva
ls -ld raport.txt arhiva
# -rw-r----- ... raport.txt
# drwxr-x--- ... arhiva

De ce contează în securitate: masca implicită uzuală, 022, face fișierele noi lizibile pentru toți utilizatorii sistemului (644). Pe un server multi-utilizator sau pe unul unde rulează mai multe aplicații cu utilizatori diferiți, loguri, exporturi sau fișiere de configurare cu parole pot deveni citibile de alte procese. Un umask mai strict pentru serviciile care manipulează date sensibile reduce riscul.

Unde se setează:

  • pentru un serviciu systemd, directiva UMask=0027 în fișierul unității;
  • pentru utilizatori, în /etc/login.defs sau în profilul shell-ului;
  • în cod, explicit la creare, de exemplu os.open(cale, os.O_CREAT | os.O_WRONLY, 0o600).

umask nu schimbă permisiunile fișierelor existente; pentru acelea folosești chmod și o verificare periodică, de exemplu cu find / -xdev -type f -perm -0002 pentru fișierele modificabile de oricine.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi cum apar permisiunile prea largi fără ca cineva să le seteze explicit. Greșeala tipică este calculul prin scădere și confuzia cu chmod.

77 Junior

Ce măsuri de bază de hardening aplici pe o stație de lucru Windows 11 dintr-o firmă?

Răspuns scurt: BitLocker, Microsoft Defender cu Tamper Protection, firewall activ pe toate profilurile, utilizatori fără drepturi de administrator, actualizări automate, SMBv1 dezactivat, reguli ASR, Secure Boot, totul impus central prin Intune sau Group Policy.

Măsuri, grupate pe scop:

Protecția datelor:

  • BitLocker cu TPM pentru tot discul, cu cheia de recuperare salvată centralizat în Entra ID sau AD; protejează datele dacă laptopul e pierdut sau furat;
  • Secure Boot activat, ca sistemul să pornească doar componente semnate.

Protecție împotriva malware-ului:

  • Microsoft Defender Antivirus (sau o soluție EDR) cu protecție în timp real, protecție din cloud și Tamper Protection, care împiedică dezactivarea lui de către un proces malițios;
  • reguli ASR (Attack Surface Reduction): de exemplu blocarea proceselor copil create de aplicațiile Office și blocarea furtului de credențiale din procesul LSASS;
  • macro-urile Office blocate pentru fișierele descărcate de pe internet (comportament implicit în versiunile actuale de Microsoft 365);
  • SmartScreen activat.

Credențiale și conturi:

  • utilizatorii lucrează fără drepturi de administrator local;
  • Windows LAPS pentru contul de administrator local;
  • Credential Guard, activat implicit pe sistemele compatibile începând cu Windows 11 22H2, care izolează secretele de autentificare.

Rețea:

  • firewall-ul Windows activ pe profilurile Domain, Private, Public;
  • SMBv1 dezactivat (protocol vechi, exploatat de WannaCry), semnarea SMB cerută;
  • LLMNR și NetBIOS dezactivate unde nu sunt necesare, pentru că pot fi abuzate pentru capturarea hash-urilor de autentificare.

Administrare:

  • actualizări automate cu termene limită;
  • configurare impusă central, verificată periodic față de o linie de bază (Microsoft Security Baselines sau CIS Benchmark).

Ce urmărește intervievatorul: Se verifică dacă poți enumera structurat controalele de bază pe sistemul cel mai frecvent din firme. Greșeala tipică este să te oprești la „antivirus și firewall”.

78 Mid

Scrie câteva reguli auditd care înregistrează modificările fișierelor de autentificare și folosirea sudo, apoi arată cum cauți evenimentele.

Răspuns scurt: Adaugi reguli de tip watch (-w) pe fișiere precum /etc/passwd, /etc/shadow, /etc/sudoers și pe executabilul sudo, fiecare cu o cheie (-k), într-un fișier din /etc/audit/rules.d/. Încarci regulile cu augenrules --load și cauți cu ausearch -k cheie sau rezumi cu aureport.

auditd este sistemul de audit al kernelului Linux. Spre deosebire de logurile aplicațiilor, înregistrează la nivel de apel de sistem cine (inclusiv utilizatorul original, înainte de sudo, prin câmpul auid) a făcut ce.

# /etc/audit/rules.d/50-identitate.rules
-w /etc/passwd   -p wa -k identitate
-w /etc/shadow   -p wa -k identitate
-w /etc/group    -p wa -k identitate
-w /etc/sudoers  -p wa -k sudoers
-w /etc/sudoers.d/ -p wa -k sudoers
-w /etc/ssh/sshd_config -p wa -k ssh_config
-w /usr/bin/sudo -p x -k privilegii
-a always,exit -F arch=b64 -S execve -F euid=0 -F auid>=1000 -F auid!=unset -k comenzi_root
  • -w urmărește o cale; -p alege operațiile: r citire, w scriere, x execuție, a schimbare de atribute;
  • -k adaugă o cheie, folosită la căutare;
  • ultima regulă înregistrează toate comenzile rulate ca root de utilizatori umani autentificați (cu auid de cel puțin 1000), adică acțiunile după sudo.

Încărcare și verificare:

BASH
sudo augenrules --load
sudo auditctl -l

Căutare:

BASH
sudo ausearch -k identitate --start today -i
sudo ausearch -k comenzi_root -ua 1001 -i
sudo aureport --auth --summary

Opțiunea -i traduce ID-urile numerice în nume de utilizatori și apeluri de sistem.

Practic: regulile execve pot genera volum mare, deci le testezi pe un server de test. Logurile se trimit către un sistem central (SIEM), pentru că un atacator cu root le poate șterge local; regula finală -e 2 face configurația imuabilă până la restart.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să construiești trasabilitate pentru acțiunile privilegiate. Greșeala frecventă este lăsarea logurilor de audit doar local.

Eroarea, în practică:auth.log: user NOT in sudoers

79 Mid

Ce sunt SELinux și AppArmor și ce faci când o aplicație nu pornește din cauza lor?

Răspuns scurt: Sunt sisteme de control obligatoriu al accesului (MAC) care limitează ce poate face un proces, peste permisiunile Unix. Când blochează o aplicație, citești refuzurile din logul de audit și ajustezi etichetele sau politica, fără să dezactivezi sistemul.

Permisiunile Unix clasice sunt discreționare (DAC): proprietarul fișierului decide cine îl accesează, iar root poate orice. MAC adaugă un strat impus de politica sistemului: chiar dacă procesul nginx este compromis, politica îi permite să citească doar conținutul web și să asculte pe porturile web, nu să citească directoarele utilizatorilor sau să deschidă conexiuni arbitrare.

SELinux (implicit pe RHEL, Fedora, Rocky): etichetează fiecare proces și fișier cu un context (de exemplu httpd_t, httpd_sys_content_t), iar politica spune ce tipuri pot interacționa.

AppArmor (implicit pe Ubuntu, Debian, SUSE): profiluri pe bază de căi de fișiere pentru fiecare program, mai simple de citit.

Depanare SELinux:

BASH
getenforce                                  # Enforcing / Permissive / Disabled
sudo ausearch -m AVC -ts recent             # refuzurile recente
sudo sealert -a /var/log/audit/audit.log    # explicații, dacă e instalat setroubleshoot

Cauze frecvente și soluții corecte:

  • fișiere mutate cu mv își păstrează eticheta veche; reaplici etichetele cu restorecon -Rv /var/www/site;
  • aplicația ascultă pe un port nestandard: semanage port -a -t http_port_t -p tcp 8081;
  • comportament legitim, dar dezactivat implicit: un boolean, de exemplu setsebool -P httpd_can_network_connect on.

Pentru AppArmor: refuzurile apar în journalctl sau dmesg cu „apparmor=DENIED”; poți trece temporar profilul în mod de învățare cu aa-complain, apoi îl ajustezi.

setenforce 0 sau dezactivarea completă rezolvă simptomul, dar elimină un strat important de protecție. Modul Permissive e acceptabil temporar, pentru diagnoză.

Ce urmărește intervievatorul: Se verifică dacă știi să lucrezi cu un control de securitate în loc să-l dezactivezi. Greșeala tipică este prima instrucțiune din multe tutoriale: „dezactivează SELinux”.

80 Senior

Un coleg spune că PowerShell e securizat în firmă pentru că politica de execuție este Restricted. De ce nu e corect și ce măsuri reale ai propune?

Răspuns scurt: Execution Policy previne doar rularea accidentală a scripturilor și se ocolește ușor, deci nu e o barieră de securitate. Măsurile reale: Script Block Logging, AMSI, Constrained Language Mode impus prin WDAC sau AppLocker, eliminarea PowerShell 2.0 și JEA.

Microsoft descrie explicit politica de execuție ca o funcție de siguranță, nu de securitate. Ea împiedică un utilizator să ruleze din greșeală un fișier .ps1, dar oricine poate rula powershell -ExecutionPolicy Bypass sau poate trimite cod prin -Command, fără niciun fișier. Atacatorii folosesc PowerShell exact în aceste moduri.

Măsuri reale:

  • Script Block Logging (evenimentul 4104 în jurnalul Microsoft-Windows-PowerShell/Operational): înregistrează codul executat după decodare, deci și scripturile ascunse prin encodare Base64;
  • Module Logging și transcripția sesiunilor, trimise în SIEM;
  • AMSI (Antimalware Scan Interface): PowerShell trimite scripturile la scanare înainte de execuție; funcționează doar cu un antivirus compatibil activ;
  • eliminarea PowerShell 2.0, care nu are aceste protecții și poate fi folosit pentru a le ocoli (în versiunile recente de Windows 11 componenta a fost deja eliminată);
  • Constrained Language Mode, impus de WDAC sau AppLocker, nu prin variabile de mediu: limitează accesul la .NET și API-uri Windows pentru utilizatorii obișnuiți, în timp ce scripturile semnate și aprobate rulează complet;
  • JEA (Just Enough Administration): endpoint-uri PowerShell la distanță care permit unui operator să ruleze doar comenzile necesare rolului, cu un cont virtual temporar, iar toate sesiunile sunt jurnalizate;
  • semnarea scripturilor interne și politica AllSigned ca mecanism de igienă, nu ca singură protecție;
  • reguli de detecție pentru PowerShell lansat de aplicații Office sau de browser.

Blocarea completă a PowerShell-ului afectează administrarea și nu oprește un atacator care poate încărca motorul PowerShell din alt proces.

Ce urmărește intervievatorul: Intervievatorul verifică dacă distingi controalele aparente de cele reale și dacă poți propune o arhitectură echilibrată. Greșeala frecventă este confuzia dintre politica de execuție și o barieră de securitate.

Vulnerabilități, backup și continuitate

81 Junior

Citește vectorul CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H. Ce spune despre vulnerabilitate și de ce scorul de bază nu e suficient pentru prioritizare?

Răspuns scurt: Exploatabilă prin rețea, fără condiții speciale, fără autentificare și fără interacțiunea utilizatorului, cu impact mare asupra confidențialității, integrității și disponibilității: scor de bază 9.8. Scorul nu ține cont de expunerea ta reală și de exploatarea activă.

Metricile de bază CVSS 3.1:

  • AV (Attack Vector): N rețea, A rețea adiacentă, L local, P fizic;
  • AC (Attack Complexity): L scăzută, H ridicată (condiții de cursă, configurație specială);
  • PR (Privileges Required): N niciuna, L utilizator obișnuit, H administrator;
  • UI (User Interaction): N niciuna, R necesară (de exemplu un click);
  • S (Scope): U neschimbat, C schimbat, adică impactul trece dincolo de componenta vulnerabilă (de exemplu evadare din sandbox);
  • C, I, A: impact asupra confidențialității, integrității, disponibilității, fiecare N, L sau H.

Vectorul din întrebare descrie cel mai rău caz practic: oricine de pe internet, fără cont, compromite complet componenta. Scorul de bază rezultat este 9.8.

De ce nu e suficient:

  • scorul de bază descrie vulnerabilitatea în general, nu situația ta. Un serviciu vulnerabil accesibil doar dintr-o rețea izolată are alt risc decât unul expus pe internet;
  • nu spune dacă vulnerabilitatea este exploatată activ. Pentru asta există lista CISA KEV (Known Exploited Vulnerabilities) și scorul EPSS (probabilitatea estimată de exploatare);
  • nu ține cont de importanța sistemului pentru business.

CVSS include și metrici temporale și de mediu (în versiunea 4.0, publicată în 2023, grupuri Threat și Environmental), care permit ajustarea, dar puține organizații le completează. În practică, prioritizarea combină scorul cu expunerea, criticitatea activului și semnalele de exploatare.

Ce urmărește intervievatorul: Se verifică dacă știi să citești vectorul, nu doar scorul afișat. Greșeala tipică este prioritizarea exclusiv după scorul de bază.

82 Junior

Ce înseamnă regula de backup 3-2-1 și varianta ei extinsă 3-2-1-1-0?

Răspuns scurt: 3-2-1: cel puțin trei copii ale datelor, pe două tipuri diferite de suport, dintre care una în altă locație. Varianta extinsă adaugă o copie offline sau imuabilă (care nu poate fi modificată sau ștearsă) și zero erori la verificarea restaurării.

Regula răspunde la întrebarea „ce se poate strica simultan?”.

  • 3 copii: datele de producție plus două backupuri. O singură copie de rezervă poate fi coruptă exact când ai nevoie de ea.
  • 2 tipuri de suport sau sisteme diferite: de exemplu un disc local și stocare în cloud. O defecțiune sau o eroare de configurare care afectează un tip de stocare nu le afectează pe amândouă.
  • 1 copie în altă locație: incendiu, inundație sau furt în sediu nu distrug toate copiile.

Extensia 3-2-1-1-0 a apărut din cauza ransomware-ului:

  • 1 copie offline sau imuabilă: atacatorii care obțin drepturi de administrator caută și șterg sau criptează backupurile înainte să lanseze criptarea. O copie pe suport deconectat (bandă, disc scos) sau în stocare imuabilă (de exemplu Object Lock în modul compliance pe S3, care împiedică ștergerea până la o dată stabilită, chiar și de către administratori) supraviețuiește;
  • 0 erori: backupurile sunt verificate automat, iar restaurarea este testată periodic. Un backup netestat este doar o speranță.

Detalii practice:

  • backupurile se criptează, pentru că o copie furată conține toate datele;
  • credențialele pentru sistemul de backup sunt separate de cele de domeniu;
  • retenția acoperă și cazul în care descoperi o corupere sau o compromitere după săptămâni;
  • frecvența backupurilor se stabilește din RPO, adică din cât de multe date îți permiți să pierzi.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi backupul ca măsură de securitate, nu doar operațională. Greșeala frecventă este un backup accesibil cu aceleași credențiale de administrator ca restul rețelei.

83 Junior

Care este diferența dintre RPO și RTO și cum influențează ele planul de backup?

Răspuns scurt: RPO este cantitatea maximă de date, măsurată în timp, pe care îți permiți să o pierzi; RTO este timpul maxim până la refacerea serviciului. RPO dictează frecvența backupurilor sau replicării, RTO dictează metoda și viteza de restaurare.

Exemplu: un magazin online stabilește RPO de 15 minute și RTO de 2 ore pentru baza de comenzi. Asta înseamnă că, după un incident, pot lipsi cel mult ultimele 15 minute de comenzi, iar magazinul trebuie să funcționeze din nou în cel mult 2 ore.

Ce decurge de aici:

  • RPO 24 de ore: un backup complet pe noapte poate fi suficient;
  • RPO de câteva minute: ai nevoie de backup continuu al jurnalelor de tranzacții (de exemplu arhivarea WAL în PostgreSQL), de snapshot-uri frecvente sau de replicare;
  • RPO aproape zero: replicare sincronă, cu costuri și latențe mai mari.

Pentru RTO:

  • RTO de zile: restaurare de pe bandă, reinstalare manuală;
  • RTO de ore: imagini pregătite, infrastructură ca cod, proceduri testate;
  • RTO de minute: mediu de rezervă pregătit (warm sau hot standby) și comutare automată.

Capcane importante din perspectiva securității:

  • replicarea nu este backup: dacă datele sunt criptate de ransomware sau șterse greșit, replicarea copiază imediat și distrugerea. Ai nevoie și de copii istorice;
  • RTO-ul real la un incident de securitate este mai mare decât la o defecțiune tehnică, pentru că trebuie să verifici că backupul nu e compromis, să identifici calea de intrare și să reconstruiești sisteme curate;
  • valorile se stabilesc împreună cu business-ul, printr-o analiză a impactului (BIA), nu doar de IT.

Ambele se verifică prin teste reale de restaurare, cronometrate.

Ce urmărește intervievatorul: Se verifică dacă poți traduce cerințele de business în decizii tehnice. Greșeala tipică este considerarea replicării drept backup.

84 Junior

Care este diferența dintre CVE, CWE și CPE și cum le folosești împreună?

Răspuns scurt: CVE identifică o vulnerabilitate concretă într-un produs (de exemplu CVE-2021-44228 în Log4j). CWE descrie tipul de slăbiciune (de exemplu CWE-79, XSS). CPE denumește standardizat produsul și versiunea. Împreună spun ce e vulnerabil, de ce fel și dacă ai produsul.

CVE (Common Vulnerabilities and Exposures) este catalogul de vulnerabilități publice, cu identificatori de forma CVE-an-număr. Fiecare intrare descrie o problemă într-un produs și versiuni anume. Bazele de date precum NVD adaugă scoruri CVSS și referințe.

CWE (Common Weakness Enumeration) este o taxonomie a tipurilor de greșeli:

  • CWE-89: injecție SQL;
  • CWE-79: XSS;
  • CWE-22: path traversal;
  • CWE-502: deserializarea datelor nesigure;
  • CWE-798: credențiale scrise în cod.

MITRE publică anual lista CWE Top 25 a celor mai periculoase slăbiciuni.

CPE (Common Platform Enumeration) este un format standard pentru numele produselor, de exemplu cpe:2.3:a:apache:log4j:2.14.1:*:*:*:*:*:*:*. Scanerele de vulnerabilități și bazele CVE îl folosesc ca să lege o vulnerabilitate de produsele din inventar.

Cum le folosești:

  • CPE în inventar: știi exact ce produse și versiuni ai;
  • CVE pentru remediere: scanerul potrivește CPE-urile tale cu CVE-urile publicate;
  • CWE pentru prevenție: dacă multe vulnerabilități găsite în propriul cod sunt CWE-89, problema nu e un bug izolat, ci o lipsă de practică în echipă (interogări parametrizate, revizuire de cod). Uneltele SAST raportează rezultatele cu ID-uri CWE.

Notă practică: potrivirea pe CPE generează și fals pozitive, de exemplu când o distribuție Linux a aplicat corecția fără să schimbe numărul de versiune.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi vocabularul comun al managementului vulnerabilităților. Greșeala frecventă este confuzia dintre o vulnerabilitate concretă (CVE) și o clasă de slăbiciuni (CWE).

85 Junior

Care este diferența dintre un plan de continuitate a afacerii (BCP) și un plan de recuperare în caz de dezastru (DRP)?

Răspuns scurt: BCP stabilește cum continuă organizația să-și desfășoare activitățile critice în timpul unei întreruperi, inclusiv oameni, procese, comunicare și furnizori. DRP este partea tehnică: cum se restaurează sistemele IT și datele, în ce ordine și în ce timp. DRP-ul este o componentă a continuității.

BCP (Business Continuity Plan) răspunde la întrebarea: „cum funcționăm cât timp lucrurile sunt stricate?”. Include:

  • procesele critice și ordinea priorităților, stabilite prin analiza impactului (BIA);
  • proceduri alternative, de exemplu lucrul pe hârtie sau telefonic dacă sistemul de comenzi este indisponibil;
  • locații alternative de lucru, lucrul de acasă;
  • comunicarea cu angajații, clienții, autoritățile și presa;
  • rolurile și lanțul de decizie.

DRP (Disaster Recovery Plan) răspunde la întrebarea: „cum readucem IT-ul?”. Include:

  • inventarul sistemelor, dependențele dintre ele și ordinea restaurării (de exemplu identitatea și DNS-ul înaintea aplicațiilor);
  • RPO și RTO pentru fiecare sistem;
  • locația backupurilor, procedurile de restaurare pas cu pas, credențialele de urgență;
  • mediul de rezervă și modul de comutare.

Legătura cu securitatea:

  • incidentele de securitate, precum ransomware-ul, sunt astăzi una dintre cele mai probabile cauze de activare a acestor planuri;
  • planurile trebuie să existe și offline sau într-un sistem separat: dacă documentația stă doar pe serverul de fișiere criptat, nu o poți citi;
  • canalele de comunicare de rezervă contează, pentru că emailul firmei poate fi compromis sau indisponibil;
  • planurile se testează: exerciții de tip tabletop (discuție pe un scenariu) și teste reale de restaurare.

Standardul ISO 22301 tratează continuitatea afacerii, iar ISO/IEC 27001 cere controale pentru securitatea informației în timpul perturbărilor.

Ce urmărește intervievatorul: Se verifică dacă înțelegi relația dintre securitate, operațiuni și business. Greșeala tipică este tratarea continuității ca problemă exclusiv IT.

86 Mid

De ce o scanare de vulnerabilități autentificată dă rezultate diferite de una neautentificată și de ce apar fals pozitive la serverele Linux actualizate?

Răspuns scurt: Scanarea neautentificată vede doar ce e expus și deduce versiunile din bannere; cea autentificată citește pachetele și configurațiile, deci e mai completă și precisă. Fals pozitivele vin din backporting: distribuția corectează fără să schimbe versiunea principală.

Scanarea neautentificată privește sistemul ca un atacator din rețea. Află ce porturi sunt deschise, ce servicii răspund și ce versiuni declară în bannere. Avantaj: arată exact ce e expus. Limite: nu vede bibliotecile interne, aplicațiile care nu ascultă pe rețea, browserele de pe o stație, configurațiile.

Scanarea autentificată folosește un cont (SSH pe Linux, WMI sau SMB pe Windows) sau un agent instalat. Citește lista de pachete și versiunile exacte, actualizările Windows instalate, setările de configurare. Găsește de obicei mult mai multe probleme reale, iar rezultatele sunt mai precise.

Backporting: distribuțiile enterprise (RHEL, Debian, Ubuntu LTS) păstrează versiunea principală a pachetelor stabilă și aplică doar corecțiile de securitate. Un server poate rula OpenSSH 8.9p1 cu toate corecțiile, iar un scaner neautentificat care citește bannerul crede că are toate vulnerabilitățile publicate pentru 8.9p1. Scanarea autentificată verifică versiunea completă a pachetului (de exemplu 1:8.9p1-3ubuntu0.10) și avizele de securitate ale distribuției, deci evită fals pozitivul.

Bune practici:

  • folosești ambele: neautentificată pentru perspectiva externă, autentificată pentru acuratețe;
  • contul de scanare are drepturi minime necesare și credențiale protejate (un cont de scanare cu drepturi de administrator pe toată rețeaua este o țintă valoroasă);
  • verifici fals pozitivele cu avizele distribuției (de exemplu Ubuntu Security Notices) și le marchezi documentat în unealtă, ca să nu reapară la fiecare scanare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi cum funcționează uneltele și de unde vin erorile lor. Greșeala frecventă este raportarea automată a tuturor rezultatelor bazate pe banner ca vulnerabilități reale.

87 Senior

Cum proiectezi backupurile unei firme astfel încât să rămână utilizabile chiar dacă atacatorul a obținut drepturi de administrator de domeniu?

Răspuns scurt: Separi backupul de identitatea principală (conturi și MFA proprii, în afara domeniului), păstrezi o copie imuabilă sau offline, izolezi infrastructura de backup în rețea, monitorizezi ștergerile și testezi restaurarea într-un mediu izolat.

În atacurile ransomware moderne, criptarea este ultimul pas. Înainte, atacatorii obțin drepturi largi, caută consola de backup, șterg copiile, dezactivează joburile și abia apoi criptează. Presupunerea de design trebuie să fie că domeniul Active Directory și administratorii lui sunt compromiși.

Principii:

  • Identitate separată: serverele de backup nu sunt membre ale domeniului de producție sau sunt într-un domeniu separat; conturile de administrare a backupului sunt dedicate, cu MFA puternic, fără parole refolosite.
  • Imuabilitate: stocare cu blocare la scriere (Object Lock în modul compliance, depozite Linux întărite cu fișiere imuabile, bandă scoasă din unitate). Nici administratorul backupului nu poate scurta retenția.
  • Separare în rețea: infrastructura de backup este într-un segment propriu; serverele de producție nu pot iniția conexiuni administrative spre ea; interfața de administrare nu este accesibilă din rețeaua obișnuită.
  • Aprobare în doi pași pentru ștergeri și modificări de retenție, unde soluția o permite.
  • Detecție: alerte la ștergerea punctelor de restaurare, la oprirea joburilor, la modificarea politicilor, la volume anormale de date modificate (semn de criptare).
  • Retenție suficient de lungă: atacatorii pot sta în rețea săptămâni; ai nevoie de puncte de restaurare dinainte de compromitere.
  • Restaurare testată în mediu curat: restaurezi într-o rețea izolată, scanezi înainte de reintroducere și ai documentată ordinea de reconstrucție (identitate, DNS, apoi aplicații).
  • Planuri și credențiale de urgență offline, accesibile fără sistemele compromise.

Măsura succesului nu este „avem backup”, ci un test recent de restaurare completă a unui sistem critic, cu timp măsurat.

Ce urmărește intervievatorul: Se verifică dacă proiectezi presupunând compromiterea, ca un arhitect de securitate. Greșeala frecventă la nivel senior este integrarea backupului în același domeniu și cu aceleași conturi ca producția.

Unelte și standarde

Exersează capitolul cu exerciții reale: Curs Cybersecurity online →
88 Junior

Cum folosești Nmap pentru a verifica expunerea propriei infrastructuri și cum interpretezi stările open, closed și filtered?

Răspuns scurt: Scanezi doar sisteme proprii sau cu autorizare scrisă, de exemplu nmap -sV -p- server.firma.ro, și compari cu ce ar trebui expus. Open: un serviciu acceptă conexiuni; closed: portul răspunde, dar nimic nu ascultă; filtered: un firewall blochează.

Din perspectivă defensivă, Nmap răspunde la întrebarea „ce vede cineva din exterior?”. Rezultatul real diferă adesea de documentație: un serviciu de test uitat, o bază de date pornită pe toate interfețele, o regulă de firewall prea largă.

Regula de bază: scanezi doar sisteme pe care le administrezi sau pentru care ai acordul scris al proprietarului, inclusiv al furnizorului de cloud când politica lui o cere. Scanarea neautorizată a sistemelor altora poate fi ilegală.

Exemple:

BASH
# toate porturile TCP, cu detectarea versiunilor serviciilor
nmap -sV -p- -oA scan-extern server.firma.ro

# porturile UDP cele mai uzuale (mai lent)
sudo nmap -sU --top-ports 50 server.firma.ro

# o subrețea internă, doar descoperirea hosturilor active
nmap -sn 10.20.0.0/24

-oA salvează rezultatul în trei formate, util ca să compari scanările în timp.

Stările:

  • open: o aplicație acceptă conexiuni. Verifici dacă trebuie să fie expusă;
  • closed: hostul răspunde (pentru TCP, cu RST), dar nicio aplicație nu ascultă. Nu e periculos, dar arată că nu există filtrare pentru acel port;
  • filtered: nu primești răspuns sau primești un mesaj ICMP de blocare, deci un firewall filtrează. Este starea dorită pentru porturile care nu trebuie folosite;
  • open|filtered: frecvent la UDP, unde lipsa răspunsului nu e concludentă.

Cel mai util este să rulezi scanarea periodic, din exterior și din interior, și să compari rezultatele (de exemplu cu ndiff), cu alertă pentru orice port nou deschis.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să folosești o unealtă clasică în scop defensiv și responsabil. Greșeala tipică este să nu menționezi autorizarea sau să confunzi closed cu filtered.

Eroarea, în practică:ssh: Connection refusedssh: Connection timed out

89 Junior

Ce filtre de afișare Wireshark ai folosi ca să depanezi o problemă de conexiune la un server intern și ce urmărești în fiecare caz?

Răspuns scurt: Pornești de la ip.addr == 10.0.0.5 și tcp.port == 443, apoi cauți resetările cu tcp.flags.reset == 1, retransmisiile cu tcp.analysis.retransmission, interogările DNS cu dns, handshake-urile TLS cu tls.handshake și erorile HTTP cu http.response.code >= 400. Fiecare filtru arată alt strat al problemei.

Wireshark are două tipuri de filtre: de captură (sintaxă BPF, aplicate în timp ce înregistrezi, de exemplu host 10.0.0.5 and port 443) și de afișare (aplicate după, cu sintaxă proprie). Cele de afișare sunt cele folosite la analiză.

Un traseu de depanare:

ip.addr == 10.0.0.5 && tcp.port == 443

Restrângi la conversația care te interesează.

dns.qry.name contains "intern.firma.ro"

Clientul rezolvă numele? Ce IP primește? Un răspuns greșit sau NXDOMAIN explică totul.

tcp.flags.syn == 1 && tcp.flags.ack == 0

Pornesc conexiunile? Dacă vezi doar SYN-uri repetate fără răspuns, un firewall aruncă pachetele sau serviciul nu e accesibil.

tcp.flags.reset == 1

Un RST imediat după SYN înseamnă că portul e închis sau că un firewall respinge activ.

tcp.analysis.retransmission || tcp.analysis.zero_window

Pierderi de pachete sau un receptor supraîncărcat.

tls.handshake.type == 1 || tls.alert_message

Client Hello-ul pleacă? Apare o alertă TLS (de exemplu certificat necunoscut sau versiune nesuportată)?

http.response.code >= 400

Erori la nivel de aplicație, vizibile doar dacă traficul nu e criptat sau dacă ai cheile de sesiune ale propriului client (variabila SSLKEYLOGFILE la browsere).

Din considerente de confidențialitate, capturezi doar trafic pe care ai dreptul să-l analizezi, cât mai restrâns, și tratezi fișierele .pcap ca date sensibile.

Ce urmărește intervievatorul: Se verifică dacă știi să folosești o captură de trafic metodic, strat cu strat. Greșeala tipică este capturarea a tot fără filtre și încercarea de a citi mii de pachete.

90 Junior

Ce sunt honeypot-urile și canary token-urile și ce valoare au pentru o echipă defensivă?

Răspuns scurt: Un honeypot este un sistem fals care imită o țintă atractivă; un canary token este un element fals mic (fișier, cheie, cont, URL) care declanșează alertă la folosire. Nimeni nu are motiv legitim să le atingă, deci alertele au foarte puține fals pozitive.

Problema principală în detecție este zgomotul: majoritatea alertelor sunt activități legitime. Honeypot-urile și canary token-urile inversează situația: nimeni nu are motiv legitim să le atingă, deci o singură interacțiune este un semnal puternic.

Honeypot în rețeaua internă: un server care pare un server de fișiere sau o bază de date, cu un nume atractiv, dar fără date reale. Un atacator care scanează rețeaua sau încearcă autentificări pe el se dezvăluie. Variante de complexitate redusă (care doar simulează servicii) sunt suficiente pentru detecție și mai ușor de întreținut decât cele complete.

Canary tokens, exemple:

  • un document parole_admin.docx pe un share, care la deschidere contactează un URL de alertă;
  • chei de acces AWS false, plasate într-un fișier de configurare; orice folosire apare în logurile furnizorului și declanșează alertă;
  • un cont de utilizator fals în Active Directory, cu un nume atractiv, monitorizat pentru orice încercare de autentificare;
  • o înregistrare falsă într-o bază de date de clienți, cu o adresă de email monitorizată, care semnalează o scurgere dacă primește mesaje.

Servicii gratuite precum Canarytokens de la Thinkst permit generarea rapidă a unor astfel de capcane.

Precauții:

  • honeypot-ul trebuie izolat, ca să nu devină un punct de pornire spre rețeaua reală;
  • alertele trebuie să ajungă la cineva care reacționează, altfel capcana nu ajută;
  • se documentează intern (pentru echipa de securitate), ca să nu fie confundate cu sisteme reale în inventar.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi tehnici de detecție cu raport bun între cost și beneficiu. Greșeala frecventă este conectarea unui honeypot la rețeaua de producție fără izolare.

91 Junior

Care este diferența dintre SAST, DAST și SCA și unde le integrezi în procesul de dezvoltare?

Răspuns scurt: SAST analizează codul sursă fără să-l ruleze. DAST testează aplicația pornită, din exterior. SCA verifică dependențele terțe pentru vulnerabilități cunoscute și licențe. SAST și SCA rulează la pull request, DAST pe mediul de test după deploy.

SAST (Static Application Security Testing): unelte precum Semgrep, CodeQL sau SonarQube citesc codul și urmăresc fluxul datelor de la surse (parametrii cererii) la funcții periculoase (interogări SQL, comenzi de sistem). Avantaje: rulează devreme, indică linia exactă. Dezavantaje: fals pozitive, nu vede problemele de configurare sau de logică.

DAST (Dynamic Application Security Testing): unelte precum OWASP ZAP trimit cereri către aplicația pornită și analizează răspunsurile: headere lipsă, erori care dezvăluie informații, reflectarea input-ului, configurări greșite. Avantaje: vede aplicația reală, independent de limbaj. Dezavantaje: rulează mai târziu, nu indică linia de cod, acoperirea depinde de cât din aplicație poate explora (inclusiv paginile de după autentificare).

SCA (Software Composition Analysis): unelte precum Dependabot, npm audit, pip-audit, OWASP Dependency-Check, Snyk sau Trivy compară dependențele, inclusiv pe cele indirecte, cu bazele de vulnerabilități. Majoritatea codului unei aplicații moderne vine din biblioteci, deci SCA acoperă o parte mare din risc.

Integrare tipică în pipeline:

  • la commit: scanare de secrete (gitleaks, trufflehog) în pre-commit și în CI;
  • la pull request: SAST și SCA, cu blocare doar pentru problemele critice confirmate, ca echipa să nu ignore uneltele;
  • la build: scanarea imaginii de container;
  • după deploy pe staging: DAST automat;
  • periodic: SCA pe aplicațiile deja în producție, pentru vulnerabilitățile publicate după lansare.

Uneltele completează revizuirea de cod și testarea manuală, nu le înlocuiesc.

Ce urmărește intervievatorul: Se verifică dacă știi locul fiecărui tip de testare automată. Greșeala tipică este activarea tuturor regulilor cu blocare totală, ceea ce face echipa să ocolească uneltele.

92 Mid

Cum folosești Burp Suite ca dezvoltator sau tester ca să verifici, pe propria aplicație într-un mediu de test, că o corecție de securitate funcționează?

Răspuns scurt: Treci browserul prin proxy-ul Burp, faci fluxul normal și găsești cererea în istoricul HTTP. În Repeater modifici controlat ID-ul resursei, rolul sau tokenul și verifici că serverul refuză acum cererile care nu trebuie permise.

Burp Suite (ediția Community este gratuită) este un proxy de interceptare: stă între browser și aplicație și îți arată fiecare cerere și răspuns. Pentru o echipă de dezvoltare este util pentru că arată ce trimite efectiv clientul, nu ce crezi că trimite interfața. Se folosește doar pe aplicații proprii sau cu autorizare, într-un mediu de test, cu date de test.

Configurare:

  • pornești browserul integrat al Burp sau setezi proxy-ul 127.0.0.1:8080 și instalezi certificatul Burp în browserul de test, ca să poți vedea traficul HTTPS;
  • definești scope-ul (domeniul aplicației de test), ca să nu înregistrezi trafic către alte site-uri.

Exemplu de verificare a unei corecții de control al accesului:

  • te loghezi ca utilizatorul A și deschizi propria factură; în Proxy, HTTP history găsești cererea GET /api/facturi/1001;
  • o trimiți în Repeater și schimbi ID-ul cu cel al unei facturi a utilizatorului B. Înainte de corecție primeai datele; acum trebuie să primești 403 sau 404;
  • înlocuiești cookie-ul de sesiune cu unul al unui utilizator cu alt rol, ca să verifici și endpoint-urile de administrare;
  • elimini complet headerul de autentificare și verifici că răspunsul este 401.

Alte funcții utile pentru verificare: Comparer, pentru diferențele dintre răspunsuri, și Decoder, pentru a vedea conținutul unui token sau al unui cookie codificat.

Rezultatul bun al unei astfel de verificări este un test automat: cererea care a dovedit problema devine un test de integrare în suita aplicației, ca regresia să fie prinsă la următoarele modificări.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să folosești o unealtă de testare în mod controlat, pentru confirmarea remedierilor. Greșeala frecventă este testarea manuală o singură dată, fără a transforma cazul într-un test automat.

93 Mid

Cum verifici configurația TLS a unui server din linia de comandă și ce probleme cauți?

Răspuns scurt: Folosești openssl s_client pentru verificări punctuale (versiune, certificat, lanț) și o unealtă dedicată precum testssl.sh sau sslyze pentru o analiză completă. Cauți versiuni vechi activate (TLS 1.0/1.1, SSL), suite de cifrare slabe, lanț incomplet, certificat aproape expirat sau cu nume greșit și lipsa HSTS.

Verificări punctuale cu OpenSSL:

BASH
# acceptă serverul TLS 1.3? ce suită negociază?
openssl s_client -connect app.firma.ro:443 -servername app.firma.ro -tls1_3 </dev/null 2>/dev/null \
  | grep -E "Protocol|Cipher"

# mai acceptă TLS 1.1? (răspuns corect: handshake eșuat)
openssl s_client -connect app.firma.ro:443 -servername app.firma.ro -tls1_1 </dev/null

Atenție: versiunile recente de OpenSSL au protocoalele vechi dezactivate la nivel de bibliotecă, deci un eșec poate veni din clientul tău, nu din server. De aceea uneltele dedicate sunt mai fiabile.

Analiză completă:

BASH
./testssl.sh --severity MEDIUM https://app.firma.ro
# sau
sslyze app.firma.ro

Ce urmărești:

  • protocoale: doar TLS 1.2 și 1.3; SSLv3, TLS 1.0 și 1.1 dezactivate;
  • suite de cifrare pentru TLS 1.2: doar ECDHE cu AEAD (AES-GCM, ChaCha20-Poly1305); fără RC4, 3DES, CBC cu SHA-1, NULL, EXPORT, fără schimb de chei RSA static;
  • certificat: nume corecte în SAN, lanț complet, cheie suficient de mare, expirare monitorizată;
  • OCSP stapling și HSTS;
  • vulnerabilități cunoscute ale implementării, pe care testssl.sh le verifică automat (de exemplu Heartbleed pe versiuni vechi de OpenSSL).

Pentru servere publice, serviciul Qualys SSL Labs oferă un raport cu notă. Ghidul Mozilla Server Side TLS și generatorul lui de configurații dau configurații recomandate pentru Nginx, Apache și alte servere, în profilurile „modern” și „intermediate”.

Ce urmărește intervievatorul: Se verifică dacă poți audita concret o configurație TLS. Greșeala tipică este interpretarea unui eșec al clientului OpenSSL local ca dovadă că serverul nu suportă protocolul.

Eroarea, în practică:certificate has expiredcurl: (35) tlsv1 alert protocol version

94 Mid

Care e diferența dintre OWASP Top 10 și OWASP ASVS și când folosești fiecare?

Răspuns scurt: OWASP Top 10 este un document de conștientizare: o listă a celor mai importante categorii de riscuri în aplicațiile web. OWASP ASVS (Application Security Verification Standard) este un standard detaliat de cerințe verificabile, pe niveluri, folosit pentru specificații, revizuiri și teste de securitate.

OWASP Top 10 se actualizează la câțiva ani (ediția 2021 este cea mai citată, iar una nouă a fost publicată în 2025). Grupează riscurile în zece categorii largi, de exemplu controlul de acces defect, defectele criptografice, injecțiile. E util pentru instruire, pentru prioritizare la nivel general și pentru a vorbi aceeași limbă cu managementul. Nu este o listă de verificare: o aplicație „conformă cu Top 10” nu înseamnă nimic precis.

OWASP ASVS (versiunea 5.0 a fost publicată în 2025) conține sute de cerințe concrete și testabile, organizate pe capitole (autentificare, sesiuni, control de acces, validare, criptografie, API-uri, configurare) și pe trei niveluri:

  • L1: minimul pentru orice aplicație;
  • L2: pentru aplicații care manipulează date sensibile; nivelul recomandat pentru majoritatea aplicațiilor de business;
  • L3: pentru aplicații critice (financiare, medicale, infrastructură).

O cerință ASVS are forma unei afirmații verificabile, de exemplu că aplicația invalidează toate sesiunile active după schimbarea parolei.

Cum le folosești:

  • Top 10 pentru instruirea echipei și pentru a explica de ce contează securitatea;
  • ASVS pentru cerințe nefuncționale în specificații, liste de verificare la revizuirea de cod, criterii de acceptare și ca bază pentru un test de penetrare sau pentru o cerință contractuală față de un furnizor („aplicația respectă ASVS L2”).

Există și liste dedicate: OWASP API Security Top 10 pentru API-uri și OWASP MASVS pentru aplicații mobile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să transformi principiile în cerințe verificabile. Greșeala frecventă este folosirea Top 10 ca listă de verificare de conformitate.

95 Mid

Ce urmărește PCI DSS la nivel de principiu și cum reduce tokenizarea aria sistemelor afectate de standard?

Răspuns scurt: PCI DSS este standardul industriei cardurilor de plată pentru cine stochează, procesează sau transmite date de card. Se aplică mediului cu date de card și sistemelor conectate la el, iar tokenizarea sau plata găzduită la procesator scot majoritatea sistemelor din arie.

PCI DSS (versiunea 4.0, cu 4.0.1 curentă și cerințele noi obligatorii din martie 2025) este stabilit de PCI Security Standards Council, înființat de marile rețele de carduri. Nu este o lege, ci o obligație contractuală față de bănci și procesatori.

Cerințele sunt grupate în 12 secțiuni, pe teme precum: securitatea rețelei, configurații sigure, protecția datelor de card stocate, criptarea la transmiterea pe rețele publice, protecția împotriva malware-ului, dezvoltarea sigură, controlul accesului pe principiul need-to-know, autentificarea (inclusiv MFA pentru accesul la mediul cu date de card), jurnalizarea și monitorizarea, testarea regulată și politicile de securitate. Codul de verificare de pe spatele cardului (CVV) nu poate fi stocat după autorizare.

Aria (scope-ul) este conceptul cheie: cerințele se aplică mediului datelor de card (CDE) și oricărui sistem care se poate conecta la el. Cu cât aria e mai mare, cu atât auditul și controalele costă mai mult.

Cum se reduce aria:

  • plată găzduită sau câmpuri furnizate de procesator: formularul de card este servit de procesatorul de plăți, iar datele nu trec niciodată prin serverele tale;
  • tokenizare: procesatorul întoarce un token (o valoare fără semnificație în afara sistemului lui), folosit pentru plăți recurente sau rambursări. Sistemele tale stochează doar tokenul;
  • segmentare strictă dacă trebuie totuși să procesezi date de card.

Chiar și cu plată găzduită, pagina ta care încarcă formularul rămâne parțial în arie: PCI DSS 4.0 cere controlul și monitorizarea scripturilor de pe paginile de plată, ca să prevină skimming-ul.

Ce urmărește intervievatorul: Se verifică dacă înțelegi standardele ca decizii de arhitectură, nu doar ca liste de verificare. Greșeala tipică este să crezi că folosirea unui procesator elimină complet obligațiile.

Situații din practică

96 Mid

Un coleg îți spune că a urcat din greșeală o cheie de acces AWS într-un repository public de GitHub și a șters-o deja cu un commit nou. Ce faci, în ordine?

Răspuns scurt: Consideri cheia compromisă, chiar dacă a fost publică doar câteva minute: o dezactivezi și o rotești imediat, verifici în CloudTrail ce s-a făcut cu ea, cauți resurse create neautorizat, cureți istoricul repository-ului și abia apoi analizezi cauza, fără să cauți vinovați.

Un model de răspuns structurat:

1. Revocare imediată (minute, nu ore). Un commit nou nu șterge cheia din istoric, iar roboții care scanează repository-urile publice găsesc chei în foarte scurt timp. Dezactivezi cheia în IAM, creezi una nouă doar dacă e necesară și o pui într-un manager de secrete, nu în cod. Dacă AWS a aplicat automat politica de carantină pentru chei expuse (AWSCompromisedKeyQuarantine), nu te bazezi pe ea: revoci oricum.

2. Evaluarea impactului. Ce permisiuni avea identitatea asociată cheii? În CloudTrail filtrezi evenimentele după ID-ul cheii, în toate regiunile, din momentul publicării: crearea de utilizatori sau chei noi, instanțe noi (adesea pentru minat), modificări de politici, acces la bucket-uri S3. Verifici și facturarea pentru creșteri neobișnuite.

3. Curățare. Ștergi resursele create de atacator, revoci credențialele create de el și elimini persistența (utilizatori, roluri, chei noi). Dacă există semne de acces la date, tratezi situația ca incident de securitate, cu notificările legale aplicabile.

4. Istoricul repository-ului. Rescrii istoricul cu git filter-repo sau cu BFG, dar reții că forkurile și copiile existente pot păstra cheia; tocmai de aceea revocarea vine prima.

5. Prevenție:

  • scanare de secrete în pre-commit și în CI, plus GitHub secret scanning și push protection;
  • credențiale temporare în locul cheilor permanente (roluri IAM, SSO, OIDC pentru pipeline-uri);
  • permisiuni minime pentru identitățile folosite de aplicații.

6. Comunicare: mulțumești colegului pentru raportarea rapidă. O cultură în care oamenii ascund greșelile ar fi transformat un incident de minute într-unul de săptămâni.

Ce urmărește intervievatorul: Intervievatorul verifică ordinea priorităților și reacția calmă, nevinovatoare. Greșeala tipică este să crezi că ștergerea fișierului din ultimul commit rezolvă problema.

97 Mid

Un coleg vrea să adauge verify=False în scriptul care apelează un API intern, pentru că primește o eroare de certificat și termenul de livrare e mâine. Cum procedezi?

Răspuns scurt: Explici că verify=False face conexiunea vulnerabilă la orice interceptare și că problema e aproape mereu de configurare (lanț incomplet, autoritate internă). Diagnosticați și rezolvați corect cauza; o eventuală excepție temporară se documentează, cu termen de eliminare.

Un răspuns structurat, care arată atât partea tehnică, cât și colaborarea:

Înțeleg presiunea. Nu încep cu „nu ai voie”, ci cu obiectivul comun: scriptul trebuie să meargă mâine și să nu creeze o problemă de securitate.

Explic riscul concret, în termenii lui. Cu verify=False, scriptul acceptă orice certificat. Oricine se poate interpune în rețea (un dispozitiv compromis, o configurare greșită de DNS) poate citi tokenul API și datele trimise și poate modifica răspunsurile. Mai mult, astfel de setări ajung adesea copiate în alte scripturi și rămân ani de zile.

Diagnosticăm împreună, de obicei în câteva minute:

BASH
openssl s_client -connect api.intern.firma.ro:443 -servername api.intern.firma.ro -showcerts </dev/null
  • dacă serverul trimite doar certificatul final, cerem echipei care îl administrează să configureze lanțul complet;
  • dacă certificatul e emis de autoritatea internă a firmei, o adăugăm explicit: requests.get(url, verify="/etc/ssl/firma-root-ca.pem") sau prin variabila REQUESTS_CA_BUNDLE;
  • dacă certificatul e expirat sau numele nu corespunde, problema este pe server și trebuie raportată, pentru că afectează și alți clienți.

Dacă nu se poate rezolva până mâine: o excepție aprobată, limitată (de exemplu fixarea certificatului cunoscut, nu dezactivarea totală), documentată într-un tichet, cu responsabil și dată de eliminare.

După: adăugăm o regulă în SAST care semnalează verify=False și echivalentele lui din alte limbaje, plus o notă în documentația internă despre autoritatea internă de certificare.

Ce urmărește intervievatorul: Se verifică echilibrul între livrare și securitate și capacitatea de a convinge fără blocaje. Greșeala tipică este fie acceptarea fără discuție, fie refuzul fără o soluție alternativă.

Eroarea, în practică:unable to get local issuer certificateself-signed certificate

98 Mid

Primești pe email un mesaj de la un cercetător extern care spune că a găsit o vulnerabilitate în aplicația firmei. Cum gestionezi situația?

Răspuns scurt: Confirmi rapid primirea, reproduci problema într-un mediu de test, evaluezi severitatea, remediezi cu prioritatea potrivită și ții cercetătorul informat, apoi stabiliți împreună publicarea. Pe termen lung publici o politică de divulgare și un security.txt.

Model de răspuns pe pași:

1. Răspuns rapid. Confirmi primirea în 1–2 zile lucrătoare, mulțumești și spui ce urmează. Cercetătorii care nu primesc răspuns ajung uneori să publice direct.

2. Verificare atentă a mesajului. Tratezi atașamentele și linkurile cu prudență (pot fi phishing) și nu rulezi nimic primit pe sisteme de producție.

3. Triere. Reproduci problema într-un mediu de test, pe baza descrierii. Evaluezi impactul real: ce date sau funcții sunt afectate, cât de ușor e de exploatat, dacă există semne că a fost deja exploatată (verifici logurile).

4. Remediere cu prioritate proporțională cu severitatea. Pentru o problemă critică, implici imediat echipa de dezvoltare și, dacă datele personale au fost expuse, responsabilul cu protecția datelor, pentru evaluarea obligațiilor de notificare conform GDPR.

5. Comunicare continuă. Îi spui cercetătorului când estimezi corecția și îi ceri să nu publice detalii până atunci. O practică frecventă în industrie este un termen de aproximativ 90 de zile.

6. Închidere. Confirmi remedierea, îi permiți să verifice, discutați publicarea și, dacă firma are o astfel de practică, recunoașterea (pagină de mulțumiri, recompensă).

Ce nu faci: amenințări juridice față de cineva care a raportat responsabil, ignorarea mesajului sau o corecție superficială fără verificare.

Pe termen lung: o politică de divulgare coordonată publicată pe site și un fișier /.well-known/security.txt (RFC 9116) cu adresa de contact, ca rapoartele să ajungă direct la persoanele potrivite.

Ce urmărește intervievatorul: Intervievatorul verifică maturitatea profesională și capacitatea de a gestiona relația cu exteriorul. Greșeala frecventă este reacția defensivă sau juridică în locul colaborării.

99 Senior

Se publică un CVE critic, exploatat activ, într-o bibliotecă open-source foarte răspândită. Managerul te întreabă în prima oră: „Suntem afectați?”. Cum răspunzi și ce faci în primele 48 de ore?

Răspuns scurt: În prima oră spui ce știi, ce nu știi și când revii cu răspunsul complet. Apoi inventariezi folosirea bibliotecii (SBOM, SCA, scanări, furnizori), prioritizezi sistemele expuse, aplici corecții sau măsuri temporare, cauți exploatări în loguri și comunici regulat.

Modelul de răspuns în prima oră: „Nu avem încă un răspuns complet. Am pornit inventarierea; în 4 ore vă dau lista sistemelor afectate confirmate și planul. Între timp, aplicăm măsuri temporare pe sistemele expuse pe internet.” Un răspuns onest și cu termen este mai util decât un „nu” spus prea repede.

Primele ore: inventar

  • SBOM și unelte SCA pe toate repository-urile și artefactele construite: căutarea include dependențele indirecte, nu doar cele declarate direct;
  • scanare autentificată a serverelor și a imaginilor de container (biblioteca poate fi inclusă în aplicații comerciale, fără să apară în codul vostru);
  • furnizori: aplicațiile terțe și serviciile SaaS; verifici avizele lor publicate și îi întrebi direct pe cei critici;
  • sistemele vechi, uitate, sunt cele mai probabile să fie omise.

Prioritizare: sistemele expuse pe internet și cele care procesează input extern primele, apoi cele interne.

Remediere:

  • actualizarea bibliotecii acolo unde e posibil, cu un proces accelerat de testare;
  • măsuri temporare documentate unde actualizarea durează: dezactivarea funcționalității vulnerabile prin configurare, reguli WAF (utile dar ocolibile), restricții de egress care pot bloca etapa următoare a exploatării.

Detecție: cauți în loguri indicatorii publicați și tiparele de exploatare, începând cu momentul publicării sau chiar dinainte, presupunând că atacatorii au acționat rapid. Dacă găsești exploatare reușită, treci în procedura de răspuns la incidente.

Comunicare: actualizări la intervale fixe, un singur document de stare (sisteme, stare, responsabil, termen).

După criză: lecții învățate, în special despre cât de repede ați putut răspunde la întrebarea „unde folosim biblioteca X?”. Dacă a durat zile, investiția în SBOM și inventar devine prioritară.

Ce urmărește intervievatorul: Se verifică dacă poți conduce un răspuns organizat sub presiune, cu comunicare clară. Greșeala tipică la nivel senior este un răspuns grăbit („nu folosim asta”) fără inventar real.

100 Senior

Un furnizor care întreține o aplicație a firmei cere să i se deschidă RDP din internet către serverul aplicației, „ca până acum la alți clienți”. Ce propui și cum argumentezi?

Răspuns scurt: Refuzi RDP expus direct pe internet, o cale frecventă de intrare pentru ransomware, și oferi o alternativă: VPN sau ZTNA cu MFA, conturi nominale, acces limitat în timp și la un singur server, sesiuni jurnalizate. Argumentezi prin risc, nu prin interdicție.

Modelul de răspuns combină partea tehnică cu negocierea.

De ce nu: RDP expus pe internet este scanat permanent și supus ghicirii de parole, iar serviciul a avut vulnerabilități critice care nu cer autentificare (de exemplu BlueKeep, CVE-2019-0708). Accesul furnizorilor este, conform rapoartelor publice ale multor echipe de răspuns la incidente, o cale frecventă de intrare. Dacă furnizorul are aceeași parolă la mai mulți clienți, compromiterea lui devine și a ta.

Ce propui:

  • acces prin VPN sau ZTNA (de exemplu un broker de acces sau un gateway RDP / Azure Bastion), nu port deschis;
  • conturi nominale pentru fiecare persoană de la furnizor, nu un cont comun;
  • MFA obligatoriu;
  • acces limitat: doar serverul aplicației, doar porturile necesare, fără acces la restul rețelei;
  • acces la cerere: contul este activat pentru o fereastră de timp aprobată (de exemplu prin tichet), apoi dezactivat automat;
  • jurnalizare și, pentru sistemele critice, înregistrarea sesiunilor;
  • revizuire periodică a accesului și dezactivare la încheierea contractului.

Cum argumentezi:

  • prezinți riscul în termeni de business: întreruperea activității, costul incidentului, obligațiile de notificare;
  • arăți că alternativa nu îi încetinește munca: furnizorul se conectează la fel de simplu, cu un pas suplimentar de autentificare;
  • formalizezi cerințele în contract și în anexa de securitate (de exemplu prin cerințele de securitate a furnizorilor din ISO/IEC 27001 și, unde se aplică, din NIS2);
  • dacă business-ul acceptă totuși riscul, decizia se ia de proprietarul riscului, documentat, cu măsuri compensatorii și termen de revizuire.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți spune „nu” constructiv, oferind o alternativă viabilă și argumente pe limba business-ului. Greșeala frecventă este refuzul fără soluție sau acceptarea pentru a evita conflictul.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Securitate cibernetică, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Securitate cibernetică scriind cod, nu doar citind

Curs Cybersecurity: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.