Crypto #

import crypto from "crypto";

// atau import fungsi spesifik
import {
  createHash,
  createHmac,
  createCipheriv,
  createDecipheriv,
  randomBytes,
  randomUUID,
  scrypt,
  timingSafeEqual,
} from "crypto";

// daftar semua algoritma hash yang tersedia
const algoritmHash = crypto.getHashes();
console.log(algoritmHash);
// ["md5", "sha1", "sha256", "sha384", "sha512", "sha3-256", ...]

// daftar semua algoritma cipher yang tersedia
const algoritmCipher = crypto.getCiphers();
console.log(algoritmCipher);
// ["aes-128-cbc", "aes-256-gcm", "chacha20-poly1305", ...]

// hash string dengan SHA-256
function hashSHA256(data: string): string {
  return crypto.createHash("sha256").update(data, "utf-8").digest("hex");
}

// hash string dengan SHA-512
function hashSHA512(data: string): string {
  return crypto.createHash("sha512").update(data, "utf-8").digest("hex");
}

console.log(hashSHA256("Hello, World!"));
// "dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986d"

// hash selalu menghasilkan output yang sama untuk input yang sama
console.log(hashSHA256("Hello, World!") === hashSHA256("Hello, World!")); // true

// satu karakter berbeda menghasilkan hash yang sangat berbeda (avalanche effect)
console.log(hashSHA256("Hello, World!"));
// "dffd6021..."
console.log(hashSHA256("Hello, World?")); // tanda tanya, bukan tanda seru
// "f2d9e458..." — sama sekali berbeda

// hash bisa dalam format berbeda
function hashDenganFormat(
  data: string,
  algoritma: string = "sha256",
  format: "hex" | "base64" | "base64url" = "hex"
): string {
  return crypto.createHash(algoritma).update(data, "utf-8").digest(format);
}

console.log(hashDenganFormat("data", "sha256", "hex"));
// "3a6eb0790f39ac87c94f3856b2dd2c5d110e6811602261a9a923d3bb23adc8b7"

console.log(hashDenganFormat("data", "sha256", "base64"));
// "Om6weQ85rIfJTzhWst0sXREOaBFgImGpqSPTuyrty7c="

// hash Buffer (untuk file biner)
function hashBuffer(data: Buffer, algoritma: string = "sha256"): string {
  return crypto.createHash(algoritma).update(data).digest("hex");
}

// hash file secara streaming — untuk file besar
import { createReadStream } from "fs";

async function hashFile(filePath: string, algoritma: string = "sha256"): Promise<string> {
  return new Promise((resolve, reject) => {
    const hash = crypto.createHash(algoritma);
    const stream = createReadStream(filePath);

    stream.on("data", (chunk) => hash.update(chunk));
    stream.on("end", () => resolve(hash.digest("hex")));
    stream.on("error", reject);
  });
}

// verifikasi integritas file download
async function verifikasiFile(
  filePath: string,
  hashYangDiharapkan: string,
  algoritma: string = "sha256"
): Promise<boolean> {
  const hashAktual = await hashFile(filePath, algoritma);
  // BENAR: gunakan timingSafeEqual untuk perbandingan hash
  // mencegah timing attack
  const bufA = Buffer.from(hashAktual, "hex");
  const bufB = Buffer.from(hashYangDiharapkan, "hex");
  return bufA.length === bufB.length && crypto.timingSafeEqual(bufA, bufB);
}

// buat HMAC
function buatHMAC(data: string, kunci: string, algoritma: string = "sha256"): string {
  return crypto.createHmac(algoritma, kunci).update(data, "utf-8").digest("hex");
}

// verifikasi HMAC — WAJIB gunakan timingSafeEqual
function verifikasiHMAC(
  data: string,
  kunci: string,
  hmacYangDiterima: string,
  algoritma: string = "sha256"
): boolean {
  const hmacYangDihitung = buatHMAC(data, kunci, algoritma);

  // ANTI-PATTERN: perbandingan string biasa — rentan timing attack
  // return hmacYangDihitung === hmacYangDiterima; ✗

  // BENAR: timingSafeEqual — waktu perbandingan selalu konstan
  const bufA = Buffer.from(hmacYangDihitung, "hex");
  const bufB = Buffer.from(hmacYangDiterima, "hex");

  // panjang harus sama dulu sebelum timingSafeEqual
  if (bufA.length !== bufB.length) return false;
  return crypto.timingSafeEqual(bufA, bufB); // ✓
}

