Пароли: почему хеш, соль и стоимость

Начнём с очевидного, чтобы к нему не возвращаться. Пароль открытым текстом — это пароли всех пользователей в руках каждого, кто увидел таблицу: злоумышленника, администратора, сервиса резервных копий. А люди повторяют пароли, так что утекает не только ваш сайт. Зашифровать? Сервер сверяет пароль при каждом входе, значит, ключ расшифровки должен быть под рукой у приложения, — и утечка, которая дотянулась до базы через приложение, дотягивается и до его секретов. Зашифрованное можно расшифровать, в этом вся беда.

Сверять пароль можно, и не зная его. Хеш — функция в одну сторону: из пароля строку получить легко, а из строки пароль — только угадыванием. При регистрации сервер кладёт в таблицу хеш, при входе считает хеш присланного пароля и сравнивает. SHA-256 вы уже видели: в разделе «hash: телефон не верит файлу на слово» им проверяли скачанный файл. Возьмём его.

Четыре человека регистрируются, база утекает. У злоумышленника словарь — шесть самых частых паролей; настоящие словари собраны из прошлых утечек и тянут на миллионы строк, но устроены так же. Прогноз: сколько паролей он узнает и что увидит в таблице ещё до того, как откроет словарь?

async function sha256Hex(text: string): Promise<string> {
  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
}

// так регистрирует сервер: в таблицу ложится хеш, самого пароля в ней нет
const users = new Map<string, string>();
async function register(email: string, password: string) {
  users.set(email, await sha256Hex(password));
}

// словарь злоумышленника — самые частые пароли из прошлых утечек
const dictionary = ["123456", "password", "qwerty123", "1q2w3e4r", "iloveyou", "111111"];

async function main() {
  await register("anya@mail.ru", "qwerty123");
  await register("boris@mail.ru", "Кот-на-крыше-1987");
  await register("vera@mail.ru", "qwerty123");
  await register("gleb@mail.ru", "1q2w3e4r");

  // таблицу «хеш → пароль» можно посчитать заранее, ещё до всякой утечки
  const table = new Map<string, string>();
  for (const guess of dictionary) table.set(await sha256Hex(guess), guess);

  // база утекла: у злоумышленника адреса и хеши
  const leaked = [...users];
  const twins = leaked.filter(([email, hash]) => leaked.some(([other, h]) => other !== email && h === hash));
  console.log("одинаковый хеш у:", twins.map(([email]) => email).join(", "));
  for (const [email, hash] of leaked) console.log(email, "→", table.get(hash) ?? "не найден");
  console.log("вычислений SHA-256 на всю базу:", table.size);
}

main();

Три пароля из четырёх — и ничего не взломано в привычном смысле: хеш никто не обращал. Злоумышленник посчитал хеши шести строк и поискал их в таблице. Причём таблицу «хеш → пароль» можно посчитать один раз и заранее, до всякой утечки, и она подойдёт к любой базе, где лежит голый SHA-256; готовые таблицы для таких хешей давно выложены в сеть. А первая строка вывода не потребовала даже словаря: одинаковый хеш — это одинаковый пароль. Узнав пароль anya, злоумышленник узнал и пароль vera.

SHA-256 ничего не шифрует. Он быстро превращает одну строку в другую, и злоумышленник делает это ровно так же быстро, как ваш сервер. Защита начинается там, где у него это перестаёт получаться.

Обе беды прошлого раздела растут из одного корня: хеш зависит только от пароля. Значит, к паролю надо подмешать что-то своё у каждой строки. Это соль — 16 случайных байт, которые сервер создаёт при регистрации и кладёт в таблицу рядом с хешем. Секретом соль не является и не должна им быть: при входе сервер берёт её из той же строки, где лежит хеш.

Те же четыре человека, та же утечка, но теперь с солью. У злоумышленника его таблица из прошлого примера и тот же словарь из шести строк. Прогноз: сколько найдёт таблица, сколько найдёт перебор и сколько SHA-256 придётся посчитать?

