Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React
Kompleksowe praktyki bezpieczeństwa w React
W tej lekcji6
Wystarczy jedno pole komentarza bez kontroli, by obcy sygnał przejął stery: atakujący wkleja HTML ze skryptem, a przeglądarka każdego pasażera ten skrypt wykonuje. Bezpieczeństwo aplikacji React to kilka warstw osłon, od escapowania w JSX, przez tokeny i zależności, po zasady OWASP Top 10.
1. Cross-Site Scripting (XSS)
XSS polega na wstrzyknięciu skryptu, który wykona się w przeglądarce ofiary. React domyślnie escapuje każdą wartość w nawiasach klamrowych JSX, zamieniając znaki specjalne HTML na bezpieczne encje:
// React automatycznie escapuje te wartości
function UserProfile({ userData }) {
return (
<div>
{/* Bezpieczne - React escapuje zawartość */}
<h1>{userData.name}</h1>
<p>{userData.description}</p>
{/* NIEBEZPIECZNE - omija escapowanie */}
<div dangerouslySetInnerHTML={{ __html: userData.bio }} />
</div>
);
}{userData.name} wyświetli się jako tekst, nawet jeśli ktoś wpisze tam tag <script>. Wyjątkiem jest dangerouslySetInnerHTML, które wstawia surowy HTML i omija tę ochronę.
Sanityzacja z DOMPurify
Gdy musisz pokazać HTML z niezaufanego źródła, na przykład treść z edytora tekstu, najpierw przepuść go przez DOMPurify:
// Bezpieczne komponenty z walidacją
function SafeHTMLRenderer({ content, allowedTags = [] }) {
// Biblioteka DOMPurify do oczyszczania HTML
const cleanHTML = DOMPurify.sanitize(content, {
ALLOWED_TAGS: allowedTags,
ALLOWED_ATTR: ['href', 'title', 'alt', 'src'],
ALLOW_DATA_ATTR: false
});
return (
<div dangerouslySetInnerHTML={{ __html: cleanHTML }} />
);
}
// Walidacja URL-i
function SafeLink({ href, children, ...props }) {
const isValidURL = (url) => {
try {
const urlObj = new URL(url);
// Zezwalaj tylko na bezpieczne protokoły
return ['http:', 'https:', 'mailto:'].includes(urlObj.protocol);
} catch {
return false;
}
};
if (!isValidURL(href)) {
console.warn('Niebezpieczny URL zablokowany:', href);
return <span>{children}</span>;
}
return (
<a
href={href}
{...props}
rel="noopener noreferrer" // Zabezpieczenie przed tabnabbing
>
{children}
</a>
);
}
// Bezpieczne renderowanie obrazów
function SafeImage({ src, alt, ...props }) {
const [imageSrc, setImageSrc] = useState(null);
const [error, setError] = useState(false);
useEffect(() => {
// Walidacja źródła obrazu
if (src && typeof src === 'string') {
try {
const url = new URL(src);
if (['http:', 'https:', 'data:'].includes(url.protocol)) {
setImageSrc(src);
} else {
setError(true);
}
} catch {
setError(true);
}
}
}, [src]);
if (error) {
return <div className="image-error">Nieprawidłowe źródło obrazu</div>;
}
return imageSrc ? (
<img
src={imageSrc}
alt={alt}
{...props}
onError={() => setError(true)}
/>
) : null;
}Zasada brzmi: dangerouslySetInnerHTML={{ __html: DOMPurify.sanitize(rawHtml) }}, nigdy surowy HTML. Zwykłego tekstu z pól formularza nie musisz sanityzować, bo React i tak go escapuje. SafeLink przepuszcza tylko protokoły http:, https: i mailto:, a SafeImage sprawdza źródło obrazka.
Content Security Policy
Druga osłona działa w przeglądarce: nagłówek Content Security Policy mówi, skąd wolno ładować skrypty, style i obrazy:
// Konfiguracja nagłówka CSP
const cspConfig = {
'default-src': ["'self'"],
'script-src': [
"'self'",
"'unsafe-inline'", // Tylko w development
'https://apis.google.com',
'https://cdn.jsdelivr.net'
],
'style-src': [
"'self'",
"'unsafe-inline'", // Dla CSS-in-JS
'https://fonts.googleapis.com'
],
'img-src': [
"'self'",
'data:',
'https:',
'blob:'
],
'font-src': [
"'self'",
'https://fonts.gstatic.com'
],
'connect-src': [
"'self'",
'https://api.example.com',
'wss://socket.example.com'
],
'frame-ancestors': ["'none'"],
'form-action': ["'self'"],
'upgrade-insecure-requests': []
};
// Konfiguracja CSP w Next.js
// next.config.js
const securityHeaders = [
{
key: 'Content-Security-Policy',
value: Object.entries(cspConfig)
.map(([directive, sources]) =>
`${directive} ${sources.join(' ')}`
)
.join('; ')
},
{
key: 'X-Frame-Options',
value: 'DENY'
},
{
key: 'X-Content-Type-Options',
value: 'nosniff'
},
{
key: 'Referrer-Policy',
value: 'strict-origin-when-cross-origin'
},
{
key: 'Permissions-Policy',
value: 'camera=(), microphone=(), geolocation=()'
}
];
module.exports = {
async headers() {
return [
{
source: '/(.*)',
headers: securityHeaders
}
];
}
};cspConfig zamienia się w jeden nagłówek, a headers() w next.config.js dokłada go do każdej odpowiedzi. 'unsafe-inline' w script-src wyłącza dużą część ochrony, więc trzymaj go tylko w środowisku deweloperskim.
2. JWT Security
Token JWT to przepustka na pokład, więc jego kradzież oznacza przejęcie konta. SecureTokenManager pokazuje dwa sposoby przechowywania, a useAuth co 5 minut sprawdza ważność tokenu:
// Bezpieczne przechowywanie i obsługa JWT
class SecureTokenManager {
constructor() {
this.tokenKey = 'auth_token';
this.refreshTokenKey = 'refresh_token';
}
// Przechowywanie w httpOnly cookies (najlepsze)
setTokens(accessToken, refreshToken) {
// Wysyłanie na backend do ustawienia httpOnly cookies
fetch('/api/auth/set-tokens', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ accessToken, refreshToken })
});
}
// Alternatywnie - sessionStorage (mniej bezpieczne)
setTokensInStorage(accessToken, refreshToken) {
// NIGDY nie używaj localStorage dla tokenów!
sessionStorage.setItem(this.tokenKey, accessToken);
if (refreshToken) {
// Refresh token w bezpiecznym miejscu
this.storeRefreshTokenSecurely(refreshToken);
}
}
getToken() {
return sessionStorage.getItem(this.tokenKey);
}
removeTokens() {
sessionStorage.removeItem(this.tokenKey);
sessionStorage.removeItem(this.refreshTokenKey);
// Wyloguj także z cookies
fetch('/api/auth/logout', { method: 'POST' });
}
// Walidacja tokenu
isTokenValid(token) {
if (!token) return false;
try {
// JWT koduje payload w base64url, a atob() oczekuje zwykłego base64
const base64 = token.split('.')[1].replace(/-/g, '+').replace(/_/g, '/');
const payload = JSON.parse(atob(base64));
const now = Date.now() / 1000;
// Sprawdź czy token nie wygasł
return payload.exp > now;
} catch {
return false;
}
}
// Automatyczne odświeżanie tokenu
async refreshTokenIfNeeded() {
const token = this.getToken();
if (!token || !this.isTokenValid(token)) {
return await this.refreshToken();
}
return token;
}
async refreshToken() {
try {
const response = await fetch('/api/auth/refresh', {
method: 'POST',
credentials: 'include' // Dla httpOnly cookies
});
if (response.ok) {
const { accessToken } = await response.json();
sessionStorage.setItem(this.tokenKey, accessToken);
return accessToken;
}
} catch (error) {
console.error('Token refresh failed:', error);
this.removeTokens();
}
return null;
}
}
// Hook dla autoryzacji
function useAuth() {
const [user, setUser] = useState(null);
const [loading, setLoading] = useState(true);
const tokenManager = useRef(new SecureTokenManager());
const login = async (credentials) => {
try {
const response = await fetch('/api/auth/login', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(credentials)
});
if (response.ok) {
const { user, accessToken, refreshToken } = await response.json();
// Bezpieczne przechowywanie tokenów
tokenManager.current.setTokens(accessToken, refreshToken);
setUser(user);
return { success: true };
}
} catch (error) {
return { success: false, error: error.message };
}
};
const logout = () => {
tokenManager.current.removeTokens();
setUser(null);
};
// Automatyczne odświeżanie tokenu
useEffect(() => {
const interval = setInterval(async () => {
await tokenManager.current.refreshTokenIfNeeded();
}, 5 * 60 * 1000); // Co 5 minut
return () => clearInterval(interval);
}, []);
return { user, login, logout, loading };
}Najbezpieczniejsze jest ciasteczko httpOnly, którego JavaScript nie odczyta, najlepiej ustawione przez serwer już przy logowaniu. sessionStorage znika po zamknięciu karty, ale przed XSS chroni tak słabo jak localStorage, bo oba odczyta każdy skrypt z tej domeny. isTokenValid sprawdza tylko datę wygaśnięcia, a podpis weryfikuje wyłącznie serwer.
Interceptory Axios
Interceptory dokładają nagłówki do każdego żądania i ponawiają je po odświeżeniu tokenu:
// Bezpieczna konfiguracja Axios
const createSecureAxiosInstance = () => {
const tokenManager = new SecureTokenManager();
const axiosInstance = axios.create({
baseURL: process.env.REACT_APP_API_URL,
timeout: 10000,
withCredentials: true // Dla httpOnly cookies
});
// Interceptor żądań
axiosInstance.interceptors.request.use(
async (config) => {
const token = await tokenManager.refreshTokenIfNeeded();
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
// Dodaj CSRF token jeśli dostępny
const csrfToken = document.querySelector('meta[name="csrf-token"]')?.content;
if (csrfToken) {
config.headers['X-CSRF-Token'] = csrfToken;
}
return config;
},
(error) => Promise.reject(error)
);
// Interceptor odpowiedzi
axiosInstance.interceptors.response.use(
(response) => response,
async (error) => {
const originalRequest = error.config;
if (error.response?.status === 401 && !originalRequest._retry) {
originalRequest._retry = true;
const newToken = await tokenManager.refreshToken();
if (newToken) {
originalRequest.headers.Authorization = `Bearer ${newToken}`;
return axiosInstance(originalRequest);
} else {
// Przekieruj do logowania
window.location.href = '/login';
}
}
return Promise.reject(error);
}
);
return axiosInstance;
};Przy statusie 401 interceptor odświeża token i powtarza żądanie tylko raz, czego pilnuje flaga _retry. Nagłówek X-CSRF-Token broni przed CSRF, czyli atakiem, w którym obca strona wysyła żądanie z ciasteczkami ofiary. Taki token musi pochodzić z kryptograficznie bezpiecznego generatora, jak crypto.getRandomValues(), nigdy z Math.random(), a serwer porównuje go z wartością z sesji.
3. Zmienne środowiskowe
Plik .env.example pokazuje zespołowi, jakich zmiennych potrzebuje projekt, bez prawdziwych wartości:
# .env.example - szablon dla zespołu, bez prawdziwych wartości
# Sekrety, jak API_SECRET_KEY czy DATABASE_URL, nie trafiają do tego pliku
# ani do zmiennych z prefiksem REACT_APP_, bo te zobaczy przeglądarka
REACT_APP_API_URL=https://api.example.com
REACT_APP_ENVIRONMENT=development
REACT_APP_SENTRY_DSN=your_sentry_dsn_hereWszystko z prefiksem REACT_APP_ trafia do paczki JavaScript, więc przeczyta to każdy użytkownik, a sekrety zostają na serwerze. Prefiks pochodzi z Create React App, które zespół React wycofał w 2025 roku. W Vite odpowiednikiem jest VITE_, w Next.js NEXT_PUBLIC_, a zasada pozostaje ta sama.
EnvironmentValidator sprawdza przy starcie, czy wymagane zmienne istnieją, i przerywa uruchomienie, gdy czegoś brakuje:
// Walidacja zmiennych środowiskowych
class EnvironmentValidator {
static requiredVars = [
'REACT_APP_API_URL',
'REACT_APP_ENVIRONMENT'
];
static validate() {
const missing = this.requiredVars.filter(
varName => !process.env[varName]
);
if (missing.length > 0) {
throw new Error(
`Missing required environment variables: ${missing.join(', ')}`
);
}
}
static get(key, defaultValue = null) {
const value = process.env[key];
if (!value && defaultValue === null) {
console.warn(`Environment variable ${key} is not set`);
}
return value || defaultValue;
}
static getSecure(key) {
const value = process.env[key];
if (!value) {
throw new Error(`Secure environment variable ${key} is required`);
}
return value;
}
}
// Konfiguracja aplikacji
const appConfig = {
apiUrl: EnvironmentValidator.getSecure('REACT_APP_API_URL'),
environment: EnvironmentValidator.get('REACT_APP_ENVIRONMENT', 'development'),
isDevelopment: process.env.NODE_ENV === 'development',
isProduction: process.env.NODE_ENV === 'production',
// Funkcje pomocnicze
get isSecure() {
return this.apiUrl.startsWith('https://');
},
get shouldEnableDevTools() {
return this.isDevelopment && !this.isProduction;
}
};
// Walidacja przy starcie aplikacji
EnvironmentValidator.validate();Błąd przy starcie jest lepszy niż aplikacja, która po cichu wysyła żądania pod undefined. getSecure rzuca wyjątek, a get tylko ostrzega i zwraca wartość domyślną.
ConfigProvider rozdziela ustawienia według środowiska: debugowanie, poziom logów i mocki:
// ConfigProvider.jsx
const ConfigContext = createContext();
export function ConfigProvider({ children }) {
const config = useMemo(() => {
const baseConfig = {
apiUrl: process.env.REACT_APP_API_URL,
environment: process.env.REACT_APP_ENVIRONMENT,
version: process.env.REACT_APP_VERSION || '1.0.0'
};
// Konfiguracja specyficzna dla środowiska
const environmentConfigs = {
development: {
debug: true,
logLevel: 'debug',
enableMocks: true
},
staging: {
debug: true,
logLevel: 'info',
enableMocks: false
},
production: {
debug: false,
logLevel: 'error',
enableMocks: false
}
};
return {
...baseConfig,
...environmentConfigs[baseConfig.environment] || environmentConfigs.production
};
}, []);
return (
<ConfigContext.Provider value={config}>
{children}
</ConfigContext.Provider>
);
}
export const useConfig = () => {
const context = useContext(ConfigContext);
if (!context) {
throw new Error('useConfig must be used within ConfigProvider');
}
return context;
};Nieznane środowisko dostaje konfigurację production, czyli najbezpieczniejszą: bez debugowania i bez mocków.
4. Skanowanie zależności
Najsłabszym ogniwem bywa cudzy kod. Skrypty w package.json uruchamiają audyt podatności i kontrolę licencji:
// Skrypty bezpieczeństwa w package.json
{
"scripts": {
"audit": "npm audit",
"audit:fix": "npm audit fix",
"audit:force": "npm audit fix --force",
"security:check": "npm audit && npm run license:check",
"license:check": "license-checker --summary",
"deps:update": "npm-check-updates -u",
"deps:check": "npm outdated"
},
"devDependencies": {
"license-checker": "^25.0.1",
"npm-check-updates": "^23.1.0",
"audit-ci": "^7.1.0"
}
}npm audit porównuje zależności z bazą znanych podatności. Uważaj na npm audit fix --force, bo może podnieść wersje major i zepsuć aplikację.
Te same kontrole warto uruchamiać automatycznie przy każdym pushu i pull requeście:
# .github/workflows/security.yml
name: Security Checks
on: [push, pull_request]
jobs:
security:
runs-on: ubuntu-latest
permissions:
contents: read
security-events: write # CodeQL wysyła wyniki do zakładki Security
steps:
- uses: actions/checkout@v7
- name: Initialize CodeQL
uses: github/codeql-action/init@v4
with:
languages: javascript-typescript
- name: Setup Node.js
uses: actions/setup-node@v7
with:
node-version: 'lts/*'
cache: 'npm'
- name: Install dependencies
run: npm ci
- name: Run npm audit
run: npm audit --audit-level high
- name: Check for known vulnerabilities
run: npx audit-ci --high
- name: License compliance check
run: npm run license:check
- name: SAST with CodeQL
uses: github/codeql-action/analyze@v4
- name: Dependency Review
uses: actions/dependency-review-action@v5
if: github.event_name == 'pull_request'Pipeline zatrzyma się na podatności o poziomie high, a dependency-review-action sprawdzi nowe zależności w pull requeście. CodeQL działa w dwóch krokach: init przygotowuje analizę, a analyze skanuje kod i wysyła wyniki, do czego job potrzebuje uprawnienia security-events: write. node-version: 'lts/*' wybiera aktualną wersję LTS Node.js, a numery wersji akcji może podbijać Dependabot (package-ecosystem: github-actions).
SecurityMonitor nasłuchuje w przeglądarce zdarzeń securitypolicyviolation, czyli naruszeń CSP, i raportuje je do serwera:
// SecurityMonitor.jsx
class SecurityMonitor {
constructor() {
this.violations = [];
this.init();
}
init() {
// Monitorowanie CSP violations
document.addEventListener('securitypolicyviolation', (e) => {
this.reportViolation({
type: 'CSP_VIOLATION',
directive: e.violatedDirective,
blockedURI: e.blockedURI,
documentURI: e.documentURI,
timestamp: new Date().toISOString()
});
});
// Monitorowanie console.error dla potencjalnych problemów bezpieczeństwa
const originalError = console.error;
console.error = (...args) => {
const message = args.join(' ');
if (this.isSecurityRelated(message)) {
this.reportViolation({
type: 'SECURITY_ERROR',
message,
timestamp: new Date().toISOString()
});
}
originalError.apply(console, args);
};
}
isSecurityRelated(message) {
const securityKeywords = [
'unsafe-inline',
'unsafe-eval',
'xss',
'csrf',
'cors',
'unauthorized',
'forbidden'
];
return securityKeywords.some(keyword =>
message.toLowerCase().includes(keyword)
);
}
reportViolation(violation) {
this.violations.push(violation);
// Wyślij do systemu monitorowania
if (process.env.NODE_ENV === 'production') {
fetch('/api/security/violations', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(violation)
}).catch(error => {
console.error('Failed to report security violation:', error);
});
}
}
getViolations() {
return [...this.violations];
}
}
// Hook dla monitorowania bezpieczeństwa
export function useSecurityMonitor() {
const monitor = useRef(new SecurityMonitor());
const reportCustomViolation = useCallback((violation) => {
monitor.current.reportViolation({
type: 'CUSTOM_VIOLATION',
...violation,
timestamp: new Date().toISOString()
});
}, []);
return {
reportViolation: reportCustomViolation,
getViolations: () => monitor.current.getViolations()
};
}O zablokowanym skrypcie dowiesz się, zanim zgłosi go użytkownik. Nadpisywanie console.error to jednak ingerencja globalna, więc stosuj ją ostrożnie.
5. Walidacja i sanityzacja danych
InputValidator sprawdza wymagane pola, długość i wzorce, a SecureForm waliduje pola przy wpisywaniu i czyści wartości przed wysłaniem:
// InputValidator.js
class InputValidator {
static patterns = {
email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
phone: /^\+?[\d\s\-\(\)]+$/,
url: /^https?:\/\/.+/,
alphanumeric: /^[a-zA-Z0-9]+$/,
noSpecialChars: /^[a-zA-Z0-9\s\-_]+$/
};
static validate(value, rules) {
const errors = [];
// Pole wymagane
if (rules.required && (!value || value.trim() === '')) {
errors.push('To pole jest wymagane');
}
if (!value) return errors;
// Długość
if (rules.minLength && value.length < rules.minLength) {
errors.push(`Minimalna liczba znaków: ${rules.minLength}`);
}
if (rules.maxLength && value.length > rules.maxLength) {
errors.push(`Maksymalna liczba znaków: ${rules.maxLength}`);
}
// Wzorzec
if (rules.pattern && !this.patterns[rules.pattern]?.test(value)) {
errors.push(`Nieprawidłowy format: ${rules.pattern}`);
}
// Własna reguła
if (rules.custom) {
const customError = rules.custom(value);
if (customError) errors.push(customError);
}
// Ochrona przed XSS
if (rules.preventXSS && this.containsPotentialXSS(value)) {
errors.push('Pole zawiera potencjalnie niebezpieczną treść');
}
return errors;
}
static containsPotentialXSS(value) {
const xssPatterns = [
/<script[^>]*>.*?<\/script>/gi,
/javascript:/gi,
/on\w+\s*=/gi,
/<iframe[^>]*>/gi,
/<object[^>]*>/gi,
/<embed[^>]*>/gi,
/eval\s*\(/gi,
/expression\s*\(/gi
];
return xssPatterns.some(pattern => pattern.test(value));
}
static sanitize(value, options = {}) {
if (!value) return value;
let sanitized = value;
// Usuń znaczniki HTML
if (options.stripHTML) {
sanitized = sanitized.replace(/<[^>]*>/g, '');
}
// Zamień znaki specjalne na encje HTML
if (options.escapeHTML) {
sanitized = sanitized
.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
}
// Usuń bajty zerowe
sanitized = sanitized.replace(/\0/g, '');
// Usuń białe znaki z początku i końca
if (options.trim !== false) {
sanitized = sanitized.trim();
}
return sanitized;
}
}
// Komponent SecureForm
function SecureForm({ onSubmit, children }) {
const [formData, setFormData] = useState({});
const [errors, setErrors] = useState({});
const [isSubmitting, setIsSubmitting] = useState(false);
const validateField = useCallback((name, value, rules) => {
const fieldErrors = InputValidator.validate(value, rules);
setErrors(prev => ({
...prev,
[name]: fieldErrors.length > 0 ? fieldErrors : undefined
}));
return fieldErrors.length === 0;
}, []);
const handleInputChange = useCallback((name, value, rules) => {
// Trzymaj surowy tekst: React escapuje go przy renderowaniu
setFormData(prev => ({
...prev,
[name]: value
}));
// Waliduj przy każdej zmianie
validateField(name, value, rules);
}, [validateField]);
const handleSubmit = async (e) => {
e.preventDefault();
setIsSubmitting(true);
// Waliduj wszystkie pola według reguł zapisanych w dzieciach
let isValid = true;
const newErrors = {};
React.Children.forEach(children, child => {
if (!React.isValidElement(child) || !child.props.name) return;
const fieldName = child.props.name;
const fieldErrors = InputValidator.validate(formData[fieldName], child.props.validationRules || {});
if (fieldErrors.length > 0) {
newErrors[fieldName] = fieldErrors;
isValid = false;
}
});
setErrors(newErrors);
if (isValid) {
// Przytnij wartości i usuń bajty zerowe dopiero przed wysłaniem
const cleanData = Object.fromEntries(
Object.entries(formData).map(([key, value]) => [key, InputValidator.sanitize(value)])
);
try {
await onSubmit(cleanData);
} catch (error) {
console.error('Nie udało się wysłać formularza:', error);
}
}
setIsSubmitting(false);
};
return (
<form onSubmit={handleSubmit}>
{React.Children.map(children, child => {
if (React.isValidElement(child) && child.props.name) {
return React.cloneElement(child, {
value: formData[child.props.name] || '',
onChange: (e) => handleInputChange(
child.props.name,
e.target.value,
child.props.validationRules
),
error: errors[child.props.name],
disabled: isSubmitting
});
}
return child;
})}
</form>
);
}SecureForm trzyma w stanie surowy tekst, bo React escapuje go przy renderowaniu, a escapowanie encji przy każdym naciśnięciu klawisza psułoby wpisywany tekst: & zamieniałby się w &, a po następnym znaku w &amp;. sanitize przycina wartości dopiero przed wysłaniem, a escapeHTML przydaje się tylko wtedy, gdy tekst trafia do HTML poza Reactem. Walidacja w przeglądarce poprawia wygodę, ale nie zabezpiecza, bo atakujący wyśle żądanie z pominięciem formularza. Serwer musi sprawdzić dane ponownie, a wyrażenia z containsPotentialXSS traktuj jako sygnał, nie tarczę.
6. OWASP Top 10
Na koniec lista kontrolna według OWASP Top 10:2025, najpopularniejszego zestawienia ryzyk aplikacji webowych. Kod pokazuje wybrane kategorie w kolejności z rankingu:
// Lista kontrolna OWASP Top 10:2025 (wybrane kategorie)
// A01:2025 Broken Access Control - UI ukrywa widoki, ale uprawnienia sprawdza serwer
function ProtectedRoute({ children, requiredRole, requiredPermissions }) {
const { user, hasRole, hasPermissions } = useAuth();
if (!user) {
return <Navigate to="/login" replace />;
}
if (requiredRole && !hasRole(requiredRole)) {
return <div>Odmowa dostępu: niewystarczająca rola</div>;
}
if (requiredPermissions && !hasPermissions(requiredPermissions)) {
return <div>Odmowa dostępu: brak uprawnień</div>;
}
return children;
}
// A02:2025 Security Misconfiguration - nagłówki, CORS i parser XML (XXE)
const SecurityConfig = {
securityHeaders: {
'Strict-Transport-Security': 'max-age=31536000; includeSubDomains',
'X-Content-Type-Options': 'nosniff',
'X-Frame-Options': 'DENY',
'X-XSS-Protection': '0',
'Referrer-Policy': 'strict-origin-when-cross-origin'
},
corsConfig: {
origin: process.env.ALLOWED_ORIGINS?.split(',') || [],
credentials: true,
optionsSuccessStatus: 200
},
// DOMParser w przeglądarce nie pobiera zewnętrznych encji XML
parseXMLSafely: (xmlString) => {
const doc = new DOMParser().parseFromString(xmlString, 'text/xml');
if (doc.querySelector('parsererror')) {
throw new Error('Nieprawidłowy format XML');
}
return doc;
}
};
// A03:2025 Software Supply Chain Failures - npm ci, npm audit i dependency review z sekcji 4
// A04:2025 Cryptographic Failures - losowość z Web Crypto, szyfrowanie danych na serwerze
const CryptoPractices = {
// Token z kryptograficznie bezpiecznego generatora, nigdy z Math.random()
randomToken: (bytes = 32) => {
const values = crypto.getRandomValues(new Uint8Array(bytes));
return Array.from(values, (b) => b.toString(16).padStart(2, '0')).join('');
}
};
// A05:2025 Injection - dane osobno od zapytania, nigdy sklejane w tekst SQL
const InjectionPrevention = {
// Zawsze używaj prepared statements (kod backendu)
safeQuery: (query, params) => {
return db.prepare(query).run(params);
},
// Walidacja parametrów
validateParams: (params, schema) => {
return schema.validate(params);
}
};
// A07:2025 Authentication Failures - zasady haseł według NIST SP 800-63B
const AuthenticationSecurity = {
passwordPolicy: {
minLength: 15, // 8, jeśli konto ma MFA
maxLength: 64, // pozwól na długie frazy
checkBreachedPasswords: true, // odrzucaj hasła z wycieków i najpopularniejsze
requireCharacterMix: false, // bez wymuszania wielkich liter i znaków specjalnych
forcePeriodicChange: false // zmiana hasła tylko po podejrzeniu wycieku
},
// Ograniczenie nieudanych prób logowania
loginAttempts: {
maxAttempts: 5,
lockoutDuration: 15 * 60 * 1000 // 15 minut
},
// Sesja w ciasteczku
sessionConfig: {
httpOnly: true,
secure: true,
sameSite: 'strict',
maxAge: 30 * 60 * 1000 // 30 minut
}
};Pełna lista OWASP Top 10:2025 to A01 Broken Access Control, A02 Security Misconfiguration, A03 Software Supply Chain Failures, A04 Cryptographic Failures, A05 Injection, A06 Insecure Design, A07 Authentication Failures, A08 Software or Data Integrity Failures, A09 Security Logging and Alerting Failures i A10 Mishandling of Exceptional Conditions. XSS z pierwszej sekcji należy do A05, a SecurityMonitor z sekcji o zależnościach to przykład A09. X-XSS-Protection ustawiamy na 0, bo przestarzały filtr przeglądarek potrafił tworzyć nowe luki, a MDN zaleca zamiast niego CSP. Klucz szyfrujący w kodzie frontendu nie jest tajemnicą, więc szyfrowanie danych wrażliwych należy do serwera, a przeglądarka bierze losowe wartości z Web Crypto API. Zasady haseł idą za NIST SP 800-63B (wersja 4 z 2025 roku), na który powołuje się OWASP: liczy się długość i odrzucanie haseł z wycieków, a wymuszania znaków specjalnych i okresowej zmiany hasła NIST zabrania.
Bezpieczeństwo obejmuje wszystkie warstwy, od klienta po serwer, i wymaga regularnych audytów oraz aktualnych zależności. Polecam zacząć od trzech kroków: DOMPurify przy każdym surowym HTML, ciasteczka httpOnly i automatyczny audyt w CI. Wszystkie wrócą w ćwiczeniu Security Operations Center.
Pamiętaj: każda warstwa to osobna tarcza statku - React escapuje, CSP filtruje, a serwer sprawdza wszystko jeszcze raz.
Kod do tej lekcji: App.jsx
import React, { useState, useRef } from 'react';
// Demonstracja praktyk bezpieczeństwa w React
// Ochrona przed XSS, sanityzacja HTML i walidacja danych wejściowych
function XSSDemo() {
const [userInput, setUserInput] = useState('');
const [messages, setMessages] = useState([
{ id: 1, text: 'Witaj na pokładzie stacji!', author: 'Kapitan' },
{ id: 2, text: 'Systemy obronne aktywne.', author: 'Oficer' },
]);
const nextId = useRef(3);
// React automatycznie escapuje zawartość JSX - ochrona przed XSS
const maliciousInput = '<script>alert("hack!")<\/script><img src=x onerror=alert(1)>';
const addMessage = () => {
if (userInput.trim()) {
setMessages(prev => [...prev, {
id: nextId.current++,
text: userInput, // React bezpiecznie escapuje te dane
author: 'Użytkownik',
}]);
setUserInput('');
}
};
return (
<div style={styles.panel}>
<h2 style={styles.heading}>1. Ochrona przed XSS</h2>
<div style={{ marginBottom: '16px' }}>
<h4 style={styles.subheading}>Złośliwe dane wejściowe (automatycznie escapowane):</h4>
<div style={{ background: '#0d1b2a', padding: '12px', borderRadius: '8px', color: '#ff6b6b', fontFamily: 'monospace', fontSize: '13px', wordBreak: 'break-all' }}>
{maliciousInput}
</div>
<p style={{ color: '#00ff88', fontSize: '13px' }}>
React renderuje to jako tekst, nie jako HTML - skrypt się nie wykona!
</p>
</div>
<div>
<h4 style={styles.subheading}>Bezpieczny czat stacji kosmicznej:</h4>
<div style={{ background: '#0d1b2a', padding: '12px', borderRadius: '8px', maxHeight: '150px', overflowY: 'auto', marginBottom: '8px' }}>
{messages.map(msg => (
<div key={msg.id} style={{ marginBottom: '8px' }}>
<span style={{ color: '#00d4ff', fontWeight: 'bold' }}>{msg.author}: </span>
<span style={{ color: '#e0e1dd' }}>{msg.text}</span>
</div>
))}
</div>
<div style={{ display: 'flex', gap: '8px' }}>
<input
value={userInput}
onChange={e => setUserInput(e.target.value)}
onKeyDown={e => e.key === 'Enter' && addMessage()}
placeholder="Wpisz wiadomość (spróbuj HTML/script)..."
aria-label="Wpisz wiadomość (spróbuj HTML/script)..."
style={{ flex: 1, minWidth: 0, padding: '8px 12px', borderRadius: '8px', border: '1px solid #415a77', background: '#0d1b2a', color: '#e0e1dd' }}
/>
<button onClick={addMessage} style={{ padding: '8px 16px', borderRadius: '8px', border: 'none', background: '#00d4ff', color: '#0d1b2a', fontWeight: 'bold', cursor: 'pointer' }}>
Wyślij
</button>
</div>
</div>
</div>
);
}
function DangerousHTMLDemo() {
const [showComparison, setShowComparison] = useState(false);
const safeHTML = '<strong>Ważna wiadomość</strong> ze stacji <em>kosmicznej</em>';
const unsafeHTML = '<img src=x onerror="alert(1)"><b>Niebezpieczny HTML</b>';
// Uproszczony filtr: zostawia kilka znaczników bez żadnych atrybutów (także onerror, onclick)
// i usuwa resztę. Tylko do demonstracji - w aplikacji użyj DOMPurify.sanitize()
const sanitize = (html) => {
const allowedTags = ['b', 'i', 'em', 'strong', 'p', 'br', 'span'];
return html.replace(/<(\/?)([a-zA-Z]+)[^>]*>/g, (match, slash, tag) =>
allowedTags.includes(tag.toLowerCase()) ? `<${slash}${tag.toLowerCase()}>` : ''
);
};
return (
<div style={{ ...styles.panel, marginTop: '16px' }}>
<h2 style={styles.heading}>2. dangerouslySetInnerHTML</h2>
<div style={{ display: 'grid', gap: '12px' }}>
<div style={styles.box}>
<h4 style={{ color: '#ff6b6b', margin: '0 0 8px' }}>Niebezpieczne użycie:</h4>
<code style={{ color: '#778da9', fontSize: '13px' }}>
{'dangerouslySetInnerHTML={{ __html: userInput }}'}
</code>
<p style={{ color: '#ff6b6b', fontSize: '13px', margin: '8px 0 0' }}>
Nigdy nie używaj z niezaufanymi danymi!
</p>
</div>
<div style={styles.box}>
<h4 style={{ color: '#00ff88', margin: '0 0 8px' }}>Bezpieczne - po sanityzacji:</h4>
<div style={{ color: '#e0e1dd', marginBottom: '8px' }} dangerouslySetInnerHTML={{ __html: sanitize(safeHTML) }} />
<code style={{ color: '#778da9', fontSize: '12px', display: 'block' }}>
{'dangerouslySetInnerHTML={{ __html: sanitize(html) }}'}
</code>
<p style={{ color: '#ffd166', fontSize: '12px', margin: '8px 0 0' }}>
Funkcja sanitize w tym przykładzie to uproszczenie. W prawdziwej aplikacji użyj DOMPurify.sanitize(), który zna pułapki parsera HTML.
</p>
</div>
</div>
<button
onClick={() => setShowComparison(visible => !visible)}
style={{ marginTop: '12px', padding: '8px 16px', borderRadius: '8px', border: '1px solid #415a77', background: 'transparent', color: '#778da9', cursor: 'pointer' }}
>
{showComparison ? 'Ukryj porównanie sanityzacji' : 'Pokaż porównanie sanityzacji'}
</button>
{showComparison && (
<div style={{ ...styles.box, marginTop: '12px' }}>
<p style={{ color: '#778da9', margin: '0 0 4px', fontSize: '13px', wordBreak: 'break-all' }}>Przed: {unsafeHTML}</p>
<p style={{ color: '#00ff88', margin: 0, fontSize: '13px', wordBreak: 'break-all' }}>Po sanityzacji: {sanitize(unsafeHTML)}</p>
</div>
)}
</div>
);
}
// Siła hasła według NIST SP 800-63B: liczy się długość i odrzucanie popularnych haseł, a nie wymuszone znaki specjalne
const COMMON_PASSWORDS = ['123456', 'password', 'qwerty', 'haslo123', 'admin123'];
function passwordStrength(password) {
if (COMMON_PASSWORDS.includes(password.toLowerCase())) return 0;
if (password.length >= 20) return 4;
if (password.length >= 15) return 3;
if (password.length >= 12) return 2;
if (password.length >= 8) return 1;
return 0;
}
function InputValidationDemo() {
const [email, setEmail] = useState('');
const [emailValid, setEmailValid] = useState(null);
const [password, setPassword] = useState('');
const validateEmail = (value) => {
setEmail(value);
if (!value) { setEmailValid(null); return; }
const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
setEmailValid(regex.test(value));
};
const strength = passwordStrength(password);
const isCommon = COMMON_PASSWORDS.includes(password.toLowerCase());
const strengthLabels = ['Bardzo słabe', 'Słabe', 'Przeciętne', 'Dobre', 'Silne'];
const strengthColors = ['#ff6b6b', '#ff6b6b', '#ffaa00', '#00d4ff', '#00ff88'];
return (
<div style={{ ...styles.panel, marginTop: '16px' }}>
<h2 style={styles.heading}>3. Walidacja danych wejściowych</h2>
<div style={{ marginBottom: '16px' }}>
<label htmlFor="crew-email" style={styles.label}>Email załogi:</label>
<input
id="crew-email"
value={email}
onChange={e => validateEmail(e.target.value)}
placeholder="pilot@stacja.space"
style={{ ...styles.input, borderColor: emailValid === null ? '#415a77' : emailValid ? '#00ff88' : '#ff6b6b' }}
/>
{emailValid !== null && (
<p style={{ color: emailValid ? '#00ff88' : '#ff6b6b', fontSize: '13px', margin: '4px 0 0' }}>
{emailValid ? 'Poprawny format email' : 'Niepoprawny format email'}
</p>
)}
</div>
<div>
<label htmlFor="crew-password" style={styles.label}>Hasło dostępu:</label>
<input
id="crew-password"
type="password"
value={password}
onChange={e => setPassword(e.target.value)}
placeholder="Min. 15 znaków, najlepiej kilka słów"
style={styles.input}
/>
{password && (
<div style={{ marginTop: '8px' }}>
<div style={{ display: 'flex', gap: '4px', marginBottom: '4px' }}>
{[1, 2, 3, 4].map(level => (
<div key={level} style={{ flex: 1, height: '4px', borderRadius: '2px', background: level <= strength ? strengthColors[strength] : '#415a77' }} />
))}
</div>
<p style={{ color: strengthColors[strength], fontSize: '13px', margin: 0 }}>
{isCommon ? 'To hasło jest na liście najpopularniejszych - wybierz inne' : `Siła hasła: ${strengthLabels[strength]} (długość: ${password.length})`}
</p>
</div>
)}
<p style={{ color: '#778da9', fontSize: '12px', margin: '8px 0 0' }}>Długa fraza z kilku słów jest mocniejsza niż krótkie hasło ze znakami specjalnymi.</p>
</div>
</div>
);
}
const styles = {
panel: { background: '#1b2838', padding: '20px', borderRadius: '12px', border: '1px solid #415a77' },
heading: { color: '#00d4ff', marginTop: 0 },
subheading: { color: '#778da9' },
box: { background: '#0d1b2a', padding: '12px', borderRadius: '8px' },
label: { color: '#778da9', display: 'block', marginBottom: '4px' },
input: { width: '100%', padding: '8px 12px', borderRadius: '8px', border: '1px solid #415a77', background: '#0d1b2a', color: '#e0e1dd', boxSizing: 'border-box' },
};
export default function App() {
return (
<div style={{ background: '#0d1b2a', minHeight: '100vh', padding: '24px 16px', color: '#e0e1dd', fontFamily: 'monospace' }}>
<div style={{ maxWidth: '650px', margin: '0 auto' }}>
<h1 style={{ color: '#00d4ff', textAlign: 'center' }}>Bezpieczeństwo w React</h1>
<p style={{ color: '#778da9', textAlign: 'center', marginBottom: '24px' }}>
Systemy obronne stacji kosmicznej - praktyki bezpieczeństwa
</p>
<XSSDemo />
<DangerousHTMLDemo />
<InputValidationDemo />
</div>
</div>
);
}Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Jak React domyślnie chroni przed atakami XSS (Cross-Site Scripting)?
2. Kiedy w React TRZEBA sanityzować dane wejściowe użytkownika za pomocą biblioteki jak DOMPurify?
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż składnię użycia DOMPurify do bezpiecznego renderowania HTML w React:
- Edytor kodu
Zabezpiecz panel transmisji od obcych statków. Treść wiadomości React escapuje sam, bo trafia do JSX w klamrach. ___BLANK1___: isSafeUrl zwraca true tylko dla protokołów http:, https: i mailto: (dla javascript:, data: i każdego innego - false). ___BLANK2___: wypełnij tablicę bytes losowymi bajtami z kryptograficznie bezpiecznego crypto.getRandomValues (nigdy Math.random), żeby powstał 32-znakowy token CSRF. ___BLANK3___: link otwierany w nowej karcie dostaje rel z wartościami noopener i noreferrer. W podglądzie link od nieznanego statku musi być zablokowany, a jego tekst widoczny jako zwykły tekst.