Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React

Kompleksowe praktyki bezpieczeństwa w React

17 min czytania ·
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_here

Wszystko 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, '&amp;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#x27;');
    }

    // 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 &amp;, a po następnym znaku w &amp;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. 1. Jak React domyślnie chroni przed atakami XSS (Cross-Site Scripting)?

  2. 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.

  1. PytanieXSS w React - ochrona
  2. Ułóż w kolejnościSortowanie poziome: sanityzacja z DOMPurify
  3. PytanieSanityzacja danych wejściowych
  4. Zadanie z kodemPraktyka: Centrum bezpieczeństwa stacji

Przydatne artykuły