Kurs Angular · Moduł 12: Bezpieczeństwo i wydajność

Bezpieczeństwo w Angular - Fortyfikacje Zamku

2 min czytania ·
W tej lekcji5

Bezpieczeństwo aplikacji to jak mury zamku Himeji 城 - wielowarstwowa obrona przed wrogami. Zamek Himeji przetrwał wieki dzięki przemyślanym fortyfikacjom - Twoja aplikacja też potrzebuje takiej ochrony!

Typy Zagrożeń

ZagrożenieOpisOchrona Angular
XSSWstrzykiwanie złośliwych skryptówAutomatyczna sanityzacja
CSRFFałszywe żądania między stronamiHttpXsrfModule
InjectionWstrzykiwanie koduParametryzowane zapytania
ClickjackingUkryte ramkiX-Frame-Options

Ochrona przed XSS

Angular automatycznie sanityzuje wszystkie wartości w szablonach:

@Component({
  template: `
    <!-- Bezpieczne - Angular escaped HTML -->
    <div>{{ userInput }}</div>

    <!-- Bezpieczne - Angular sanityzuje URL -->
    <a [href]="userUrl">Link</a>

    <!-- Bezpieczne - Angular sanityzuje style -->
    <div [style.background]="userBackground">...</div>
  `
})
export class SafeComponent {
  // Nawet jeśli userInput = '<script>alert("XSS")</script>'
  // Angular wyświetli tekst, nie wykona skryptu
  userInput = '<script>alert("XSS")</script>';
}

DomSanitizer - Świadome Obejście

Czasem potrzebujesz wyświetlić zaufany HTML (np. z edytora WYSIWYG):

import { DomSanitizer, SafeHtml, SafeUrl } from '@angular/platform-browser';

@Component({
  template: `
    <!-- Używamy pipe lub bindowania -->
    <div [innerHTML]="trustedHtml"></div>
    <iframe [src]="trustedUrl"></iframe>
  `
})
export class TrustedContentComponent {
  private sanitizer = inject(DomSanitizer);

  trustedHtml: SafeHtml;
  trustedUrl: SafeUrl;

  constructor() {
    // WAŻNE: Używaj tylko dla ZAUFANYCH źródeł!
    this.trustedHtml = this.sanitizer.bypassSecurityTrustHtml(
      '<b>Zaufany HTML</b>'
    );

    this.trustedUrl = this.sanitizer.bypassSecurityTrustResourceUrl(
      'https://trusted-site.com/embed'
    );
  }
}

// Pipe do wielokrotnego użycia
@Pipe({ name: 'safeHtml', standalone: true })
export class SafeHtmlPipe implements PipeTransform {
  private sanitizer = inject(DomSanitizer);

  transform(value: string): SafeHtml {
    return this.sanitizer.bypassSecurityTrustHtml(value);
  }
}

Content Security Policy (CSP)

CSP to dodatkowa warstwa obrony - jak zewnętrzne mury zamku:

<!-- index.html -->
<meta http-equiv="Content-Security-Policy" content="
  default-src 'self';
  script-src 'self' 'unsafe-inline';
  style-src 'self' 'unsafe-inline';
  img-src 'self' data: https:;
  font-src 'self';
  connect-src 'self' https://api.example.com;
">

Ochrona przed CSRF

// app.config.ts
import { provideHttpClient, withXsrfConfiguration } from '@angular/common/http';

export const appConfig: ApplicationConfig = {
  providers: [
    provideHttpClient(
      withXsrfConfiguration({
        cookieName: 'XSRF-TOKEN',
        headerName: 'X-XSRF-TOKEN'
      })
    )
  ]
};
Kod do tej lekcji: src/app/app.component.ts
import { Component, signal, computed } from '@angular/core';
import { CommonModule } from '@angular/common';
import { DomSanitizer, SafeHtml } from '@angular/platform-browser';

