Strona główna/Blog/Badania podatności
Badania podatnościOpublikowano · Zaktualizowano ⚡ 15 min czytania

Przestań wypuszczać pułapki na własne stopy. Tak naprawdę pisze się bezpieczny kod w 2026 roku.

Surowy playbook praktyk bezpiecznego kodowania bez ściemy. Omawiamy walidację danych wejściowych z Zod, zapytania parametryzowane, CSP i wzorce bezpieczeństwa SDLC, które pewnie ignorujesz.

VG
Vladyslav Gusarov
DevSecOps Lead w Bryxe
Praktyki bezpiecznego kodowania: playbook senior inżyniera [audyt 2026]

# Przestań wypuszczać śmieci: playbook bezpiecznego kodowania na 2026 rok

Słuchaj, jestem zmęczony. Cały dzień przeglądam PR-y i ciągle widzę te same podstawowe pułapki bezpieczeństwa, wypychane na produkcję przez inżynierów, którzy powinni wiedzieć lepiej. AI dopisuje nam kod, a my wciąż dajemy się nabrać na podatności z epoki 1999 roku. Tak zwany bezpieczny cykl wytwarzania oprogramowania (bezpieczeństwo SDLC) w większości organizacji to żart. To ticket w Jirze, który ktoś odklikuje jako „Done”, podczas gdy surowa konkatenacja stringów przemyka do warstwy bazy danych.

Podsumowując: praktyki bezpiecznego kodowania nie są już opcjonalne. Nie możesz po prostu postawić WAF-a przed swoim rozklekotanym backendem w Node.js i uznać sprawy za załatwioną. To jest playbook. Stosuj te wytyczne bezpiecznego kodowania albo daj się zhakować. Nie obchodzi mnie Twoje velocity w sprincie, jeśli aktywnie narażasz dane użytkowników.

1. Dobre praktyki walidacji danych wejściowych: Zod albo nic

Widzę mnóstwo sprawdzeń w stylu if (req.body.userId == null). Przestań. Po prostu przestań. To nie jest walidacja danych wejściowych. To modlitwa. Potrzebujesz ścisłej walidacji schematem na samych krawędziach aplikacji. Jeśli dane nie pasują do schematu, wywal je. Bez wyjątków.

Mam dość oglądania tego w PR-ach. Tu zasady OWASP secure coding zderzają się z rzeczywistością. Używamy Zod. Dlaczego? Bo wymusza ścisłe typowanie i pod spodem wycina śmieci.

typescriptKod źródłowy
import { z } from 'zod';
import express from 'express';

const app = express();
app.use(express.json());

// Strict schema. No extra keys allowed.
const UserProfileSchema = z.object({
  username: z.string().min(3).max(30).regex(/^[a-zA-Z0-9_]+$/),
  email: z.string().email(),
  age: z.number().int().min(18).max(120),
}).strict();

app.post('/api/profile', (req, res) => {
  const result = UserProfileSchema.safeParse(req.body);
  
  if (!result.success) {
    // Log this internally, but give a generic 400 to the client
    console.error('Validation failed:', result.error.format());
    return res.status(400).json({ error: 'Invalid input data.' });
  }

  // result.data is now 100% typed and scrubbed
  const validData = result.data;
  // proceed to business logic
});

Jeśli tego nie robisz, prosisz się o NoSQL injection albo prototype pollution. Ścisłe schematy oznaczają, że atakujący uderzają w ścianę, zanim w ogóle dotrą do Twojej logiki biznesowej. Dobre praktyki walidacji danych wejściowych to Twoja pierwsza linia obrony.

2. Zapytania parametryzowane: epidemia SQLi wciąż trwa

Nie wierzę, że muszę to pisać w 2026 roku. Jeśli używasz interpolacji stringów w zapytaniach SQL, powinieneś stracić prawo do commitów. Nie obchodzi mnie, że to wewnętrzne narzędzie administracyjne. To właśnie przez wewnętrzne narzędzia dochodzi do lateral movement.

Spójrz na te śmieci:

typescriptKod źródłowy
// DO NOT DO THIS. EVER.
const query = `SELECT * FROM users WHERE email = '${userEmail}'`;
db.query(query);

Słuchaj, widziałem to sto razy. Tak to się robi naprawdę, z zapytaniami parametryzowanymi. Sanityzacją zajmuje się sterownik bazy danych. Nie próbujesz escapować samodzielnie.

typescriptKod źródłowy
// GOOD: Using parameterized queries with pg (PostgreSQL)
const query = 'SELECT * FROM users WHERE email = $1';
const values = [userEmail];

try {
  const res = await db.query(query, values);
  return res.rows;
} catch (err) {
  // Generic error to the user
  throw new Error('Database operation failed');
}

A jeśli używasz ORM-a takiego jak Prisma czy Drizzle, nie korzystaj z ich furtek do surowych zapytań, chyba że absolutnie musisz, a nawet wtedy używaj tagged template literals, które udostępniają. Bezpieczeństwo SDLC wymaga parametryzowanych danych wejściowych wszędzie.

3. Kodowanie wyjścia: wykończmy XSS na dobre

React i nowoczesne frameworki domyślnie kodują wyjście, ale deweloperzy uwielbiają znajdować sposoby, żeby strzelić sobie w stopę przez dangerouslySetInnerHTML. Jeśli renderujesz dane od użytkownika bez kodowania wyjścia, dostajesz XSS.

Gdy naprawdę musisz renderować surowy HTML (np. z parsera markdown), użyj DOMPurify. I rób to na serwerze, jeśli to możliwe.

typescriptKod źródłowy
import DOMPurify from 'isomorphic-dompurify';