const kunci = process.env.HMAC_SECRET_KEY!;
const payload = JSON.stringify({ userId: 123, action: "transfer", jumlah: 500000 });

const signature = buatHMAC(payload, kunci);
console.log("Signature:", signature);

const valid = verifikasiHMAC(payload, kunci, signature);
console.log("Valid:", valid); // true

// payload dimodifikasi
const payloadDimodifikasi = JSON.stringify({ userId: 123, action: "transfer", jumlah: 999999 });
const validDimodifikasi = verifikasiHMAC(payloadDimodifikasi, kunci, signature);
console.log("Valid (dimodifikasi):", validDimodifikasi); // false

// buat URL dengan tanda tangan yang kedaluwarsa otomatis
function buatSignedURL(
  basePath: string,
  params: Record<string, string>,
  kunci: string,
  ttlDetik: number = 3600
): string {
  const kedaluwarsa = Math.floor(Date.now() / 1000) + ttlDetik;
  const semuaParam = { ...params, expires: String(kedaluwarsa) };

  // urutkan parameter agar signature deterministik
  const queryString = Object.entries(semuaParam)
    .sort(([a], [b]) => a.localeCompare(b))
    .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
    .join("&");

  const dataUntukSign = `${basePath}?${queryString}`;
  const signature = buatHMAC(dataUntukSign, kunci, "sha256").slice(0, 32);

  return `${dataUntukSign}&sig=${signature}`;
}

function verifikasiSignedURL(url: string, kunci: string): boolean {
  const [pathDanQuery, sigPart] = url.split("&sig=");
  if (!sigPart) return false;

  // cek kedaluwarsa
  const params = new URLSearchParams(pathDanQuery.split("?")[1]);
  const expires = Number(params.get("expires"));
  if (Date.now() / 1000 > expires) return false; // sudah kedaluwarsa

  // verifikasi signature
  const signatureYangDiharapkan = buatHMAC(pathDanQuery, kunci, "sha256").slice(0, 32);
  const bufA = Buffer.from(sigPart);
  const bufB = Buffer.from(signatureYangDiharapkan);
  return bufA.length === bufB.length && crypto.timingSafeEqual(bufA, bufB);
}

const ALGORITMA = "aes-256-gcm";
const PANJANG_KUNCI = 32; // 256 bit
const PANJANG_IV = 16;    // 128 bit — ukuran standar untuk GCM

interface HasilEnkripsi {
  ciphertext: string; // data terenkripsi dalam hex
  iv: string;         // initialization vector dalam hex
  authTag: string;    // authentication tag dalam hex
}

// enkripsi data
function enkripsi(plaintext: string, kunci: Buffer): HasilEnkripsi {
  // IV harus unik untuk setiap enkripsi — jangan pernah pakai ulang IV yang sama
  const iv = crypto.randomBytes(PANJANG_IV);

  const cipher = crypto.createCipheriv(ALGORITMA, kunci, iv);

  const encrypted = Buffer.concat([
    cipher.update(plaintext, "utf-8"),
    cipher.final(),
  ]);

  // ambil authentication tag — penting untuk verifikasi saat dekripsi
  const authTag = cipher.getAuthTag();

  return {
    ciphertext: encrypted.toString("hex"),
    iv: iv.toString("hex"),
    authTag: authTag.toString("hex"),
  };
}

// dekripsi data
function dekripsi(hasil: HasilEnkripsi, kunci: Buffer): string {
  const decipher = crypto.createDecipheriv(
    ALGORITMA,
    kunci,
    Buffer.from(hasil.iv, "hex")
  );

  // set authentication tag sebelum dekripsi — GCM akan verifikasi integritas
  decipher.setAuthTag(Buffer.from(hasil.authTag, "hex"));

  const decrypted = Buffer.concat([
    decipher.update(Buffer.from(hasil.ciphertext, "hex")),
    decipher.final(), // melempar error jika authTag tidak cocok
  ]);

  return decrypted.toString("utf-8");
}