declare function sha256Hex(bytes: Uint8Array): Promise<string>;
declare const dictionary: string[];

interface UserRow {
  salt: Uint8Array;
  hash: string;
}
const users = new Map<string, UserRow>();

function salted(salt: Uint8Array, password: string): Uint8Array {
  const text = new TextEncoder().encode(password);
  const bytes = new Uint8Array(salt.length + text.length);
  bytes.set(salt);
  bytes.set(text, salt.length);
  return bytes;
}

async function register(email: string, password: string) {
  // у каждой строки своя случайная соль; секрета в ней нет, она лежит рядом с хешем
  const salt = crypto.getRandomValues(new Uint8Array(16));
  users.set(email, { salt, hash: await sha256Hex(salted(salt, password)) });
}

async function main() {
  await register("anya@mail.ru", "qwerty123");
  await register("boris@mail.ru", "Кот-на-крыше-1987");
  await register("vera@mail.ru", "qwerty123");
  await register("gleb@mail.ru", "1q2w3e4r");
  const leaked = [...users];
  console.log("разных хешей на четыре строки:", new Set(leaked.map(([, row]) => row.hash)).size);

  // таблица из прошлого примера, посчитанная без соли
  const table = new Map<string, string>();
  for (const guess of dictionary) table.set(await sha256Hex(new TextEncoder().encode(guess)), guess);
  console.log("найдено по готовой таблице:", leaked.filter(([, row]) => table.has(row.hash)).length);

  // перебор: весь словарь заново для каждой строки, с её солью
  let computed = 0;
  for (const [email, row] of leaked) {
    let found = "не найден";
    for (const guess of dictionary) {
      computed += 1;
      if ((await sha256Hex(salted(row.salt, guess))) === row.hash) found = guess;
    }
    console.log(email, "→", found);
  }
  console.log("вычислений SHA-256:", computed);
}

main();

Таблица не нашла ничего, и одинаковых хешей больше нет: пароль у anya и vera общий, а соль разная. Но перебор нашёл те же три пароля. Соль не делает слабый пароль сильным — она отменяет оптовую скидку. Раньше шесть вычислений вскрывали всю базу, а заодно и любую другую; теперь словарь считается заново для каждой строки: 24 вычисления на четыре строки, а в жизни — миллионы строк словаря на каждого из тысяч пользователей.

Не изменилось одно: попытка по-прежнему стоит один SHA-256. Этот хеш придуман быстрым — для проверки файла это достоинство. На машине автора один SHA-256 короткой строки в Node занимает около микросекунды: больше полумиллиона попыток в секунду на одном ядре, и это ещё с накладными расходами JavaScript на каждый вызов.

Сделать хеш медленным для злоумышленника можно только одним способом — сделать его медленным для всех. PBKDF2 прогоняет пароль с солью через HMAC-SHA256 заданное число раз, и каждый шаг берёт результат предыдущего: одну цепочку не распараллелить, шаги не пропустить. HMAC здесь тот же, которым подписывают токен входа, — его разберём в статье «Собираем токен: три части, подпись, срок, подделка». Число повторов называется стоимостью. В браузере PBKDF2 встроен в crypto.subtle: пароль импортируется как ключ, а deriveBits выдаёт нужное число бит.

OWASP сегодня советует для PBKDF2-HMAC-SHA256 не меньше 600 000 итераций. Посчитаем 1 000, 100 000 и 600 000 на вашей машине. Миллисекунды у каждого читателя свои, поэтому пример печатает соотношения. Прогноз: во сколько раз дольше 100 000 итераций, чем 1 000, и 600 000, чем 100 000?

async function pbkdf2(password: string, salt: BufferSource, iterations: number): Promise<Uint8Array> {
  const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, ["deriveBits"]);
  const bits = await crypto.subtle.deriveBits({ name: "PBKDF2", hash: "SHA-256", salt, iterations }, key, 256);
  return new Uint8Array(bits);
}

