Как обеспечивается безопасность HTTP запросов?

Безопасность HTTP запросов

Безопасность HTTP запросов обеспечивается на нескольких уровнях: криптографическом (протокол), сетевом, и уровне приложения. Рассмотрим основные механизмы.

1. HTTPS - Криптографический уровень

HTTPS (HTTP Secure) использует TLS/SSL для шифрования данных между клиентом и сервером:

// Неправильно - использует незашифрованный HTTP
fetch('http://api.example.com/users');

// Правильно - использует защищённый HTTPS
fetch('https://api.example.com/users');

Что даёт HTTPS:

• Конфиденциальность - данные зашифрованы и невидимы для перехвата
• Целостность - нельзя изменить данные без обнаружения
• Аутентификация - подтверждение, что это действительно сервер

Сертификат проверяется браузером:

// Браузер автоматически проверяет SSL сертификат
// Если сертификат недействителен, запрос блокируется
fetch('https://self-signed.example.com') // Ошибка: SSL_ERROR_BAD_CERT_DOMAIN

2. Аутентификация и Авторизация

Bearer Token (для API)

const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...';

fetch('https://api.example.com/profile', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${token}`
  }
});

Токены должны:

• Хранить в HttpOnly куках (защита от XSS)
• Иметь время жизни (expiration)
• Быть достаточно длинными (256 бит+)

Session Cookies

// Браузер автоматически отправляет куки в запросах
fetch('https://api.example.com/data', {
  credentials: 'include' // Включить куки в запрос
})
.then(res => res.json());

Безопасные флаги куки:

// На сервере (Node.js Express)
res.cookie('sessionId', token, {
  httpOnly: true,   // Недоступна для JavaScript (защита от XSS)
  secure: true,     // Передаётся только по HTTPS
  sameSite: 'Strict', // Защита от CSRF
  maxAge: 3600000   // 1 час
});

3. Защита от CSRF (Cross-Site Request Forgery)

Проблема: Злоумышленник может отправить запрос от вашего имени

Решение: CSRF токены

// Сервер отправляет уникальный токен
const csrfToken = document.querySelector('meta[name="csrf-token"]').content;

fetch('https://api.example.com/profile', {
  method: 'POST',
  headers: {
    'X-CSRF-Token': csrfToken,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ name: 'Новое имя' })
});

SameSite атрибут куки:

// На сервере
res.cookie('session', token, {
  sameSite: 'Strict' // Кука не отправляется при кросс-сайтовых запросах
});

4. Защита от XSS (Cross-Site Scripting)

Проблема: Вредоносный код попадает на страницу

Решение: Content Security Policy (CSP)

// На сервере (заголовок HTTP)
res.setHeader(
  'Content-Security-Policy',
  "default-src 'self'; script-src 'self' https://trusted-cdn.com"
);

В HTML:

<meta http-equiv="Content-Security-Policy" 
      content="default-src 'self'; script-src 'self' 'unsafe-inline'">

Санитизация данных:

// Правильно - экранировать HTML
const userInput = '<script>alert("XSS")</script>';
const escaped = document.createElement('div');
escaped.textContent = userInput; // Безопасное отображение

// Или использовать библиотеку
import DOMPurify from 'dompurify';
const clean = DOMPurify.sanitize(userInput);

5. Валидация и Санитизация

На клиенте

function validateEmail(email) {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return regex.test(email);
}

// Проверить перед отправкой
if (!validateEmail(userEmail)) {
  console.error('Неверный email');
  return;
}

fetch('https://api.example.com/register', {
  method: 'POST',
  body: JSON.stringify({ email: userEmail })
});

На сервере (ВАЖНО!)

// Никогда не доверяй только клиентской валидации
app.post('/api/register', (req, res) => {
  // Валидировать на сервере
  if (!isValidEmail(req.body.email)) {
    return res.status(400).json({ error: 'Invalid email' });
  }
  
  // Санитизировать
  const cleanEmail = sanitize(req.body.email);
  
  // Сохранить
  saveUser(cleanEmail);
});

6. Защита от Man-in-the-Middle (MITM)

HTTPS решает большинство проблем, но есть доп. меры:

HSTS (HTTP Strict Transport Security)

// На сервере
res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');

Это заставляет браузер всегда использовать HTTPS для домена.

Pinning сертификата (для мобильных приложений)

// В приложении хранить хеш сертификата сервера
const allowedCertificates = [
  'sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA='
];

// Проверить при подключении
if (!allowedCertificates.includes(certificateHash)) {
  throw new Error('Suspicious certificate');
}

7. Защита от CORS атак

CORS контролирует, какие домены могут запрашивать ресурсы:

// На сервере (Node.js)
const cors = require('cors');

app.use(cors({
  origin: 'https://trusted-domain.com', // Только этот домен
  credentials: true,                      // Разрешить куки
  methods: ['GET', 'POST']                // Только эти методы
}));

В запросе:

fetch('https://api.example.com/data', {
  method: 'POST',
  credentials: 'include'
});

8. Rate Limiting и Throttling

Защита от brute-force и DDoS атак:

// На клиенте - ограничить частоту запросов
class RequestThrottler {
  constructor(maxRequests = 10, windowMs = 60000) {
    this.maxRequests = maxRequests;
    this.windowMs = windowMs;
    this.requests = [];
  }

  isAllowed() {
    const now = Date.now();
    this.requests = this.requests.filter(time => now - time < this.windowMs);
    
    if (this.requests.length < this.maxRequests) {
      this.requests.push(now);
      return true;
    }
    return false;
  }
}

const throttler = new RequestThrottler(5, 60000); // 5 запросов в минуту

if (throttler.isAllowed()) {
  fetch('https://api.example.com/data');
}

9. Отправка чувствительных данных

// Плохо - GET запрос с пароль в URL
fetch(`https://api.example.com/login?password=${password}`); // Опасно!

// Хорошо - POST с телом запроса
fetch('https://api.example.com/login', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ password })
});

Чеклист безопасности для HTTP запросов

• Используй HTTPS для всех запросов
• Храни токены в HttpOnly куках
• Добавляй CSRF токены в POST/PUT/DELETE запросы
• Санитизируй входные данные на сервере
• Устанавливай Content-Security-Policy заголовок
• Используй SameSite атрибут для кук
• Проверяй CORS на сервере
• Применяй rate limiting
• Добавляй HSTS заголовок
• Не доверяй клиентской валидации

Пример полностью защищённого запроса

const makeSecureRequest = async (url, options = {}) => {
  // Проверить HTTPS
  if (!url.startsWith('https://')) {
    throw new Error('Только HTTPS запросы');
  }

  // Получить CSRF токен
  const csrfToken = document.querySelector('meta[name="csrf-token"]')?.content;

  return fetch(url, {
    ...options,
    credentials: 'include', // Включить куки
    headers: {
      ...options.headers,
      'X-CSRF-Token': csrfToken,
      'Content-Type': 'application/json'
    }
  });
};

// Использование
await makeSecureRequest('https://api.example.com/profile', {
  method: 'POST',
  body: JSON.stringify({ name: 'Иван' })
});