// derive kunci dari password menggunakan scrypt
async function deriveKunci(password: string, salt: Buffer): Promise<Buffer> {
  return new Promise((resolve, reject) => {
    crypto.scrypt(password, salt, PANJANG_KUNCI, (err, derivedKey) => {
      if (err) reject(err);
      else resolve(derivedKey);
    });
  });
}

// contoh penggunaan end-to-end
async function contohEnkripsiDekripsi(): Promise<void> {
  const password = "password-rahasia-yang-kuat";
  const salt = crypto.randomBytes(32); // simpan salt bersama data terenkripsi

  const kunci = await deriveKunci(password, salt);

  const dataRahasia = JSON.stringify({
    kartuKredit: "4111-1111-1111-1111",
    cvv: "123",
    kedaluwarsa: "12/26",
  });

  // enkripsi
  const terenkripsi = enkripsi(dataRahasia, kunci);
  console.log("Terenkripsi:", terenkripsi);

  // dekripsi
  const terdekripsi = dekripsi(terenkripsi, kunci);
  console.log("Terdekripsi:", terdekripsi);
}

// ANTI-PATTERN: token dari Math.random() — tidak aman secara kriptografis
function tokenTidakAman(): string {
  return Math.random().toString(36).slice(2); // ✗ bisa diprediksi
}

// BENAR: token dari crypto.randomBytes()
function generateToken(panjangBytes: number = 32): string {
  return crypto.randomBytes(panjangBytes).toString("hex");
  // 32 bytes = 64 karakter hex = 256 bit entropy
}

function generateTokenBase64URL(panjangBytes: number = 32): string {
  return crypto.randomBytes(panjangBytes).toString("base64url");
  // base64url aman untuk URL — tanpa karakter +, /, =
}

// UUID v4 — identifier unik universal
function generateUUID(): string {
  return crypto.randomUUID();
  // "550e8400-e29b-41d4-a716-446655440000"
}

// OTP numerik N digit
function generateOTP(panjang: number = 6): string {
  // randomBytes menghasilkan nilai 0-255 per byte
  // untuk OTP numerik, ambil modulo 10 per digit
  const bytes = crypto.randomBytes(panjang);
  return Array.from(bytes)
    .map((b) => b % 10)
    .join("");
}

console.log(generateOTP(6));  // misal: "847261"
console.log(generateOTP(8));  // misal: "37291046"

// API key dengan format yang mudah dibaca: prefix + token
function generateAPIKey(prefix: string = "sk"): string {
  const token = crypto.randomBytes(24).toString("base64url");
  return `${prefix}_${token}`;
}

console.log(generateAPIKey("sk"));  // misal: "sk_a3mK9pLx..."
console.log(generateAPIKey("pk"));  // misal: "pk_7nRt2yBq..."

// token dengan kedaluwarsa
interface TokenDenganExpiry {
  token: string;
  kedaluwarsa: Date;
}

function generateTokenDenganExpiry(ttlMenit: number = 60): TokenDenganExpiry {
  const token = generateToken(32);
  const kedaluwarsa = new Date(Date.now() + ttlMenit * 60 * 1000);
  return { token, kedaluwarsa };
}

// simpan hash token di database, bukan token aslinya
// sehingga jika database bocor, token tidak bisa langsung digunakan
function hashToken(token: string): string {
  return crypto.createHash("sha256").update(token).digest("hex");
}

async function buatTokenResetPassword(userId: string): Promise<string> {
  const { token, kedaluwarsa } = generateTokenDenganExpiry(30); // 30 menit
  const hashTokenReset = hashToken(token);

  // simpan hash ke database
  await db.simpan("password_reset_tokens", {
    userId,
    tokenHash: hashTokenReset,
    kedaluwarsa,
  });

  // kembalikan token asli untuk dikirim ke email pengguna
  return token;
}

async function verifikasiTokenReset(token: string): Promise<string | null> {
  const hashTokenInput = hashToken(token);

  const record = await db.cari("password_reset_tokens", {
    tokenHash: hashTokenInput,
    kedaluwarsa: { $gt: new Date() }, // belum kedaluwarsa
  });

  return record?.userId ?? null;
}