async function timeOf(iterations: number): Promise<number> {
  const start = performance.now();
  let calls = 0;
  // повторяем, пока не наберётся 100 мс: вызов в 1 000 итераций короче шага, которым браузер отмеряет время
  do {
    // соль каждый раз новая: Firefox запоминает результат PBKDF2 для тех же входных данных
    await pbkdf2("qwerty123", crypto.getRandomValues(new Uint8Array(16)), iterations);
    calls += 1;
  } while (performance.now() - start < 100);
  return (performance.now() - start) / calls;
}

const moreThan = (ratio: number, times: number) => (ratio > times ? "да" : "нет");

async function main() {
  // первый замер выбрасывается: он платит ещё и за подготовку движка
  await timeOf(1_000);
  const cheap = await timeOf(1_000);
  const middle = await timeOf(100_000);
  const recommended = await timeOf(600_000);
  console.log("100 000 итераций дольше 1 000 больше чем в 30 раз:", moreThan(middle / cheap, 30));
  console.log("600 000 итераций дольше 100 000 больше чем в 4 раза:", moreThan(recommended / middle, 4));
}

main();

Время растёт почти ровно по числу итераций. На машине автора 600 000 дольше 100 000 в шесть раз, а 100 000 дольше 1 000 — примерно в 80 раз, а не в 100: у дешёвого вызова заметная доля времени уходит на импорт ключа и сам вызов, а не на итерации. Каждая итерация — это HMAC, то есть два прохода SHA-256, так что 600 000 итераций — больше миллиона SHA-256 на одну попытку. Злоумышленник платит эту цену за каждую строку словаря, вы — за каждый вход: от десятков миллисекунд до сотни, раз в сессию.

Что именно это покупает? Переберём словарь по одной строке утёкшей базы — сначала при 1 000 итераций, потом при 100 000. У gleb пароль из словаря, у boris — нет. Прогноз: на какой попытке найдётся gleb при каждой стоимости и во сколько раз подорожает весь проход по словарю?

declare function pbkdf2(password: string, salt: BufferSource, iterations: number): Promise<Uint8Array>;
declare const dictionary: string[];

const equal = (a: Uint8Array, b: Uint8Array) => a.length === b.length && a.every((byte, i) => byte === b[i]);

// одна строка утёкшей базы и перебор словаря по ней
async function crack(password: string, iterations: number) {
  const salt = crypto.getRandomValues(new Uint8Array(16));
  const leaked = await pbkdf2(password, salt, iterations);
  const start = performance.now();
  let attempts = 0;
  for (const guess of dictionary) {
    attempts += 1;
    if (equal(await pbkdf2(guess, salt, iterations), leaked)) return { found: guess, attempts, ms: performance.now() - start };
  }
  return { found: "не найден", attempts, ms: performance.now() - start };
}

// один проход при 1 000 итераций короче шага, которым браузер отмеряет время,
// и на занятой машине тонет в накладных расходах: повторяем, пока не наберётся 100 мс
async function passOf(iterations: number) {
  const start = performance.now();
  let passes = 0;
  do {
    await crack("Кот-на-крыше-1987", iterations);
    passes += 1;
  } while (performance.now() - start < 100);
  return (performance.now() - start) / passes;
}

async function main() {
  const times: number[] = [];
  for (const iterations of [1_000, 100_000]) {
    const gleb = await crack("1q2w3e4r", iterations);
    const boris = await crack("Кот-на-крыше-1987", iterations);
    console.log(iterations, "итераций | gleb:", gleb.found, "за", gleb.attempts, "| boris:", boris.found, "за", boris.attempts);
    times.push(await passOf(iterations));
  }
  console.log("перебор дольше больше чем в 10 раз:", times[1] / times[0] > 10 ? "да" : "нет");
}

main();

