# 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.
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:
// 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.
// 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.
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.
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.
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.
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.
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.
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.
![Praktyki bezpiecznego kodowania: playbook senior inżyniera [audyt 2026]](/_next/image?url=%2Fblog%2Ftest-mockup.jpg&w=3840&q=75&dpl=dpl_4APdW92RmtTARbNBj4X6xdJXX9hA)