API, Autentikasi, dan Keamanan · 3/7

Password: hashing, salting, dan jangan pernah menyimpan plaintext

Satu topik di mana menyalin jawaban Stack Overflow sembarangan bisa berakibat buruk bagi orang sungguhan.

Baca 28 menit

Setelah pelajaran ini kamu bisa

Menjelaskan kenapa hashing bukan encryption
Menjelaskan kenapa hash yang cepat adalah alat yang salah
Menjelaskan apa yang dicegah oleh salt
Membandingkan password dalam waktu konstan

Jangan pernah menyimpan password. Simpan sebuah hash — transformasi satu arah tanpa jalan kembali. Saat seseorang masuk, hash apa yang mereka ketik lalu bandingkan hash-nya.

Kenapa bukan SHA-256

SHA-256 adalah hash yang bagus dan alat yang salah di sini, karena satu alasan: ia cepat. Cepat itu keunggulan saat meng-hash sebuah file dan bencana saat meng-hash password, karena penyerang yang punya database-mu menebak secara offline, secepat yang diizinkan perangkat kerasnya.

Coba sendiri

SHA-256 sungguhan, lewat Web Crypto API yang sudah dimiliki browser-mu. Ukur berapa banyak tebakan yang diizinkannya.

const encoder = new TextEncoder();

async function sha256(text) {
  const digest = await crypto.subtle.digest("SHA-256", encoder.encode(text));
  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
}

console.log("sha256('password123') =");
console.log("  ", await sha256("password123"));
console.log("");
console.log("The same input always gives the same output:");
console.log("  ", (await sha256("password123")) === (await sha256("password123")));
console.log("");

// How many guesses per second, in single-threaded JavaScript?
const COUNT = 2000;
const start = performance.now();
for (let i = 0; i < COUNT; i++) await sha256("guess" + i);
const ms = performance.now() - start;
const perSecond = Math.round(COUNT / (ms / 1000));

console.log("hashed " + COUNT + " guesses in " + ms.toFixed(0) + "ms");
console.log("=> about " + perSecond.toLocaleString() + " guesses per second, in a browser tab");
console.log("");
console.log("A purpose-built GPU rig does BILLIONS of SHA-256 per second.");
console.log("Against that, every password in a leaked database that is not");
console.log("long and random is recovered within hours.");

Hasil

Tekan Jalankan untuk melihat hasilnya.

Ini jalan di browser kamu, di dalam sandbox. Apa pun yang kamu tulis di sini tidak bisa merusak situs.

Function hashing password dibuat lambat dan lapar memori dengan sengaja. Diukur di mesin yang menulis pelajaran ini: scrypt dengan N=16384 butuh 37,5 ms per hash, dibanding 0,018 ms untuk SHA-256 — kira-kira dua ribu kali lebih lambat. Itu 37,5 ms yang tidak kamu sadari saat login, dan pajak dua ribu kali lipat untuk setiap tebakan yang dibuat penyerang.

Pakai	Untuk password?
argon2	Ya — pilihan pertama saat ini
scrypt	Ya — dan sudah ada di dalam Node, itu sebabnya proyek ini memakainya
bcrypt	Ya — tua tapi masih layak
PBKDF2	Bisa diterima kalau diwajibkan untuk kepatuhan
SHA-256, SHA-512, MD5	Tidak. Cepat secara desain.

Salt

Salt adalah data acak yang dicampurkan ke setiap password sebelum di-hash, dan disimpan bersama hasilnya. Artinya dua user dengan password sama mendapat hash berbeda.

Coba sendiri

Apa yang dicegah salt. Hashing sungguhan lagi — perhatikan kolom tanpa salt.

const encoder = new TextEncoder();
async function sha256(text) {
  const d = await crypto.subtle.digest("SHA-256", encoder.encode(text));
  return [...new Uint8Array(d)].map((b) => b.toString(16).padStart(2, "0")).join("");
}
function randomSalt() {
  const bytes = crypto.getRandomValues(new Uint8Array(8));
  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
}

const users = [
  { name: "Ana", password: "password123" },
  { name: "Budi", password: "password123" },   // same password
  { name: "Citra", password: "letmein" },
];

