Bezpieczeństwo aplikacji (AppSec): OWASP Top 10 w praktyce

# NIEBEZPIECZNE: konkatenacja stringów
query = f"SELECT * FROM users WHERE email = '{email}'"
cursor.execute(query)  # email = "' OR '1'='1" omija filtr

# BEZPIECZNE: parametryzowane zapytanie, driver escapuje wartość
cursor.execute(
    "SELECT * FROM users WHERE email = %s",
    (email,),
)

import subprocess

# NIEBEZPIECZNE: shell=True + interpolacja
subprocess.run(f"convert {filename} output.png", shell=True)

# BEZPIECZNE: lista argumentów, brak powłoki
subprocess.run(["convert", filename, "output.png"], shell=False, check=True)

// NIEBEZPIECZNE: obiekt z request.body trafia bezpośrednio do query
db.users.findOne({ username: req.body.username, password: req.body.password });
// atak: password = { "$ne": null } omija uwierzytelnienie

// BEZPIECZNE: wymuszenie typu string przed budową zapytania
const username = String(req.body.username);
const password = String(req.body.password);
db.users.findOne({ username, password: hash(password) });

from flask import session, current_app

@app.route("/login", methods=["POST"])
def login():
    user = authenticate(request.form["email"], request.form["password"])
    if user is None:
        abort(401)

    session.clear()
    current_app.session_interface.regenerate(session)  # rotates the actual session ID (Flask-Session); session.clear() alone only empties the payload, it does not fix a pre-login session ID
    session["user_id"] = user.id
    session["issued_at"] = time.time()
    return redirect("/dashboard")

SESSION_TTL_SECONDS = 30 * 60

def is_session_valid(session: dict) -> bool:
    if "user_id" not in session:
        return False
    if time.time() - session["issued_at"] > SESSION_TTL_SECONDS:
        return False
    return session["user_id"] not in revoked_user_ids  # server-side revocation list

// BEZPIECZNE: JSX escapuje automatycznie przy renderze
function Comment({ text }: { text: string }) {
  return <p>{text}</p>;
}

// NIEBEZPIECZNE: świadome wyłączenie escapowania bez sanitizacji
function CommentUnsafe({ html }: { html: string }) {
  return <div dangerouslySetInnerHTML={{ __html: html }} />;
}

// BEZPIECZNE, gdy HTML jest wymagany: sanitizacja przez DOMPurify
import DOMPurify from "dompurify";
function CommentRichText({ html }: { html: string }) {
  const clean = DOMPurify.sanitize(html, { ALLOWED_TAGS: ["b", "i", "a"] });
  return <div dangerouslySetInnerHTML={{ __html: clean }} />;
}

Content-Security-Policy:
  script-src 'nonce-{RANDOM_PER_REQUEST}' 'strict-dynamic' https: 'unsafe-inline';
  object-src 'none';
  base-uri 'none';
  frame-ancestors 'none';

Set-Cookie: session=abc123; SameSite=Strict; Secure; HttpOnly

from flask_wtf.csrf import CSRFProtect

app = Flask(__name__)
csrf = CSRFProtect(app)  # wymusza token na każdym POST/PUT/PATCH/DELETE

@app.route("/account/email", methods=["POST"])
def change_email():
    # token walidowany automatycznie przez CSRFProtect przed wejściem tutaj;
    # brak/zły token -> 400 Bad Request
    ...

import pickle, json

# NIEBEZPIECZNE: deserializacja niezaufanych danych wykonuje dowolny kod
data = pickle.loads(untrusted_bytes_from_request)

# BEZPIECZNE: format danych bez wykonywalnego kodu
data = json.loads(untrusted_bytes_from_request)

ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(
    "com.app.model.*;!*"  // dozwolone tylko klasy z com.app.model, reszta odrzucona
);
ObjectInputStream ois = new ObjectInputStream(inputStream);
ois.setObjectInputFilter(filter);

import ipaddress
import socket
from urllib.parse import urlparse

def resolve_safe_ip(url: str) -> str | None:
    parsed = urlparse(url)
    if parsed.scheme not in ("http", "https") or not parsed.hostname:
        return None

    # rozwiąż DNS PRZED walidacją i sprawdź KAŻDY adres (IPv4 i IPv6)
    infos = socket.getaddrinfo(parsed.hostname, None)
    addrs = [ipaddress.ip_address(info[4][0]) for info in infos]
    if not all(addr.is_global for addr in addrs):
        return None  # blokuje też 169.254.169.254 (metadata endpoint)
    # Łącz się pod TEN adres (nagłówek Host = parsed.hostname) i nie podążaj
    # za przekierowaniem bez ponownej walidacji: drugie rozwiązanie nazwy
    # przez klienta HTTP otwiera drogę dla DNS rebinding.
    return str(addrs[0])

server {
    autoindex off;                 # brak listowania katalogów
    server_tokens off;             # ukryj wersję Nginx w nagłówku Server
    location /admin { deny all; }  # panel admina niedostępny z zewnątrz
}

@app.route("/api/invoices/<invoice_id>")
@login_required
def get_invoice(invoice_id):
    invoice = db.get_invoice(invoice_id)

    if invoice is None:
        abort(404)  # nie ujawniaj, czy zasób istnieje

    if invoice.owner_id != current_user.id and not current_user.is_admin:
        abort(404)  # 404, nie 403 - utrudnia enumerację zasobów

    return jsonify(invoice.to_dict())

-- Konto aplikacji: tylko operacje na danych, zero uprawnień strukturalnych
CREATE ROLE app_user LOGIN PASSWORD '...';
GRANT SELECT, INSERT, UPDATE, DELETE ON orders, invoices TO app_user;
REVOKE ALL ON SCHEMA public FROM app_user;  -- brak DROP/ALTER/CREATE

import hashlib
from argon2 import PasswordHasher

# NIEBEZPIECZNE: szybki hash bez soli, łamany tęczowymi tablicami w sekundy
hashlib.md5(password.encode()).hexdigest()

# BEZPIECZNE: Argon2id, sól generowana automatycznie, koszt pamięciowy wbudowany
ph = PasswordHasher()
hashed = ph.hash(password)           # zapisz `hashed` do bazy
ph.verify(hashed, password_attempt)  # rzuca wyjątkiem przy niezgodności

# Zamroź dokładne wersje przechodnich zależności (powtarzalny build)
pip freeze > requirements.lock.txt

# Skanuj znane CVE w zainstalowanych pakietach
pip install pip-audit && pip-audit

# .env (w .gitignore, NIGDY commitowane)
DATABASE_URL=postgresql://user:pass@host:5432/db
JWT_SECRET=<losowe 256+ bitów>

import os

database_url = os.environ["DATABASE_URL"]