gleb найден на четвёртой попытке при любой стоимости: пароль из верхушки словаря стоимость не спасает, его пробуют первым. boris не найден ни там, ни там, но проход, который это выяснил, подорожал в десятки раз, — ровно это стоимость и покупает. Настоящий словарь — миллионы строк. При сотне миллисекунд на попытку проход по миллиону строк против одного пользователя — больше суток работы одного ядра, против тысячи пользователей — годы. Ядер у злоумышленника больше одного, поэтому стоимость поднимают до предела, при котором вход ещё не ощущается. А от «qwerty123» не спасает ничто, кроме запрета на такие пароли при регистрации.

Стоимость — ручка, а не константа. Железо дешевеет, и число, честное сегодня, через несколько лет станет скидкой для перебора. Поэтому стоимость хранят рядом с хешем — об этом последний раздел.

У PBKDF2 есть слабость, которой не видно на одном ядре: ему почти не нужна память. Вся цепочка — несколько сотен байт состояния, и видеокарта с тысячами простых ядер ведёт тысячи таких цепочек сразу. Поэтому появились алгоритмы, которым на каждую попытку нужны мегабайты: scrypt и argon2id — вариант Argon2, победителя Password Hashing Competition 2015 года. Каждая одновременная попытка занимает свою память, и число попыток упирается уже не только в ядра, но и в объём и скорость памяти.

В Node все три алгоритма встроены в node:crypto, argon2 — начиная с 24.7.0. Прогон хеширует один пароль тремя алгоритмами с параметрами из OWASP, проверяет верный и неверный пароль, сравнивает проверку с одним SHA-256 и смотрит, на сколько вырос пик памяти процесса. Первым делом он пробует посчитать scrypt с рекомендованными параметрами как есть. Прогноз: чем кончится эта попытка и какой из трёх алгоритмов прибавит больше всего памяти?

import { argon2, createHash, pbkdf2, randomBytes, scrypt, timingSafeEqual } from 'node:crypto';
import { promisify } from 'node:util';

// параметры — минимум из OWASP Password Storage Cheat Sheet;
// пик памяти процесса только растёт, поэтому замер памяти зависит от порядка в этом списке
const algorithms = {
  'pbkdf2-sha256': {
    params: 'i=600000',
    derive: (password, salt, p) => promisify(pbkdf2)(password, salt, p.i, 32, 'sha256'),
  },
  argon2id: {
    params: 'v=19$m=19456,t=2,p=1',
    derive: (password, salt, p) =>
      promisify(argon2)('argon2id', { message: password, nonce: salt, memory: p.m, passes: p.t, parallelism: p.p, tagLength: 32 }),
  },
  scrypt: {
    params: 'ln=17,r=8,p=1',
    derive: (password, salt, p) =>
      promisify(scrypt)(password, salt, 32, { N: 2 ** p.ln, r: p.r, p: p.p, maxmem: 256 * 1024 * 1024 }),
  },
};

// "v=19$m=19456,t=2,p=1" → { v: 19, m: 19456, t: 2, p: 1 }
const readParams = (text) => Object.fromEntries(text.split(/[$,]/).map((pair) => pair.split('=')).map(([k, v]) => [k, Number(v)]));
const b64 = (bytes) => bytes.toString('base64').replace(/=+$/, '');

async function hashPassword(password, name) {
  const { params, derive } = algorithms[name];
  const salt = randomBytes(16);
  return `$${name}$${params}$${b64(salt)}$${b64(await derive(password, salt, readParams(params)))}`;
}

async function verifyPassword(password, stored) {
  const [, name, ...rest] = stored.split('$');
  const [salt, hash] = rest.splice(-2).map((part) => Buffer.from(part, 'base64'));
  const derived = await algorithms[name].derive(password, salt, readParams(rest.join('$')));
  return timingSafeEqual(derived, hash);
}

const yes = (flag) => (flag ? 'да' : 'нет');
const peakMiB = () => process.resourceUsage().maxRSS / 1024;

// сколько стоит одна попытка быстрым хешем
const start = performance.now();
for (let i = 0; i < 10_000; i += 1) createHash('sha256').update('qwerty123').digest();
const sha256 = (performance.now() - start) / 10_000;