const rawHtml = getUserInput(); 
// Sanitize before it ever hits the DOM or gets saved to the DB
const cleanHtml = DOMPurify.sanitize(rawHtml, {
  ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'a'],
  ALLOWED_ATTR: ['href']
});

4. Nagłówki CSP: obrona w głąb

Szczerze, to koszmar. Content Security Policy (CSP) to wrzód na tyłku przy konfiguracji. Rozumiem. Twój skrypt analityczny się sypie. Font przestaje się ładować. Ale to ostateczna siatka bezpieczeństwa przeciw XSS. Jeśli zawalisz kodowanie wyjścia, CSP powstrzyma wykonanie payloadu.

Użyj Helmet w Expressie. Ustaw ścisłe CSP.

typescriptKod źródłowy
import helmet from 'helmet';

app.use(
  helmet.contentSecurityPolicy({
    directives: {
      defaultSrc: ["'self'"],
      scriptSrc: ["'self'", "https://trusted.cdn.com"],
      objectSrc: ["'none'"],
      upgradeInsecureRequests: [],
    },
  })
);

Nie używaj 'unsafe-inline'. Jeśli masz inline'owe skrypty, zrefaktoruj je. Tak, to wymaga pracy. I tak to zrób.

5. Konfiguracja CORS: przestań używać wildcardów

Ciągle widzę Access-Control-Allow-Origin: * w PR-ach. To ogromna czerwona flaga. Jeśli Twoje API uwierzytelnia przez ciasteczka, otwarta polityka CORS to katastrofa, która tylko czeka, żeby się wydarzyć.

Szczerze, to koszmar. Bądź jawny.

typescriptKod źródłowy
import cors from 'cors';

const whitelist = ['https://app.bryxe.com', 'https://admin.bryxe.com'];
const corsOptions = {
  origin: function (origin, callback) {
    if (!origin || whitelist.indexOf(origin) !== -1) {
      callback(null, true)
    } else {
      callback(new Error('Not allowed by CORS'))
    }
  },
  credentials: true // Only if you actually need cookies
};

app.use(cors(corsOptions));

6. Bezpieczne zarządzanie sesją

JWT to nie magiczne rozwiązanie. Jeśli trzymasz JWT w localStorage, każda podatność XSS natychmiast kompromituje sesję.

Używaj ciasteczek HttpOnly, Secure, SameSite=Strict.

typescriptKod źródłowy
app.post('/login', (req, res) => {
  // ... validate user ...
  const sessionId = generateSecureSessionId();
  
  res.cookie('sessionId', sessionId, {
    httpOnly: true, // No JS access
    secure: process.env.NODE_ENV === 'production', // HTTPS only
    sameSite: 'strict', // CSRF protection
    maxAge: 3600000 // 1 hour
  });
  
  res.json({ message: 'Logged in' });
});

7. Obsługa błędów bez wycieków informacji

Gdy coś się psuje, Twój stack trace nigdy nie powinien trafić do klienta. Nigdy. Mówi atakującym dokładnie, jakich wersji jakich bibliotek używasz, jakie są ścieżki bezwzględne na Twoim serwerze, a czasem nawet jak wygląda struktura bazy danych.

Mam dość oglądania tego w PR-ach. Łap błędy globalnie. Loguj szczegóły do swojego SIEM-a. Zwracaj użytkownikowi ogólny błąd 500.

typescriptKod źródłowy
app.use((err, req, res, next) => {
  // Log the full stack trace internally
  logger.error('Unhandled Exception:', err);
  
  // Return generic response
  res.status(500).json({
    error: 'An unexpected error occurred. Please try again later.'
  });
});

8. Dobre praktyki kryptograficzne

Przestań wymyślać własną kryptografię. Przestań używać MD5 albo SHA-1 do haseł. Używaj Argon2id albo bcrypt. W 2026 roku standardem jest Argon2id.

typescriptKod źródłowy
import * as argon2 from 'argon2';

async function hashPassword(password: string) {
  try {
    return await argon2.hash(password, {
      type: argon2.argon2id,
      memoryCost: 2 ** 16,
      timeCost: 3,
      parallelism: 1,
    });
  } catch (err) {
    throw new Error('Hashing failed');
  }
}

Przy szyfrowaniu PII w spoczynku używaj AES-256-GCM. Zapewnia szyfrowanie uwierzytelnione. Nie dotykaj trybu ECB. Nie dotykaj CBC bez HMAC. Po prostu użyj GCM i miej spokój.

Podsumowanie

Słuchaj, praktyki bezpiecznego kodowania to nie magia. To dyscyplina. To odmawianie merge'owania niechlujnych PR-ów. To wbudowanie bezpieczeństwa SDLC w pipeline'y za pomocą narzędzi SAST/DAST, żeby takie rzeczy były wyłapywane automatycznie.

Mam dość oglądania tego w PR-ach. Zacznij wdrażać te wzorce już dziś. Uporządkuj swoje schematy Zod. Napraw CORS. Wywal wildcardy. Twoja rotacja dyżurów podziękuje Ci, gdy nikt nie postawi Cię na nogi o 3 nad ranem z powodu wycieku danych.

AUTOMATYCZNA OCHRONA

Nie czekaj na exploit, żeby zrobić audyt kodu

Przejrzyj obsługiwane ryzyka w kodzie, ujawnione sekrety i wyniki dla zależności z Bryxe Shield. Przed wydaniem zweryfikuj poprawki w swojej aplikacji.

Potrzebujesz praktycznego kolejnego kroku? Zajrzyj do praktycznych poradników bezpieczeństwa lub przeczytaj naszą politykę redakcyjną i zasady doboru źródeł.

Polecane badania bezpieczeństwa