@Component({
  selector: 'app-root',
  standalone: true,
  imports: [CommonModule],
  template: `
    <div class="security-castle">
      <h1>Fortyfikacje Zamku - Bezpieczeństwo Angular</h1>

      <section class="xss-demo">
        <h2>Ochrona przed XSS</h2>

        <div class="demo-box">
          <h3>Automatyczna sanityzacja Angular</h3>

          <div class="input-group">
            <label>Wprowadź tekst (spróbuj &lt;script&gt; lub onclick):</label>
            <input
              type="text"
              [value]="userInput()"
              (input)="onInputChange($event)"
              placeholder="<script>alert('XSS')</script>"
            >
          </div>

          <div class="output-comparison">
            <div class="output safe">
              <h4>Angular domyślnie (bezpieczny):</h4>
              <div class="content">{{ userInput() }}</div>
              <p class="note">Angular automatycznie escape'uje HTML</p>
            </div>

            <div class="output dangerous">
              <h4>innerHTML bez sanityzacji:</h4>
              <div class="content" [innerHTML]="userInput()"></div>
              <p class="note">Angular sanityzuje innerHTML automatycznie</p>
            </div>

            <div class="output bypass">
              <h4>bypassSecurityTrust (ostrożnie!):</h4>
              <div class="content" [innerHTML]="trustedHtml()"></div>
              <p class="note">Tylko dla zaufanych źródeł!</p>
            </div>
          </div>
        </div>
      </section>

      <section class="sanitizer-api">
        <h2>DomSanitizer API</h2>

        <div class="methods-grid">
          <div class="method">
            <code>bypassSecurityTrustHtml()</code>
            <p>Zaufany HTML</p>
          </div>
          <div class="method">
            <code>bypassSecurityTrustStyle()</code>
            <p>Zaufane style CSS</p>
          </div>
          <div class="method">
            <code>bypassSecurityTrustScript()</code>
            <p>Zaufany skrypt</p>
          </div>
          <div class="method">
            <code>bypassSecurityTrustUrl()</code>
            <p>Zaufany URL</p>
          </div>
          <div class="method">
            <code>bypassSecurityTrustResourceUrl()</code>
            <p>Zaufany URL zasobu (iframe)</p>
          </div>
        </div>

        <div class="warning-box">
          <h3>Ostrzeżenie</h3>
          <p>Nigdy nie używaj bypass* dla danych od użytkownika! Tylko dla zaufanych, kontrolowanych źródeł.</p>
        </div>
      </section>

      <section class="code-example">
        <h2>Przykład bezpiecznego kodu</h2>
        <pre><code>{{ safeCodeExample }}</code></pre>
      </section>

      <section class="checklist">
        <h2>Checklist bezpieczeństwa</h2>
        <ul>
          @for (item of securityChecklist(); track item.id) {
            <li [class.checked]="item.checked" (click)="toggleCheck(item.id)">
              <span class="checkbox">{{ item.checked ? '[x]' : '[ ]' }}</span>
              <span class="text">{{ item.text }}</span>
            </li>
          }
        </ul>
        <p class="progress">
          Ukończono: {{ checkedCount() }}/{{ securityChecklist().length }}
        </p>
      </section>
    </div>
  `,
  styles: [`
    .security-castle {
      font-family: 'Segoe UI', sans-serif;
      padding: 20px;
      background: linear-gradient(135deg, #2c3e50 0%, #1a252f 100%);
      min-height: 100vh;
      color: #ecf0f1;
    }

    h1 {
      text-align: center;
      color: #e74c3c;
    }

    h2 {
      color: #e74c3c;
      border-bottom: 2px solid #e74c3c;
      padding-bottom: 10px;
    }

    section {
      background: rgba(255,255,255,0.05);
      border-radius: 10px;
      padding: 20px;
      margin: 20px 0;
    }

    .demo-box {
      background: rgba(0,0,0,0.3);
      padding: 20px;
      border-radius: 8px;
    }

    .input-group {
      margin-bottom: 20px;
    }

    .input-group label {
      display: block;
      margin-bottom: 8px;
      color: #bdc3c7;
    }

    .input-group input {
      width: 100%;
      padding: 12px;
      border: 2px solid #34495e;
      border-radius: 5px;
      background: #2c3e50;
      color: white;
      font-size: 16px;
      box-sizing: border-box;
    }

    .output-comparison {
      display: grid;
      grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
      gap: 15px;
    }

    .output {
      padding: 15px;
      border-radius: 8px;
    }

    .output.safe {
      background: rgba(46, 204, 113, 0.2);
      border: 2px solid #2ecc71;
    }

    .output.dangerous {
      background: rgba(241, 196, 15, 0.2);
      border: 2px solid #f1c40f;
    }

    .output.bypass {
      background: rgba(231, 76, 60, 0.2);
      border: 2px solid #e74c3c;
    }

    .output h4 {
      margin-top: 0;
      font-size: 0.9em;
    }

    .output .content {
      background: rgba(0,0,0,0.3);
      padding: 10px;
      border-radius: 4px;
      min-height: 40px;
      word-break: break-all;
    }

    .output .note {
      font-size: 0.8em;
      color: #888;
      margin-bottom: 0;
    }

    .methods-grid {
      display: grid;
      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
      gap: 15px;
      margin: 20px 0;
    }

    .method {
      background: rgba(0,0,0,0.3);
      padding: 15px;
      border-radius: 8px;
      text-align: center;
    }

    .method code {
      display: block;
      background: #e74c3c;
      color: white;
      padding: 8px;
      border-radius: 4px;
      margin-bottom: 10px;
      font-size: 0.85em;
    }

    .method p {
      margin: 0;
      color: #bdc3c7;
    }

    .warning-box {
      background: rgba(231, 76, 60, 0.2);
      border: 2px solid #e74c3c;
      border-radius: 8px;
      padding: 15px;
    }

    .warning-box h3 {
      margin-top: 0;
      color: #e74c3c;
    }

    pre {
      background: #1a252f;
      padding: 15px;
      border-radius: 8px;
      overflow-x: auto;
      border-left: 4px solid #e74c3c;
    }

    code {
      color: #ecf0f1;
      font-family: 'Fira Code', monospace;
      font-size: 0.85em;
    }

    .checklist ul {
      list-style: none;
      padding: 0;
    }

    .checklist li {
      display: flex;
      align-items: center;
      gap: 10px;
      padding: 12px;
      margin: 5px 0;
      background: rgba(0,0,0,0.3);
      border-radius: 5px;
      cursor: pointer;
      transition: all 0.3s;
    }

    .checklist li:hover {
      background: rgba(0,0,0,0.5);
    }

    .checklist li.checked {
      background: rgba(46, 204, 113, 0.2);
    }

    .checklist .checkbox {
      font-size: 1.2em;
    }

    .progress {
      text-align: center;
      font-weight: bold;
      color: #2ecc71;
    }
  `]
})
export class AppComponent {
  userInput = signal('<b>Bold</b> <script>alert("XSS")</script> <img onerror="alert(1)" src="x">');

