01 - OWASP Top 10 2025: Ghid pentru dezvoltatori
Fiecare linie de cod pe care o scriem poartă cu ea o responsabilitate implicită: protejarea datelor și încrederea utilizatorilor. În 2025, cu aplicații din ce în ce mai complexe, arhitecturi distribuite și adoptarea în creștere a instrumentelor de generare automată a codului, the Securitatea nu mai poate fi o idee ulterioară. Acolo OWASP Top 10 2025 reprezintă referința actualizată a celor mai critice zece vulnerabilități din aplicațiile web și fiecare dezvoltatorul ar trebui să-l cunoască în detaliu.
Acest ghid analizează toate cele zece categorii ale noii liste, cu un accent deosebit pe două noi categorii introduse în 2025: Eșecuri în lanțul de aprovizionare software (A03) e Manipularea greșită a condițiilor excepționale (A10). Pentru fiecare vulnerabilitate veți găsi explicații clare, cod vulnerabil și sigur în TypeScript/Node.js și bune practici specifice pentru Angular.
Ce vei învăța
- Toate cele 10 categorii OWASP 2025, inclusiv 2 noi
- Principalele diferențe față de versiunea 2021
- Exemple de cod vulnerabil și contramăsuri aferente
- Cum se asigură lanțul de aprovizionare al dependențelor npm
- de ce 45% din codul generat de AI eșuează testele de securitate
- O listă de verificare specifică Angular pentru a vă securiza aplicațiile
Ce este OWASP și cum s-a născut Top 10
La Deschideți proiectul de securitate a aplicațiilor la nivel mondial (OWASP) si o fundatie non-profit fondată în 2001 cu scopul de a îmbunătăți securitatea software-ului la nivel global globală. Cel mai cunoscut proiect al său este OWASP Top 10: un document de referință care listează cele mai critice zece vulnerabilități din aplicațiile web, actualizate periodic pe baza datelor reale colectate de la sute de organizații.
Lista este întocmită analizând milioane de aplicații și sute de mii de aplicații vulnerabilitate. Procesul se combină date empirice (accidente reale, rapoarte de securitate, analiză automată) cu a sondaj comunitar care colectează preocupările experților în securitate cu privire la amenințările emergente. Harta fiecărei categorii una sau mai multe CWE (Enumerarea punctelor slabe comune), sau clasificări standard of software weaknesses.
Versiunile anterioare
Top 10 OWASP a avut mai multe ediții: 2004, 2007, 2010, 2013, 2017, 2021 și acum 2025. Fiecare actualizare reflectă evoluția amenințărilor. În 2017, injecțiile au fost pe primul loc loc; în 2021, Broken Access Control i-a depășit. În 2025 vedem schimbări cu atât mai semnificativ, cu intrarea a două categorii complet noi care reflectă provocările moderne ale dezvoltării software.
Ce este nou în Top 10 OWASP 2025
Ediția 2025 aduce schimbări importante față de 2021. Iată lista completă cu schimbari de pozitie:
| Poziţie | OWASP 2025 | Modificare din 2021 |
|---|---|---|
| A01 | Control de acces spart | Confirmat la numărul 1 (a fost A01:2021). Acum include SSRF |
| A02 | Configurare greșită de securitate | Urcă de la #5 la #2 |
| A03 | Eșecuri în lanțul de aprovizionare software | NOU - se extinde A06:2021 (componente vulnerabile) |
| A04 | Eșecuri criptografice | Scade de la #2 la #4 |
| A05 | Injectare | Scade de la #3 la #5 |
| A06 | Design nesigur | Scade de la #4 la #6 |
| A07 | Eșecuri de autentificare | Confirmat la #7 |
| A08 | Eșecuri de integritate software sau date | Confirmat la #8 |
| A09 | Eșecuri de înregistrare și alerte de securitate | Confirmat la #9 (redenumit: „Alertare” în loc de „Monitorizare”) |
| A10 | Manipularea greșită a condițiilor excepționale | NOU - înlocuiește SSRF (acum încorporat în A01) |
Cele două schimbări cheie
A03: Eșecuri în lanțul de aprovizionare software - Atacurile asupra lanțului de aprovizionare de software au explodat în ultimii ani. Această categorie a fost votată ca principala preocupare în sondajul comunității OWASP. Acoperă typosquatting, confuzie de dependență, pachete rău intenționate și conducte CI/CD compromise.
A10: Manipularea greșită a condițiilor excepționale - Gestionarea incorectă a erori și excepții și acum recunoscut ca un vector de atac autonom. Include 24 CWE legate de gestionarea inadecvată a erorilor, deschiderea eșuată și scurgerile de informații sensibile prin mesaje de eroare.
A01:2025 - Control acces întrerupt
Il Control de acces spart rămâne ferm pe primul loc pentru al patrulea an consecutive. Apare atunci când un utilizator este capabil să acceseze resurse sau să efectueze acțiuni pentru care nu are autorizatie. Cele mai comune forme includ: IDOR (Referință nesigură la obiect direct), parcurgerea drumului, bypass de control rolurile și manipularea token-urilor sau a parametrilor URL.
În 2025, această categorie are a încorporat SSRF (falsificare de solicitare pe partea serverului), care în versiunea 2021 a ocupat poziția A10. Logica este că SSRF reprezintă practic o eroare de control al accesului: serverul face cereri către resurse la care nu ar trebui să ajungă.
Exemplu: IDOR (Insecure Direct Object Reference)
// VULNERABILE: nessun controllo di ownership
app.get('/api/users/:id/profile', async (req, res) => {
// Chiunque può vedere il profilo di qualsiasi utente cambiando l'ID
const user = await User.findById(req.params.id);
res.json(user);
});
// SICURO: verifica ownership + ruolo
app.get('/api/users/:id/profile', authenticate, async (req, res) => {
if (req.user.id !== req.params.id && req.user.role !== 'admin') {
return res.status(403).json({ error: 'Accesso non autorizzato' });
}
const user = await User.findById(req.params.id);
if (!user) {
return res.status(404).json({ error: 'Utente non trovato' });
}
res.json(user);
});Exemplu: Traversarea traseului
import path from 'path';
// VULNERABILE: l'utente controlla il percorso del file
app.get('/api/files/:filename', (req, res) => {
// Un attaccante può richiedere: ../../../etc/passwd
res.sendFile(`/uploads/${req.params.filename}`);
});
// SICURO: normalizza e valida il percorso
const UPLOAD_DIR = '/var/www/uploads';
app.get('/api/files/:filename', authenticate, (req, res) => {
const filename = path.basename(req.params.filename);
const filePath = path.join(UPLOAD_DIR, filename);
// Verifica che il percorso risolto sia dentro UPLOAD_DIR
if (!filePath.startsWith(UPLOAD_DIR)) {
return res.status(400).json({ error: 'Percorso non valido' });
}
res.sendFile(filePath);
});Apărări unghiulare pentru controlul accesului întrerupt
- Implementează Garzi de traseu (
canActivate,canMatch) pentru a proteja rutele rezervate - Folosiți a Interceptor HTTP pentru a atașa automat jetonul JWT la fiecare cerere
- Ascunde elementele UI pe baza permisiunilor, dar întotdeauna valabil pe partea serverului
- Nu introduceți niciodată roluri sau permisiuni în localStorage fără a verifica pe partea de backend
- Centralizați logica de autorizare într-unul singur AuthService reutilizabile
A02:2025 - Configurare greșită de securitate
Le Configurare greșită de securitate ele cresc de la #5 la #2 în 2025. Acest salt reflectă un fapt real: odată cu creșterea complexității configurațiilor (cloud, containere, microservicii, CDN), erorile de configurare au devenit una dintre cele mai frecvente cauze ale încălcărilor.
Această categorie include: configurații implicite neschimbate, anteturi HTTP securizate lipsă, CORS prea permisiv, stiva urme expuse în producție, porturi și servicii nu necesare expuse, iar funcțiile de depanare rămase active.
Antet de securitate și CORS
import helmet from 'helmet';
import cors from 'cors';
const app = express();
// Header di sicurezza con Helmet
app.use(helmet({
contentSecurityPolicy: {
directives: {
defaultSrc: ["'self'"],
scriptSrc: ["'self'"],
styleSrc: ["'self'", "https://fonts.googleapis.com"],
imgSrc: ["'self'", "data:", "https:"],
fontSrc: ["'self'", "https://fonts.gstatic.com"],
connectSrc: ["'self'", "https://api.tuodominio.com"],
frameAncestors: ["'none'"], // Protegge da clickjacking
objectSrc: ["'none'"],
}
},
referrerPolicy: { policy: 'strict-origin-when-cross-origin' },
hsts: { maxAge: 31536000, includeSubDomains: true, preload: true },
}));
// CORS restrittivo
app.use(cors({
origin: ['https://tuodominio.com'],
methods: ['GET', 'POST', 'PUT', 'DELETE'],
allowedHeaders: ['Content-Type', 'Authorization'],
credentials: true,
maxAge: 86400 // Cache preflight per 24 ore
}));Erori de configurare comune
Access-Control-Allow-Origin: *in productie- Urmele stivei complete vizibile în răspunsurile de eroare
- Acreditările implicite neschimbate (admin/admin)
- Depanați porturile (9229 pentru Node.js) expuse în producție
- Fişier
.envaccesibile publicului - Lista de director este activată pe serverul web
A03:2025 - Eșecuri în lanțul de aprovizionare software (NOU)
Aceasta este una dintre cele mai importante caracteristici noi ale OWASP Top 10 2025. Categoria Eșecuri în lanțul de aprovizionare software extinde A06:2021 anterior (Vulnerabil și Componente învechite) pentru a acoperi un domeniu mult mai larg: nu doar dependențe vulnerabil, dar întregul ecosistem de creare, distribuție și actualizare a software-ului.
În 2025, această categorie a înregistrat cea mai mare rată medie de incidență (5,19%) în toate categoriile atunci când sunt testate. De asemenea, a fost votată principala preocupare în sondajul comunității OWASP, raportând că experții în securitate consideră atacurile lanțului de aprovizionare ca amenințare cu cea mai rapidă creștere.
Tipuri de atac asupra lanțului de aprovizionare
Atacurile lanțului de aprovizionare software vin sub mai multe forme, fiecare cu diferite caracteristici și niveluri de sofisticare:
- Typosquatting: Pachete rău intenționate cu nume similare bibliotecilor populare (de ex.
lodahsîn loc delodash,expresîn loc deexpress) - Confuzie de dependență: se instalează un pachet public cu același nume ca unul intern în locul celui legitim
- Preluare cont: compromiterea conturilor de întreținere pentru a injecta cod rău intenționat în pachete legitime
- Construiți otrăvirea conductei: injectarea de cod rău intenționat în conducta CI/CD în timpul procesului de construire
- Slopsquatting: pachete care exploatează nume de dependențe inventate de AI (halucinații) ca ținte de atac
Accident real: septembrie 2025
În septembrie 2025, o campanie de phishing a compromis conturile de întreținere npm, rezultând în compromisul a cel puțin 27 de pachete cu miliarde de descărcări săptămânal. Un vierme cu auto-replicare numit Shai-Hulud a infectat peste 500 de pachete înainte de a fi neutralizat. Acest incident demonstrează cât de critică este protecția a lanțului de aprovizionare.
Apărări practice pentru lanțul de aprovizionare
# 1. Usa npm ci (non npm install) per rispettare il lockfile
npm ci
# 2. Audit delle vulnerabilità in CI/CD
npm audit --audit-level=high
# 3. Verifica le firme dei pacchetti (npm 9+)
npm audit signatures
# 4. Blocca i registry non autorizzati in .npmrc
registry=https://registry.npmjs.org/
@mycompany:registry=https://npm.mycompany.com/
# 5. Genera e verifica SBOM (Software Bill of Materials)
npx @cyclonedx/cyclonedx-npm --output-file sbom.json// package.json - usa versioni esatte, non range
{
"dependencies": {
"express": "4.21.2",
"helmet": "8.0.0",
"cors": "2.8.5"
},
"overrides": {
"vulnerable-transitive-dep": "2.1.0"
}
}Lista de verificare a lanțului de aprovizionare pentru proiecte angulare
- Fugi
npm auditîn fiecare conductă CI/CD cu prag de blocare - STATELE UNITE ALE AMERICII Dependabot o Renova pentru actualizări automate
- Activați 2FA pe toate conturile de întreținere npm
- Verificați sursa pachetelor înainte de a le instala (
npm info) - Generați a SBOM pentru fiecare lansare și monitorizați-o cu instrumente dedicate
- STATELE UNITE ALE AMERICII
npm ci(Nunpm install) în toate mediile automatizate - Configurați unul lista de permise a registrelor autorizate în
.npmrc
A04-A07: Prezentare generală a categoriilor confirmate
A04:2025 - Eșecuri criptografice
Scade de la #2 la #4, dar rămâne o vulnerabilitate critică. Se referă la protecția inadecvată a date sensibile: parole salvate în text clar sau cu hashuri slabe (MD5, SHA1), chei criptografice codificat în codul sursă, transmisie de date fără HTTPS și algoritmi de criptare învechiți.
import bcrypt from 'bcrypt';
import crypto from 'crypto';
// VULNERABILE: MD5 non e sicuro per le password
const insecureHash = crypto.createHash('md5').update(password).digest('hex');
// SICURO: bcrypt con salt rounds adeguato
const SALT_ROUNDS = 12;
const secureHash = await bcrypt.hash(password, SALT_ROUNDS);
// SICURO: verifica password senza timing attack
const isValid = await bcrypt.compare(inputPassword, storedHash);A05:2025 - Injecție
Injecțiile scad de la #3 la #5, semn că contramăsurile (ORM, interogări parametrizate, dezinfectant) s-au răspândit. Cu toate acestea, ele rămân periculoase. Include SQL Injection, NoSQL Injecție, injecție de comandă, injecție LDAP și XSS.
// VULNERABILE: concatenazione diretta
const query = `SELECT * FROM users WHERE email = '${userInput}'`;
// Input malevolo: ' OR '1'='1' --
// SICURO: query parametrizzate (PostgreSQL)
const result = await pool.query(
'SELECT * FROM users WHERE email = $1',
[userInput]
);
// SICURO: ORM con sanitizzazione automatica (TypeORM)
const user = await userRepository.findOneBy({
email: userInput // TypeORM sanitizza automaticamente
});A06:2025 - Design nesigur
Se referă la defecte ale proiecta a aplicației, nu în implementare. Absența modelării amenințărilor, nerespectarea principiului cel mai mic privilegiu și omiterea controalelor, cum ar fi limitarea ratei, sunt toate exemple de proiectare nesigură. The diferență cheie: un design sigur poate avea erori de implementare, dar un design nesigur nu poate fi remediat doar cu un cod mai bun.
A07:2025 - Eșecuri de autentificare
Eșecurile de autentificare includ: acceptarea parolelor slabe, sesiuni care nu expiră, jetoane JWT fără expirare sau cu secrete slabe și fără Multi-Factor Autentificare. Principala apărare este implementarea JWT cu expirare scurtă, jeton de reîmprospătare validarea sigură și riguroasă a acreditărilor.
A08-A09: Integritate și monitorizare
A08:2025 - Eșecuri de integritate software sau date
Această categorie se concentrează pe menținerea încrederii și pe verificarea integrității de software, cod și artefacte la un nivel mai granular decât aprovizionarea Lanț (A03). Include: conductă CI/CD fără verificare a integrității, actualizare automată fără validarea semnăturii, deserializarea datelor care nu sunt de încredere și absența Subresource Integrity (SRI) pentru resurse externe.
<!-- VULNERABILE: script esterno senza verifica -->
<script src="https://cdn.example.com/lib.js"></script>
<!-- SICURO: SRI verifica l'integrita del file -->
<script
src="https://cdn.example.com/lib.js"
integrity="sha384-oqVuAfXRKap7fdgcCY5uykM6+R9GqQ8K/ux..."
crossorigin="anonymous">
</script>A09:2025 - Eșecuri de înregistrare și alerte de securitate
Redenumită în 2025 cu adăugarea „Alertare” în locul „Monitorizare” pentru a sublinia importanța nu numai a înregistrării evenimentelor, ci și a generării alerte active când apar anomalii. Fără înregistrare structurată și alertă, o încălcare poate rămâne nedetectat de luni de zile.
import winston from 'winston';
const securityLogger = winston.createLogger({
level: 'info',
format: winston.format.combine(
winston.format.timestamp(),
winston.format.json()
),
defaultMeta: { service: 'auth-service' },
transports: [
new winston.transports.File({ filename: 'security.log' }),
]
});
// Eventi CRITICI da loggare e per cui generare alert
function logFailedLogin(email: string, ip: string): void {
securityLogger.warn({
event: 'FAILED_LOGIN',
email,
ip,
timestamp: new Date().toISOString(),
alert: true // Flag per il sistema di alerting
});
}
// REGOLA: 5 login falliti dallo stesso IP = alert immediato
// REGOLA: accesso admin da IP sconosciuto = alert immediato
// REGOLA: modifica permessi fuori orario = alert immediatoCe să înregistrezi (și ce să NU să înregistrezi)
- Jurnal: autentificări reușite/eșuate, acces refuzat (403), modificări ale datelor sensibile, acțiuni ale administratorului
- NU înregistrați: parole, jetoane, numere de card de credit, date personale complete
- Generează alerte pentru: modele de autentificare anormale, accesări din geolocații neobișnuite, vârfuri de eroare 4xx/5xx
A10:2025 - Gestionarea greșită a condițiilor excepționale (NOU)
A doua mare știre a anului 2025. Această categorie conține 24 CWE referitoare la gestionarea necorespunzătoare a erorilor, excepțiilor și condițiilor anormale. Conceptul cheia și „deschidere greșită”: când o aplicație se confruntă cu o eroare, alege să acorde acces sau să continue operațiunea în loc să o blocheze.
Condiții excepționale pot apărea din: intrare lipsă sau incompletă, stări de mediu evenimente neașteptate (memorie, rețea, permisiuni), gestionarea tardivă a erorilor la niveluri înalte în loc de unde apar și excepțiile nu sunt tratate deloc.
Cheie CWE în această categorie
- CWE-209: Mesaje de eroare care conțin informații sensibile
- CWE-234: Nerespectarea parametrilor lipsă
- CWE-274: Gestionarea necorespunzătoare a privilegiilor insuficiente
- CWE-476: Dereferința indicatorului nul
- CWE-636: „Failing Open” - nu da greș în siguranță
Exemplu: Fail-Open în Autentificare
// VULNERABILE: fail-open - in caso di errore l'utente passa
async function verifyToken(req: Request, res: Response, next: NextFunction) {
try {
const token = req.headers.authorization?.split(' ')[1];
const decoded = jwt.verify(token!, process.env.JWT_SECRET!);
req.user = decoded;
next();
} catch (error) {
// ERRORE CRITICO: in caso di eccezione, si prosegue comunque!
console.log('Token verification failed, continuing...');
next(); // L'utente non autenticato accede alle risorse protette
}
}
// SICURO: fail-closed - in caso di errore l'accesso e negato
async function verifyToken(req: Request, res: Response, next: NextFunction) {
try {
const token = req.headers.authorization?.split(' ')[1];
if (!token) {
return res.status(401).json({ error: 'Token mancante' });
}
const decoded = jwt.verify(token, process.env.JWT_SECRET!);
req.user = decoded;
next();
} catch (error) {
// CORRETTO: in caso di errore, si blocca l'accesso
return res.status(401).json({ error: 'Autenticazione fallita' });
}
}Exemplu: Scurgere de informații prin erori
// VULNERABILE: espone dettagli interni del sistema
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
res.status(500).json({
error: err.message,
stack: err.stack, // Rivela percorsi del file system
query: (err as any).sql, // Rivela struttura del database
config: (err as any).config // Potrebbe rivelare credenziali
});
});
// SICURO: messaggi generici in produzione, dettagli solo in sviluppo
const isProduction = process.env.NODE_ENV === 'production';
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
// Logga i dettagli internamente
securityLogger.error({
message: err.message,
stack: err.stack,
url: req.originalUrl,
method: req.method,
ip: req.ip
});
// Restituisci solo un messaggio generico al client
res.status(500).json({
error: isProduction
? 'Si e verificato un errore. Riprova più tardi.'
: err.message
});
});Exemplu: epuizarea resurselor din cauza gestionării incorecte
// VULNERABILE: il file handle non viene rilasciato in caso di errore
async function processUpload(filePath: string): Promise<void> {
const handle = await fs.open(filePath, 'r');
const data = await handle.readFile(); // Se fallisce, il handle resta aperto
await processData(data);
await handle.close();
}
// SICURO: pattern try/finally per garantire il rilascio delle risorse
async function processUpload(filePath: string): Promise<void> {
let handle: fs.FileHandle | null = null;
try {
handle = await fs.open(filePath, 'r');
const data = await handle.readFile();
await processData(data);
} catch (error) {
securityLogger.error({ event: 'UPLOAD_FAILED', filePath, error });
throw new AppError('Elaborazione file fallita', 500);
} finally {
if (handle) {
await handle.close(); // Sempre eseguito, anche in caso di errore
}
}
}Principiul fundamental: Fail-Closed
Ori de câte ori apare o excepție într-un context de securitate, sistemul trebuie refuza accesul în mod implicit (fail-closed), nu-l acordați niciodată (fail-deschide). Acest lucru se aplică pentru autentificare, autorizare, validare a intrărilor și oricăror decizii care afectează siguranța.
Focus: Securitatea codului generat de AI
Odată cu adoptarea masivă a instrumentelor de codare AI (Copilot, ChatGPT, Claude, Cursor), apare un nou risc: securitatea codului generat automat. Potrivit Raportul de securitate a codului GenAI Veracode 2025, care a analizat codul produs de peste 100 de LLM pe 80 de sarcini reale, rezultatele sunt îngrijorătoare.
Numerele securității AI
- 45% Mostrele de cod generate de AI nu eșuează testele de securitate și introduc primele 10 vulnerabilități OWASP
- 72% rata de eșec pentru codul Java generat de AI
- 38-45% a ratelor de eșec pentru Python, C# și JavaScript
- 86% rata de eșec specifică pentru Cross-Site Scripting (CWE-80)
- 88% rata de eșec specifică pentru Log Injection (CWE-117)
Problema nu se îmbunătățește
Modelele AI fac alegeri proaste aproximativ jumătate din timp în ceea ce privește securitatea, de ex acest lucru nu se îmbunătățește cu modelele mai mari. Problema este sistemică: modelele sunt antrenate pe cod public care conține adesea aceleași vulnerabilități pe care ar trebui să le evite. Codul generat de AI necesită întotdeauna o revizuire de securitate umană.
Lista de verificare de securitate pentru codul generat de AI
- Nu acceptați niciodată codul generat de AI fără el revizuirea codului de securitate
- Verificați dacă interogările bazei de date sunt parametrizat (fără concatenare)
- Verificați intrarea utilizatorului validate si igienizate în fiecare punct
- Asigurați-vă că secretele nu sunt hardcoded în codul generat
- Verificați gestionarea erorilor - trebuie să fie fail-închis, nu fail-deschide
- Verificați permisiunile și autorizarea: AI generează adesea cod fără controale de acces
- Fugi SAST (Testarea de securitate statică a aplicațiilor) automatizat pe tot codul generat de AI
Lista de verificare de securitate specifică unghiulară
Angular oferă multe protecții de securitate încorporate, dar este esențial să le cunoașteți nu le dezactivați din neatenție. Iată o listă de verificare specifică aplicațiilor Angular:
Protecție XSS integrată
import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
// Angular sanitizza automaticamente il binding nel template
// Le doppie graffe eseguono l'escape dell'HTML automaticamente
// PERICOLOSO: bypassare il sanitizer
@Component({
template: `<div [innerHTML]="trustedHtml"></div>`
})
export class UnsafeComponent {
trustedHtml: SafeHtml;
constructor(private sanitizer: DomSanitizer) {
// SOLO se il contenuto e completamente fidato e sotto il tuo controllo
this.trustedHtml = this.sanitizer.bypassSecurityTrustHtml(content);
}
}
// SICURO: lasciare che Angular sanitizzi automaticamente
@Component({
template: `<div [textContent]="userContent"></div>`
})
export class SafeComponent {
userContent = ''; // Angular esegue l'escape automaticamente
}HttpClient și Security Interceptor
import { HttpInterceptorFn, HttpErrorResponse } from '@angular/common/http';
import { inject } from '@angular/core';
import { Router } from '@angular/router';
import { catchError, throwError } from 'rxjs';
export const authInterceptor: HttpInterceptorFn = (req, next) => {
const router = inject(Router);
const token = getStoredToken(); // Da un servizio sicuro
// Aggiungi il token solo alle richieste verso la tua API
const secureReq = req.url.startsWith('/api')
? req.clone({
setHeaders: { Authorization: `Bearer ${token}` }
})
: req;
return next(secureReq).pipe(
catchError((error: HttpErrorResponse) => {
if (error.status === 401) {
// Token scaduto o invalido: redirect al login
router.navigate(['/login']);
}
// Non esporre dettagli dell'errore nell'interfaccia
return throwError(() => new Error('Richiesta fallita'));
})
);
};Route Guard cu API funcțional
import { CanActivateFn, Router } from '@angular/router';
import { inject } from '@angular/core';
export const authGuard: CanActivateFn = (route, state) => {
const authService = inject(AuthService);
const router = inject(Router);
if (!authService.isAuthenticated()) {
// Redirect al login con URL di ritorno
router.navigate(['/login'], {
queryParams: { returnUrl: state.url }
});
return false;
}
// Verifica ruolo se richiesto dalla rotta
const requiredRole = route.data?.['role'];
if (requiredRole && !authService.hasRole(requiredRole)) {
router.navigate(['/unauthorized']);
return false;
}
return true;
};Politica de securitate a conținutului pentru Angular
Content-Security-Policy:
default-src 'self';
script-src 'self' 'nonce-RANDOM_VALUE';
style-src 'self' 'unsafe-inline' https://fonts.googleapis.com;
font-src 'self' https://fonts.gstatic.com;
img-src 'self' data: https:;
connect-src 'self' https://api.tuodominio.com;
frame-ancestors 'none';
base-uri 'self';
form-action 'self';Lista de verificare finală unghiulară
- Nu utilizați
bypassSecurityTrustHtmlcu conținut de utilizator - STATELE UNITE ALE AMERICII
HttpClientcu token interceptor și management centralizat al erorilor - Implementează Garzi de traseu funcționali pentru toate rutele protejate
- Configurați unul CSP restrictiv pe serverul care deservește aplicația Angular
- Nu depozitați jetoanele JWT
localStorage: preferă cookie-urileHttpOnly - Valabil întotdeauna partea serverului: Protecțiile unghiulare protejează doar interfața de utilizare, nu API-ul
- Folosește steagul
--subresource-integrityinng buildpentru a genera hash-uri SRI - Păstrați Angular actualizat: Fiecare versiune include corecții de securitate
Concluzii și plan de acțiune
Topul 2025 OWASP reflectă un peisaj de amenințări care evoluează rapid. Cele două noi categoriile, Eșecurile lanțului de aprovizionare și manipularea greșită a condițiilor excepționale, nu sunt adăugate academice: reprezintă amenințări concrete care afectează zilnic aplicații reale. The Urcarea pe locul doi a configurării greșite de securitate confirmă faptul că complexitatea Infrastructura modernă creează suprafețe de atac din ce în ce mai mari.
Planul de acțiune al dezvoltatorului
Iată o cale practică în trei pași pentru a vă îmbunătăți postura de siguranță aplicatii:
- Săptămâna 1 - Fundamente: Implementați controale de acces la toate API-urile (A01), configurați anteturile de securitate cu Casca (A02) și activați
npm auditîn curs de dezvoltare CI/CD (A03) - Săptămâna 2 - Protecția datelor: Migrați la bcrypt/argon2 pentru parole (A04), asigurați-vă că toate interogările sunt parametrizate (A05) și implementați limitarea ratei (A06)
- Săptămâna 3 - Monitorizare: Configurați înregistrarea structurată cu alertă (A09), examinați toate blocurile de captură pentru a elimina deschiderea eșuată (A10) și generați un SBOM de dependență (A03)
Următoarele articole din serie
În articolele viitoare vom aprofunda mai mult în domeniile individuale ale securității web cu ghiduri practice si codul complet:
- Articolul 02: XSS și CSRF - Atacurile încrucișate și cum să le preveniți în Angular
- Articolul 03: SQL Injection și NoSQL Injection - Aprofundare cu Node.js și MongoDB
- Articolul 04: Autentificare sigură - JWT, OAuth2 și sesiuni
Securitatea aplicației web nu este un punct de control care trebuie trecut o singură dată: este un proces continuu care trebuie integrate în fiecare fază de dezvoltare, de la proiectare la producție. În calitate de dezvoltatori, avem responsabilitatea de a scrie cod sigur în mod implicit. Top 10 vulnerabilități OWASP reprezintă minimul strict a sti. Costul prevenirii unei vulnerabilități este întotdeauna mai mic decât costul suferi consecințele.