console.log("--- WITHOUT a salt ---");
for (const u of users) {
  console.log("  " + u.name.padEnd(7) + (await sha256(u.password)).slice(0, 24) + "...");
}
console.log("  Ana and Budi have identical hashes. An attacker who cracks one");
console.log("  has cracked both - and can spot the most common password in the");
console.log("  database just by counting duplicates.");

console.log("");
console.log("--- WITH a per-user salt ---");
for (const u of users) {
  const salt = randomSalt();
  const hash = await sha256(salt + u.password);
  console.log("  " + u.name.padEnd(7) + hash.slice(0, 24) + "...  salt=" + salt);
}
console.log("  Identical passwords, different hashes. No duplicates to count,");
console.log("  and a precomputed rainbow table is useless.");

Hasil

Tekan Jalankan untuk melihat hasilnya.

Ini jalan di browser kamu, di dalam sandbox. Apa pun yang kamu tulis di sini tidak bisa merusak situs.

Membandingkan dalam waktu konstan

a === b pada string berhenti di karakter pertama yang berbeda. Itu membuatnya cepat saat jawabannya tidak — dan itu membocorkan informasi tentang seberapa banyak bagian nilainya yang sudah benar.

Coba sendiri

Kebocoran waktu, terukur. Bandingkan berapa karakter yang diperiksa masing-masing perbandingan.

const secret = "a3f9c1e77b2d4e5f8a0b1c2d3e4f5061";

// Early-exit comparison, like === does.
function naiveEquals(a, b) {
  let examined = 0;
  if (a.length !== b.length) return { equal: false, examined: 0 };
  for (let i = 0; i < a.length; i++) {
    examined++;
    if (a[i] !== b[i]) return { equal: false, examined: examined };
  }
  return { equal: true, examined: examined };
}

// Constant time: always look at every character.
function constantTimeEquals(a, b) {
  if (a.length !== b.length) return { equal: false, examined: 0 };
  let diff = 0;
  for (let i = 0; i < a.length; i++) {
    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);   // accumulate, never exit early
  }
  return { equal: diff === 0, examined: a.length };
}

const guesses = [
  "00000000000000000000000000000000",
  "a0000000000000000000000000000000",
  "a3f00000000000000000000000000000",
  "a3f9c1e77b2d4e5f0000000000000000",
  secret,
];

console.log("naive comparison - characters examined per guess:");
for (const g of guesses) {
  const r = naiveEquals(secret, g);
  console.log("   " + g.slice(0, 18) + "...  examined " + String(r.examined).padStart(3) + "  equal=" + r.equal);
}
console.log("   The count rises with each correct character. An attacker who can");
console.log("   measure that learns the secret one character at a time.");

console.log("");
console.log("constant time - characters examined per guess:");
for (const g of guesses) {
  const r = constantTimeEquals(secret, g);
  console.log("   " + g.slice(0, 18) + "...  examined " + String(r.examined).padStart(3) + "  equal=" + r.equal);
}
console.log("   Always the same. Nothing leaks.");

Hasil

Tekan Jalankan untuk melihat hasilnya.

Ini jalan di browser kamu, di dalam sandbox. Apa pun yang kamu tulis di sini tidak bisa merusak situs.

Tugas praktik

Baca features/auth/password.ts di proyek ini dan features/auth/password.node.test.ts di sebelahnya. Temukan test bernama "rejects a truncated hash of the correct prefix" lalu hapus pemeriksaan expected.length !== KEY_LENGTH di implementasinya. Jalankan bun run test password dan lihat test itu gagal. Kembalikan lagi. Itulah nilai dari sebuah test keamanan.

Hasil yang diharapkan

Satu test gagal, dan itulah celah keamanannya tertangkap.

Cek pemahaman

Kenapa SHA-256 pilihan yang salah untuk meng-hash password?

Ia tidak aman — sudah berhasil dipecahkanIa terlalu cepat, jadi penyerang yang punya database-mu bisa menebak password dalam jumlah sangat besarOutput-nya terlalu pendekIa tidak bisa diberi salt

Pilih jawaban dulu