try {
  await promisify(scrypt)('qwerty123', randomBytes(16), 32, { N: 2 ** 17, r: 8, p: 1 });
} catch (err) {
  console.log('scrypt с maxmem по умолчанию:', err.code);
  console.log(' ', err.message);
}

for (const name of Object.keys(algorithms)) {
  const before = peakMiB();
  const stored = await hashPassword('qwerty123', name);
  const memory = peakMiB() - before;
  const began = performance.now();
  const right = await verifyPassword('qwerty123', stored);
  const slower = (performance.now() - began) / sha256;
  const wrong = await verifyPassword('qwerty', stored);
  console.log(stored);
  console.log(`  верный: ${right} | неверный: ${wrong} | дольше SHA-256 больше чем в 1000 раз: ${yes(slower > 1000)}`);
  console.log(`  памяти прибавилось больше 16 МиБ: ${yes(memory > 16)} | больше 100 МиБ: ${yes(memory > 100)}`);
}

scrypt с maxmem по умолчанию: ERR_CRYPTO_INVALID_SCRYPT_PARAMS
  Invalid scrypt params: error:030000AC:digital envelope routines::memory limit exceeded
$pbkdf2-sha256$i=600000$<соль>$<хеш>
  верный: true | неверный: false | дольше SHA-256 больше чем в 1000 раз: да
  памяти прибавилось больше 16 МиБ: нет | больше 100 МиБ: нет
$argon2id$v=19$m=19456,t=2,p=1$<соль>$<хеш>
  верный: true | неверный: false | дольше SHA-256 больше чем в 1000 раз: да
  памяти прибавилось больше 16 МиБ: да | больше 100 МиБ: нет
$scrypt$ln=17,r=8,p=1$<соль>$<хеш>
  верный: true | неверный: false | дольше SHA-256 больше чем в 1000 раз: да
  памяти прибавилось больше 16 МиБ: да | больше 100 МиБ: да

scrypt с рекомендованными N: 2 ** 17 и r: 8 упал, не начав считать. Node ограничивает его память опцией maxmem — по умолчанию 32 МиБ, а этим параметрам нужно около 128 * N * r байт, 128 МиБ. Память здесь и есть стоимость, и её надо разрешить явно. Пик памяти процесса подтверждает это: PBKDF2 не прибавил и 16 МиБ, argon2id прибавил больше 16 (его m=19456 — килобайты, 19 МиБ), scrypt — больше 100.

Остальное у трёх строк общее, и это важнее выбора алгоритма. Проверка каждого в тысячи раз дороже одного SHA-256. Строка записана в формате PHC — $алгоритм$параметры$соль$хеш, и verifyPassword берёт из неё всё нужное, не зная, с какими параметрами хеш создавали. Асинхронные pbkdf2, scrypt и argon2 считаются в пуле потоков libuv, и цикл событий в это время свободен, а варианты *Sync держат его всё время счёта. Пул не резиновый — по умолчанию четыре потока, и пятый одновременный вход ждёт очереди; как это выглядит на настоящих числах — в статье «Настоящий цикл, libuv и пул потоков».

Порядок в таблице — порядок OWASP: argon2id, если его нет — scrypt; bcrypt — для систем, где он уже стоит; PBKDF2 — там, где требуется сертификация FIPS-140. Числа сверены с OWASP Password Storage Cheat Sheet 15 сентября 2026 года.

Своя схема вроде «SHA-256 от соли и пароля, и ещё раз SHA-256» почти всегда оказывается быстрым хешем в новой обёртке. Все четыре алгоритма из таблицы лежат в стандартной библиотеке или в одном пакете, изобретать тут нечего.

Прогон уже показал формат: алгоритм, параметры, соль и хеш в одной строке. Это не украшение. Стоимость придётся поднимать, а пересчитать старые хеши сервер не может — паролей у него нет. Значит, в базе годами живут строки разной стоимости, и проверять каждую надо её собственными параметрами.