  securityChecklist = signal([
    { id: 1, text: 'Nie używaj bypassSecurityTrust* dla danych użytkownika', checked: false },
    { id: 2, text: 'Waliduj dane po stronie serwera', checked: false },
    { id: 3, text: 'Używaj HttpOnly cookies dla tokenów', checked: false },
    { id: 4, text: 'Implementuj CSP (Content Security Policy)', checked: false },
    { id: 5, text: 'Sanityzuj URL-e przed użyciem', checked: false },
    { id: 6, text: 'Unikaj eval() i innerHTML z danymi użytkownika', checked: false },
    { id: 7, text: 'Używaj HTTPS wszędzie', checked: false },
    { id: 8, text: 'Aktualizuj Angular do najnowszej wersji', checked: false }
  ]);

  checkedCount = computed(() =>
    this.securityChecklist().filter(item => item.checked).length
  );

  safeCodeExample = `// Bezpieczne użycie DomSanitizer
import { DomSanitizer, SafeHtml } from '@angular/platform-browser';

@Component({...})
export class SafeComponent {
  private sanitizer = inject(DomSanitizer);

  // Dla zaufanego HTML z serwera (np. CMS)
  trustedContent: SafeHtml;

  loadTrustedContent(): void {
    // Tylko dla treści z zaufanego źródła!
    const htmlFromCMS = this.cmsService.getContent();
    this.trustedContent = this.sanitizer.bypassSecurityTrustHtml(htmlFromCMS);
  }

  // NIGDY nie rób tego dla danych użytkownika!
  // userInput = this.sanitizer.bypassSecurityTrustHtml(userProvidedData);

  // Dla URL-i dynamicznych
  getVideoUrl(videoId: string): SafeResourceUrl {
    const url = \`https://youtube.com/embed/\${videoId}\`;
    return this.sanitizer.bypassSecurityTrustResourceUrl(url);
  }
}`;

  constructor(private sanitizer: DomSanitizer) {}

  trustedHtml = computed(() => {
    // Demonstracja - w praktyce używaj tylko dla zaufanych źródeł!
    return this.sanitizer.bypassSecurityTrustHtml(this.userInput());
  });

  onInputChange(event: Event): void {
    const input = event.target as HTMLInputElement;
    this.userInput.set(input.value);
  }

  toggleCheck(id: number): void {
    this.securityChecklist.update(list =>
      list.map(item =>
        item.id === id ? { ...item, checked: !item.checked } : item
      )
    );
  }
}

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 Angular chroni przed atakami XSS?

  2. 2. Co oznacza skrót XSS w kontekście bezpieczeństwa aplikacji webowych?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Uzupełnij komponent wyświetlający zaufany HTML z CMS.

  • Układanie w poziomie

    Ułóż w poprawnej kolejności linię importu DomSanitizer (od lewej do prawej):

  • Klikanie w kolejności

    Zbuduj wywołanie zwracające zaufany HTML (klikaj w kolejności):

  1. PytanieOchrona XSS
  2. PytanieAtak XSS
  3. PytanieZagrożenie CSRF
  4. Zadanie z kodemPraktyka: Bezpieczne HTML
  5. Ułóż w kolejnościImport DomSanitizer
  6. Kliknij w kolejnościWywołanie sanityzacji

Przydatne artykuły