// placeholder untuk db — implementasi sesuai database yang digunakan
const db = {
  simpan: async (_collection: string, _data: unknown) => {},
  cari: async (_collection: string, _query: unknown) => null as any,
};

interface HasilHashPassword {
  hash: string; // hash dalam hex
  salt: string; // salt dalam hex
}

// hash password baru
async function hashPassword(password: string): Promise<HasilHashPassword> {
  const salt = crypto.randomBytes(32); // salt unik per password

  return new Promise((resolve, reject) => {
    crypto.scrypt(
      password,
      salt,
      64,  // panjang output dalam bytes
      {
        N: 16384, // cost factor — semakin besar semakin lambat (default: 16384)
        r: 8,     // block size
        p: 1,     // parallelization factor
      },
      (err, derivedKey) => {
        if (err) reject(err);
        else resolve({
          hash: derivedKey.toString("hex"),
          salt: salt.toString("hex"),
        });
      }
    );
  });
}

// verifikasi password
async function verifikasiPassword(
  passwordInput: string,
  hashTersimpan: string,
  saltTersimpan: string
): Promise<boolean> {
  const salt = Buffer.from(saltTersimpan, "hex");

  return new Promise((resolve, reject) => {
    crypto.scrypt(passwordInput, salt, 64, { N: 16384, r: 8, p: 1 }, (err, derivedKey) => {
      if (err) reject(err);
      else {
        const hashInput = derivedKey;
        const hashDB = Buffer.from(hashTersimpan, "hex");

        // timingSafeEqual — mencegah timing attack
        if (hashInput.length !== hashDB.length) {
          resolve(false);
        } else {
          resolve(crypto.timingSafeEqual(hashInput, hashDB));
        }
      }
    });
  });
}

// contoh alur registrasi dan login
async function registrasi(email: string, password: string): Promise<void> {
  const { hash, salt } = await hashPassword(password);
  await db.simpan("users", { email, passwordHash: hash, passwordSalt: salt });
  console.log("User berhasil dibuat");
}

async function login(email: string, passwordInput: string): Promise<boolean> {
  const user = await db.cari("users", { email });
  if (!user) return false;

  return verifikasiPassword(passwordInput, user.passwordHash, user.passwordSalt);
}

import bcrypt from "bcrypt";

// JANGAN diinstall jika belum perlu — scrypt bawaan Node.js sudah cukup
// npm install bcrypt
// npm install --save-dev @types/bcrypt

const SALT_ROUNDS = 12; // 10–14 adalah rentang yang umum digunakan

async function hashPasswordBcrypt(password: string): Promise<string> {
  return bcrypt.hash(password, SALT_ROUNDS);
  // bcrypt mengelola salt secara internal — tidak perlu generate manual
}

async function verifikasiPasswordBcrypt(
  passwordInput: string,
  hashTersimpan: string
): Promise<boolean> {
  return bcrypt.compare(passwordInput, hashTersimpan);
  // bcrypt.compare sudah timing-safe secara internal
}

// ANTI-PATTERN: perbandingan string biasa untuk nilai keamanan
function verifikasiTokenTidakAman(tokenInput: string, tokenSah: string): boolean {
  return tokenInput === tokenSah; // ✗ rentan timing attack
}

// BENAR: timingSafeEqual — selalu membandingkan seluruh string
function verifikasiTokenAman(tokenInput: string, tokenSah: string): boolean {
  // konversi ke Buffer dulu — timingSafeEqual hanya menerima Buffer
  const bufInput = Buffer.from(tokenInput, "utf-8");
  const bufSah = Buffer.from(tokenSah, "utf-8");

  // panjang harus sama — jika tidak, kembalikan false tapi tetap konstan waktu
  if (bufInput.length !== bufSah.length) {
    // XOR dengan dirinya sendiri agar tetap ada operasi yang butuh waktu konstan
    crypto.timingSafeEqual(bufSah, bufSah);
    return false;
  }

  return crypto.timingSafeEqual(bufInput, bufSah); // ✓
}