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 ipaddress
import socket
from urllib.parse import urlparse

def is_safe_url(url: str) -> bool:
    parsed = urlparse(url)
    if parsed.scheme not in ("http", "https"):
        return False

    ip = socket.gethostbyname(parsed.hostname)  # rozwiąż DNS PRZED walidacją
    addr = ipaddress.ip_address(ip)
    if addr.is_private or addr.is_loopback or addr.is_link_local:
        return False  # blokuje też 169.254.169.254 (metadata endpoint)
    return True

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"]