01 – OWASP Top 10 2025: Průvodce pro vývojáře
Každý řádek kódu, který napíšeme, s sebou nese implicitní odpovědnost: chránit data a uživatelská důvěra. V roce 2025 se stále složitějšími aplikacemi, architekturami distribuované a rostoucí zavádění nástrojů pro automatické generování kódu, Bezpečnost již nemůže být dodatečným nápadem. Tam OWASP Top 10 2025 představuje aktualizované reference deseti nejkritičtějších zranitelností ve webových aplikacích a všech vývojář by to měl vědět důkladně.
Tato příručka analyzuje všech deset kategorií nového seznamu se zvláštním zaměřením dvě nové kategorie představené v roce 2025: Selhání softwarového dodavatelského řetězce (A03) e Nesprávné zacházení s výjimečnými podmínkami (A10). Pro každou zranitelnost najdete jasné vysvětlení, zranitelný a bezpečný kód v TypeScript/Node.js a konkrétní doporučené postupy pro Angular.
Co se naučíte
- Všech 10 kategorií OWASP 2025, včetně 2 nových
- Hlavní rozdíly oproti verzi 2021
- Příklady zranitelného kódu a souvisejících protiopatření
- Jak zabezpečit npm závislosti dodavatelského řetězce
- proč 45 % kódu generovaného umělou inteligencí neprojde bezpečnostními testy
- Kontrolní seznam specifický pro Angular pro zabezpečení vašich aplikací
Co je OWASP a jak se zrodilo Top 10
La Open Worldwide Application Security Project (OWASP) a nadace nezisková organizace založená v roce 2001 s cílem zlepšit softwarovou bezpečnost na globální úrovni globální. Jeho nejznámějším projektem je OWASP Top 10: dokument o aktualizovaný odkaz obsahující deset nejkritičtějších zranitelností webových aplikací pravidelně založené na skutečných datech shromážděných od stovek organizací.
Seznam je sestaven na základě analýzy milionů aplikací a stovek tisíc zranitelnost. Proces se kombinuje empirická data (skutečné nehody, zprávy od zabezpečení, automatizovaná analýza) s a komunitní průzkum která sbírá obavy bezpečnostních expertů z nově se objevujících hrozeb. Mapa každé kategorie jeden nebo více CWE (Common Weakness Enumeration)nebo standardní klasifikace softwarových slabin.
Předchozí verze
OWASP Top 10 má několik vydání: 2004, 2007, 2010, 2013, 2017, 2021 a nyní 2025. Každá aktualizace odráží vývoj hrozeb. V roce 2017 byly na prvním místě Injekce místo; v roce 2021 je překonal Broken Access Control. V roce 2025 vidíme změny ještě výraznější, se vstupem dvou zcela nových kategorií, které reflektují moderní výzvy vývoje softwaru.
Co je nového v OWASP Top 10 2025
Vydání 2025 přináší důležité změny oproti roku 2021. Zde je kompletní seznam s změny pozice:
| Pozice | OWASP 2025 | Změna od roku 2021 |
|---|---|---|
| A01 | Rozbité řízení přístupu | Potvrzeno u #1 (bylo A01:2021). Nyní zahrnuje SSRF |
| A02 | Chybná konfigurace zabezpečení | Zvýší se z #5 na #2 |
| A03 | Selhání softwarového dodavatelského řetězce | NOVINKA – rozšiřuje A06:2021 (zranitelné součásti) |
| A04 | Kryptografická selhání | Klesá z #2 na #4 |
| A05 | Injekce | Klesá z #3 na #5 |
| A06 | Nezabezpečený design | Klesá z #4 na #6 |
| A07 | Selhání ověření | Potvrzeno na čísle 7 |
| A08 | Selhání integrity softwaru nebo dat | Potvrzeno na čísle 8 |
| A09 | Bezpečnostní protokolování a selhání výstrah | Potvrzeno na #9 (přejmenováno: "Upozornění" místo "Monitorování") |
| A10 | Špatné zacházení s výjimečnými podmínkami | NOVINKA - nahrazuje SSRF (nyní začleněno do A01) |
Dvě klíčové změny
A03: Selhání softwarového dodavatelského řetězce - Útoky na dodavatelský řetězec softwaru v posledních letech explodovaly. Tato kategorie byla zvolena největší zájem v komunitním průzkumu OWASP. Pokrývá překlepy, zmatek v závislosti, škodlivé pakety a kompromitované kanály CI/CD.
A10: Nesprávné zacházení s výjimečnými podmínkami - Nesprávné řízení chyby a výjimky a nyní jsou uznávány jako autonomní vektor útoku. Zahrnuje 24 CWE související s nedostatečným zpracováním chyb, otevřením při selhání a úniky citlivých informací prostřednictvím chybových zpráv.
A01:2025 – Nefunkční kontrola přístupu
Il Rozbité řízení přístupu zůstává již čtvrtým rokem pevně na prvním místě po sobě jdoucí. Vyskytuje se, když je uživatel schopen přistupovat ke zdrojům nebo provádět akce ke kterému nemá oprávnění. Mezi nejčastější formy patří: IDOR (Nezabezpečený přímý odkaz na objekt), průchod cesty, ovládací bypass role a manipulace s tokeny nebo parametry URL.
V roce 2025 má tato kategorie začlenil SSRF (Padělání požadavku na straně serveru), který ve verzi 2021 obsadil pozici A10. Logika je taková, že SSRF představuje v podstatě selhání řízení přístupu: server odesílá požadavky zdrojů, kam by se nemělo dostat.
Příklad: IDOR (Nezabezpečený přímý objektový odkaz)
// 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);
});Příklad: Traverzování
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);
});Úhlové ochrany pro kontrolu zlomeného přístupu
- Nářadí Traťové stráže (
canActivate,canMatch) k ochraně vyhrazených cest - Použijte a HTTP Interceptor k automatickému připojení tokenu JWT ke každému požadavku
- Skrýt prvky uživatelského rozhraní na základě oprávnění, ale vždy platné na straně serveru
- Nikdy nevkládejte role nebo oprávnění do localStorage bez kontroly na straně backendu
- Centralizujte autorizační logiku do jednoho AuthService opakovaně použitelné
A02:2025 – Chybná konfigurace zabezpečení
Le Chybná konfigurace zabezpečení stoupají z #5 na #2 v roce 2025. Tento skok odráží skutečný fakt: s rostoucí složitostí konfigurací (cloud, kontejnery, mikroslužby, CDN), chyby konfigurace se staly jednou z nejčastějších příčin porušení.
Tato kategorie zahrnuje: nezměněné výchozí konfigurace, zabezpečené HTTP hlavičky chybí, CORS je příliš tolerantní, stopy zásobníku odhaleny ve výrobě, porty a služby ne potřebné vystavené a funkce ladění ponechány aktivní.
Bezpečnostní hlavička a 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
}));Běžné chyby konfigurace
Access-Control-Allow-Origin: *ve výrobě- Trasování celého zásobníku viditelné v chybových odpovědích
- Výchozí přihlašovací údaje se nezměnily (admin/admin)
- Ladicí porty (9229 pro Node.js) vystavené ve výrobě
- Soubor
.envveřejně přístupný - Výpis adresářů povolen na webovém serveru
A03:2025 – Selhání softwarového dodavatelského řetězce (NOVINKA)
Toto je jedna z nejdůležitějších nových funkcí OWASP Top 10 2025. Kategorie Selhání softwarového dodavatelského řetězce rozšiřuje předchozí A06:2021 (zranitelné a zastaralé komponenty), aby pokryl mnohem širší rozsah: nejen závislosti zranitelný, ale celý ekosystém vytváření, distribuce a aktualizace softwaru.
V roce 2025 tato kategorie zaznamenala nejvyšší průměrnou incidenci (5,19 %) ve všech kategoriích při testování. To bylo také zvoleno za hlavní zájem v komunitním průzkumu OWASP, který uvádí, že bezpečnostní experti uvažují útoky na dodavatelský řetězec jako nejrychleji rostoucí hrozba.
Typy útoků na dodavatelský řetězec
Útoky softwarového dodavatelského řetězce mají mnoho forem, z nichž každý má různé vlastnosti a úrovně propracovanosti:
- překlepy: Škodlivé balíčky s názvy podobnými populárním knihovnám (např.
lodahsmístolodash,expresmístoexpress) - Zmatek v závislosti: namísto legitimního je nainstalován veřejný balíček se stejným názvem jako interní
- Převzetí účtu: kompromitující účty správců za účelem vložení škodlivého kódu do legitimních balíčků
- Otrava sestavení potrubí: vložení škodlivého kódu do kanálu CI/CD během procesu sestavování
- Slopsquatting: balíčky, které využívají názvy závislostí vynalezené AI (halucinace) jako cíle útoku
Skutečná nehoda: září 2025
V září 2025 phishingová kampaň kompromitovala účty správců npm, což vedlo ke kompromisu nejméně 27 balíčků s miliardami stažení týdně. Samoreplikující se červ jménem Shai-Hulud infikoval přes 500 balíčků před neutralizací. Tento incident ukazuje, jak kritická je ochrana dodavatelského řetězce.
Praktická obrana pro dodavatelský řetězec
# 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"
}
}Kontrolní seznam dodavatelského řetězce pro úhlové projekty
- Běh
npm auditv každém potrubí CI/CD s prahovou hodnotou blokování - USA Dependabot o Renovovat pro automatické aktualizace
- Aktivujte 2FA na všech účtech správce npm
- Před instalací balíčků zkontrolujte jejich zdroj (
npm info) - Vygenerovat a SBOM pro každé vydání a sledujte jej pomocí vyhrazených nástrojů
- USA
npm ci(Nenpm install) ve všech automatizovaných prostředích - Nakonfigurujte jeden seznam povolených autorizovaných registrů v
.npmrc
A04-A07: Přehled potvrzených kategorií
A04:2025 - Kryptografické chyby
Klesá z #2 na #4, ale zůstává kritickou zranitelností. Týká se to nedostatečné ochrany citlivá data: hesla uložená jako prostý text nebo se slabými hashemi (MD5, SHA1), kryptografické klíče pevně zakódované ve zdrojovém kódu, přenos dat bez HTTPS a zastaralé šifrovací algoritmy.
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 - Injekce
Injekce klesnou z #3 na #5, což je znamení, že protiopatření (ORM, parametrizované dotazy, dezinfekční prostředek) se rozšířily. Zůstávají však nebezpeční. Zahrnuje SQL Injection, NoSQL Injection, Command Injection, LDAP Injection a 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 – Nezabezpečený design
Týká se závad v design aplikace, nikoli v implementaci. Absence modelování hrozeb, nerespektování zásady nejmenšího privilegia a vynechání ovládacích prvků, jako je omezení rychlosti, jsou příklady nejistého návrhu. The klíčový rozdíl: bezpečný design může mít chyby v implementaci, ale nezabezpečený design nelze to opravit pouze pomocí lepšího kódu.
A07:2025 – Selhání ověření
Mezi selhání autentizace patří: přijímání slabých hesel, relace, které nevyprší, tokeny JWT bez expirace nebo se slabými tajemstvími a žádný multifaktor Autentizace. Hlavní obranou je implementace JWT s krátkou expirací, obnovovacím tokenem bezpečné a přísné ověřování přihlašovacích údajů.
A08-A09: Integrita a monitorování
A08:2025 – Selhání integrity softwaru nebo dat
Tato kategorie se zaměřuje na udržování důvěry a ověřování integrity softwaru, kódu a artefaktů na podrobnější úrovni než nabídka Řetěz (A03). Obsahuje: potrubí CI/CD bez kontroly integrity, automatické aktualizace bez ověření podpisu, deserializace nedůvěryhodných dat a absence Subresource Integrity (SRI) pro externí zdroje.
<!-- 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 – Selhání bezpečnostního protokolování a výstrah
Přejmenováno v roce 2025 s přidáním „Výstrahy“ namísto „Monitorování“, aby bylo zdůrazněno důležitost nejen zaznamenávání událostí, ale i generování aktivní výstrahy když se objeví anomálie. Bez strukturovaného protokolování a upozornění může narušení zůstat měsíce nezjištěno.
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 immediatoCo logovat (a co NELOGOVAT)
- Protokol: úspěšné/neúspěšné přihlášení, odepřený přístup (403), změny citlivých údajů, akce správce
- NEPROHLÁŠUJTE: hesla, tokeny, čísla kreditních karet, kompletní osobní údaje
- Generuje upozornění na: anomální přihlašovací vzory, přístupy z neobvyklých geolokací, 4xx/5xx špičky chyb
A10:2025 – Nesprávné zacházení s výjimečnými podmínkami (NOVINKA)
Druhá velká novinka roku 2025. Tato kategorie obsahuje 24 CWE týkající se nesprávného zacházení s chybami, výjimkami a anomálními podmínkami. Koncept klíč a "fail-open": když aplikace čelí chybě, se rozhodne udělit přístup nebo pokračovat v operaci místo jejího zablokování.
Výjimečné podmínky mohou vzniknout z: chybějícího nebo neúplného vstupu, stavu prostředí neočekávané události (paměť, síť, oprávnění), pozdní zpracování chyb na vysokých úrovních kde se vyskytují, a výjimky, které se vůbec nezpracovávají.
Klíč CWE v této kategorii
- CWE-209: Chybové zprávy, které obsahují citlivé informace
- CWE-234: Selhání zpracování chybějících parametrů
- CWE-274: Nesprávná správa nedostatečných oprávnění
- CWE-476: Dereference nulového ukazatele
- CWE-636: "Failing Open" - neselžou bezpečně
Příklad: Fail-Open in Authentication
// 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' });
}
}Příklad: Únik informací prostřednictvím chyb
// 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
});
});Příklad: Vyčerpání zdrojů z nesprávného řízení
// 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
}
}
}Základní princip: Fail-Closed
Kdykoli dojde v kontextu zabezpečení k výjimce, systém musí ve výchozím nastavení zakázat přístup (fail-closed), nikdy to neudělujte (fail-open). To se týká autentizace, autorizace, ověřování vstupu a jakýchkoli rozhodnutí která ovlivňuje bezpečnost.
Zaměření: Bezpečnost kódu generovaného umělou inteligencí
Díky masivnímu přijetí nástrojů pro kódování AI (Copilot, ChatGPT, Claude, Cursor) objevuje se nové riziko: bezpečnost automaticky generovaného kódu. Podle Zpráva o zabezpečení kódu GenAI společnosti Veracode 2025, který kód analyzoval produkované více než 100 LLM na 80 skutečných úkolech, výsledky jsou znepokojivé.
Čísla bezpečnosti AI
- 45 % Ukázky kódu generované umělou inteligencí neprojdou bezpečnostními testy a představují 10 hlavních zranitelností OWASP
- 72 % míra selhání kódu Java generovaného umělou inteligencí
- 38–45 % míry selhání pro Python, C# a JavaScript
- 86 % specifická míra selhání pro Cross-Site Scripting (CWE-80)
- 88 % specifická míra selhání pro Log Injection (CWE-117)
Problém se nezlepšuje
Modely AI dělají špatná rozhodnutí zhruba v polovině případů, pokud jde o bezpečnost, např u větších modelů se to nezlepšuje. Problém je systémové: modely jsou trénovány na veřejném kódu, který často obsahuje stejné zranitelnosti kterému by se měli vyhnout. Kód generovaný AI vždy vyžaduje bezpečnostní kontrolu člověk.
Kontrolní seznam zabezpečení pro kód vygenerovaný AI
- Bez něj nikdy nepřijímejte kód vygenerovaný AI kontrola bezpečnostního kódu
- Ověřte, zda jsou databázové dotazy parametrizované (žádné zřetězení)
- Zkontrolujte, zda je uživatelský vstup ověřeno a dezinfikováno v každém bodě
- Ujistěte se, že tajemství nejsou pevně zakódované ve vygenerovaném kódu
- Zkontrolujte zpracování chyb - musí být selhání-zavřeno, neotevřené při selhání
- Kontrola oprávnění a autorizace: AI často generuje kód bez řízení přístupu
- Běh SAST (Statické testování zabezpečení aplikací) automatizované na všech kódech generovaných AI
Kontrolní seznam úhlového zabezpečení
Angular nabízí mnoho vestavěných bezpečnostních ochran, ale je nezbytné je znát nedeaktivujte je nechtěně. Zde je kontrolní seznam specifický pro aplikace Angular:
Integrovaná XSS ochrana
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 a 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 s funkčním API
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;
};Zásady zabezpečení obsahu pro 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';Úhlový konečný kontrolní seznam
- Nepoužívejte
bypassSecurityTrustHtmls uživatelským obsahem - USA
HttpClients token interceptor a centralizovanou správou chyb - Nářadí Funkční hlídače pro všechny chráněné cesty
- Nakonfigurujte jeden Omezující CSP na serveru obsluhujícím aplikaci Angular
- Neukládejte tokeny JWT
localStorage: preferuji cookiesHttpOnly - Platný vždy na straně serveru: Úhlové kryty chrání pouze uživatelské rozhraní, nikoli API
- Použijte vlajku
--subresource-integrityinng buildpro generování SRI hash - Udržujte Angular aktualizovaný: Každá verze obsahuje bezpečnostní záplaty
Závěry a akční plán
Top 10 OWASP 2025 odráží rychle se vyvíjející prostředí hrozeb. Ty dvě nové kategorie, Selhání dodavatelského řetězce a Špatné zacházení s výjimečnými podmínkami, se nepřidávají akademické: představují konkrétní hrozby, které každý den ovlivňují skutečné aplikace. The Vzestup chybné konfigurace zabezpečení na druhé místo potvrzuje, že složitost Moderní infrastruktura vytváří stále větší útočné plochy.
Akční plán pro vývojáře
Zde je praktická cesta ve třech krocích ke zlepšení vaší bezpečné pozice aplikace:
- 1. týden – základy: Implementujte řízení přístupu na všechna rozhraní API (A01), nakonfigurujte záhlaví zabezpečení pomocí Helmet (A02) a povolte
npm auditv potrubí CI/CD (A03) - 2. týden – Ochrana údajů: Přejděte na bcrypt/argon2 pro hesla (A04), ujistěte se, že všechny dotazy jsou parametrizované (A05) a implementujte omezení rychlosti (A06)
- 3. týden – Monitorování: Nakonfigurujte strukturované protokolování s upozorněním (A09), zkontrolujte všechny bloky zachycení, abyste eliminovali otevření při selhání (A10) a vygenerujte SBOM závislosti (A03)
Další články v seriálu
V dalších článcích se budeme hlouběji zabývat jednotlivými oblastmi webové bezpečnosti s praktickými návody a kompletní kód:
- Článek 02: XSS a CSRF – Útoky napříč weby a jak jim předcházet v Angular
- Článek 03: SQL Injection a NoSQL Injection – Hluboký ponor s Node.js a MongoDB
- Článek 04: Zabezpečené ověřování – JWT, OAuth2 a relace
Zabezpečení webových aplikací není kontrolním bodem, který lze předat pouze jednou: je to a nepřetržitý proces které musí být začleněny do každé fáze vývoje, od návrhu až po výrobu. Jako vývojáři máme odpovědnost za psaní kódu ve výchozím nastavení bezpečné. Top 10 zranitelností OWASP představuje naprosté minimum vědět. Náklady na prevenci zranitelnosti jsou vždy nižší než náklady na zranitelnost nést následky.