Пересчитать хеш можно в единственный момент — при успешном входе: только тогда пароль у сервера в руках и уже известно, что он верный. Проверили строку её параметрами, увидели, что стоимость ниже нынешней, записали новый хеш. Сравнивают при этом без раннего выхода: === и every останавливаются на первом расхождении, и по времени ответа можно судить, сколько совпало до него. Для солёного хеша это скорее страховка, чем дыра — соли злоумышленник не знает и подобрать пароль под нужное начало хеша не может, — но страховка стоит одну функцию: в Node это timingSafeEqual, в песочнице — цикл с |=.

anya зарегистрировалась давно, при 1 000 итераций; сегодня стоимость — 100 000 (меньше рекомендованной, чтобы пример шёл быстро). Она ошибается паролем, потом входит дважды. Прогноз: после какого из трёх входов строка в базе сменит стоимость?

declare function pbkdf2(password: string, salt: BufferSource, iterations: number): Promise<Uint8Array>;
declare function toBase64(bytes: Uint8Array): string;
// <ArrayBuffer> — иначе TypeScript не пустит байты в crypto.subtle: SharedArrayBuffer он не принимает
declare function fromBase64(text: string): Uint8Array<ArrayBuffer>;

// стоимость сегодня; раньше регистрировали с 1 000
const ITERATIONS = 100_000;

async function hashPassword(password: string, iterations = ITERATIONS): Promise<string> {
  const salt = crypto.getRandomValues(new Uint8Array(16));
  const hash = await pbkdf2(password, salt, iterations);
  return `$pbkdf2-sha256$i=${iterations}$${toBase64(salt)}$${toBase64(hash)}`;
}

function parse(stored: string) {
  const [, , params, salt, hash] = stored.split("$");
  return { iterations: Number(params.slice("i=".length)), salt: fromBase64(salt), hash: fromBase64(hash) };
}

function equalBytes(a: Uint8Array, b: Uint8Array): boolean {
  if (a.length !== b.length) return false;
  let diff = 0;
  // без выхода на первом расхождении: время сравнения не должно зависеть от того, где разошлись байты
  for (let i = 0; i < a.length; i += 1) diff |= a[i] ^ b[i];
  return diff === 0;
}

async function verifyPassword(password: string, stored: string): Promise<boolean> {
  const { iterations, salt, hash } = parse(stored);
  return equalBytes(await pbkdf2(password, salt, iterations), hash);
}

const db = new Map<string, string>();

async function login(email: string, password: string): Promise<string> {
  const stored = db.get(email);
  if (!stored || !(await verifyPassword(password, stored))) return "неверный адрес или пароль";
  if (parse(stored).iterations < ITERATIONS) db.set(email, await hashPassword(password));
  return "вошла";
}

async function main() {
  db.set("anya@mail.ru", await hashPassword("qwerty123", 1_000));
  const cost = () => (db.get("anya@mail.ru") ?? "").split("$")[2];
  console.log("в базе:", cost());
  for (const password of ["qwerty", "qwerty123", "qwerty123"]) {
    const answer = await login("anya@mail.ru", password);
    console.log(password, "→", answer, "| в базе:", cost());
  }
}

main();

Неудачный вход строку не тронул и не должен: пароль был чужой, и записать его хеш значило бы сменить пароль на ошибочный. Первый удачный вход переписал строку на 100 000, второй уже ничего не менял. Тем, кто не заходит годами, старая стоимость так и останется; OWASP для таких предлагает со временем стирать хеши и просить задать пароль заново через восстановление.

У нового хеша есть побочный эффект, на котором стоит целая техника. Соль при каждом хешировании новая, поэтому строка меняется даже при том же пароле. Если подписать ссылку восстановления секретом, выведенным из текущего хеша, первая же смена пароля погасит все выданные ссылки; перехеширование при входе погасит их тоже. Как это устроено и чем за это платят — в статье «Восстановление пароля и письмо, которое обязано дойти».