Bcrypt Generator & Hash Verifier Online

Apa Itu Algoritma Hashing Bcrypt & Mengapa MD5/SHA Tidak Boleh Digunakan?

Bcrypt adalah fungsi hashing kata sandi adaptif satu arah (one-way adaptive cryptographic password hashing function) yang dirancang oleh ilmuwan komputer Niels Provos dan David Mazières pada tahun 1999 untuk sistem operasi OpenBSD. Algoritma ini dibangun berbasis sandi blok Eksblowfish (Extended Eksblowfish Key Setup) yang memiliki karakteristik komputasi intensif dan sengaja dirancang lambat untuk menggagalkan upaya peretasan massal berbasis hardware modern seperti GPU cluster dan ASIC rig.

Banyak pengembang web pemula melakukan kesalahan fatal dalam arsitektur keamanan dengan menyimpan kata sandi pengguna menggunakan algoritma MD5, SHA-1, atau SHA-256. Algoritma keluarga SHA dan MD5 dirancang sebagai general-purpose cryptographic hash yang dituntut berjalan secepat mungkin untuk keperluan verifikasi integritas data, checksum berkas biner, dan tanda tangan digital. Kecepatan komputasi super tinggi tersebut justru menjadi bencana besar saat diterapkan pada proteksi kata sandi pengguna.

Bagaimana Algoritma Bcrypt & Eksblowfish Bekerja di Balik Layar?

Arsitektur inti Bcrypt mengandalkan varian modifikasi dari cipher Blowfish bernama Eksblowfish (Extended Key Schedule Blowfish). Proses hashing dibagi menjadi tiga tahapan komputasi matematis yang ketat:

1. Inisialisasi State Eksblowfish (P-Array & S-Boxes): Bcrypt menginisialisasi 18 buah subkey 32-bit (disebut P-Array) dan 4 buah Substitution Boxes (S-Boxes, masing-masing berisi 256 entri 32-bit) menggunakan angka pecahan konstanta heksadesimal dari bilangan Pi ($\pi$).
2. EksblowfishSetup Loop (Key Stretching dengan Salt): Sistem menjalankan fungsi EksblowfishSetup(cost, salt, password). Pada tahap ini, state internal dienkripsi berulang-ulang menggunakan kombinasi Salt 128-bit dan kata sandi pengguna sebanyak $2^{\text{cost}}$ putaran (rounds). Pada Cost Factor 10, proses key expansion ini diulang sebanyak 1.024 kali; pada Cost 12 diulang 4.096 kali. Hal ini memastikan bahwa pembuatan hash membutuhkan waktu CPU yang dapat dikontrol oleh pemilik server.
3. Enkripsi String Teks Tetap (Ciphertext Generation): Setelah state internal selesai diacak dan diperluas melalui ribuan putaran, algoritma menggunakan state tersebut untuk mengenkripsi string teks tetap berukuran 192-bit (24 karakter) berupa string ASCII: "OrpheanBeholderScryDoubt" String ini dienkripsi sebanyak 64 kali berturut-turut dalam mode CBC (Cipher Block Chaining). Hasil 192-bit ciphertext inilah yang kemudian dikodekan ke dalam format Base64 khusus 31 karakter sebagai representasi akhir hash.

Anatomi dan Struktur Format String Hash Bcrypt (60 Karakter)

Setiap output hash yang dihasilkan oleh algoritma Bcrypt memiliki panjang persis 60 karakter ASCII yang terbagi menjadi empat segmen modular yang dipisahkan oleh karakter pembatas dolar ($). Seluruh informasi yang dibutuhkan untuk proses verifikasi kata sandi di masa depan (algoritma, cost factor, salt, dan ciphertext) telah terkemas rapi di dalam string 60 karakter ini.

Evolusi Prefix Identifier ($2a$, $2b$, $2y$, $2x$)

• $2a$: Spesifikasi asli implementasi Bcrypt OpenBSD yang diterbitkan pada tahun 1999.
• $2y$: Standar resmi yang diperkenalkan pada PHP 5.3.7 untuk memperbaiki bug komparasi karakter 8-bit pada implementasi pustaka Crypt PHP tanpa merusak kompatibilitas hash yang ada.
• $2b$: Standar modern OpenBSD yang dirilis pada Februari 2014 untuk memperbaiki celah pembacaan panjang kata sandi (wrap-around bug) pada implementasi kernel OpenBSD asli.
• $2x$: Identifier historis PHP untuk menandai hash yang pernah dibuat dengan bug penanganan karakter UTF-8 lawas.

Tabel Benchmark Cost Factor (Work Factor Rounds)

Kekuatan utama Bcrypt terletak pada parameter Cost Factor (Work Factor) yang adaptif terhadap hukum Moore. Setiap penambahan nilai cost sebesar +1 akan menggandakan secara eksponensial (2x lipat) jumlah operasi komputasi dan durasi waktu yang dibutuhkan prosesor untuk memproses sebuah kata sandi.

Perbandingan Kriptografi: Bcrypt vs Argon2id vs PBKDF2 vs Scrypt

Dalam lanskap keamanan siber modern, terdapat beberapa algoritma password hashing yang diakui oleh OWASP dan NIST. Memahami perbedaan mendasar tiap algoritma membantu Anda menentukan strategi arsitektur autentikasi yang tepat:

Panduan Implementasi Kode Bcrypt di Berbagai Bahasa Pemrograman

Berikut adalah contoh implementasi kode produksi yang aman dan mengikuti standar terbaik untuk melakukan hashing serta verifikasi password di PHP, Node.js, Python, Golang, Java (Spring Security), dan C# (.NET):

<?php
// 1. Generate Bcrypt Hash dengan custom cost 12
$passwordPlain = 'P@ssw0rdRahasia2025!';
$hash = password_hash($passwordPlain, PASSWORD_BCRYPT, ['cost' => 12]);

echo "Bcrypt Hash: " . $hash . "\n";
// Output: $2y$12$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy

// 2. Verifikasi Password Saat User Login
$inputUser = 'P@ssw0rdRahasia2025!';
if (password_verify($inputUser, $hash)) {
    echo "Login Berhasil: Password Valid!\n";
    
    // 3. Otomatis rehash jika standar cost sistem dinaikkan
    if (password_needs_rehash($hash, PASSWORD_BCRYPT, ['cost' => 12])) {
        $newHash = password_hash($inputUser, PASSWORD_BCRYPT, ['cost' => 12]);
        // Simpan $newHash ke database pengguna
    }
} else {
    echo "Login Gagal: Password Salah!\n";
}
?>

const bcrypt = require('bcryptjs');

async function handlePasswordSecurity() {
    const plainPassword = 'P@ssw0rdRahasia2025!';
    const saltRounds = 12;

    // 1. Generate Hash Async (Non-blocking Event Loop)
    const hashedPassword = await bcrypt.hash(plainPassword, saltRounds);
    console.log('Generated Hash:', hashedPassword);

    // 2. Verifikasi Password Saat Pengguna Login
    const userInput = 'P@ssw0rdRahasia2025!';
    const isMatch = await bcrypt.compare(userInput, hashedPassword);

    if (isMatch) {
        console.log('Autentikasi Sukses: Password Cocok');
    } else {
        console.log('Autentikasi Gagal: Password Tidak Cocok');
    }
}

handlePasswordSecurity();

import bcrypt

# 1. Hashing Password dengan Cost Factor 12
password = "P@ssw0rdRahasia2025!".encode('utf-8')
salt = bcrypt.gensalt(rounds=12)
hashed_password = bcrypt.hashpw(password, salt)

print("Bcrypt Hash:", hashed_password.decode('utf-8'))

# 2. Verifikasi Password Saat Otentikasi
input_password = "P@ssw0rdRahasia2025!".encode('utf-8')

if bcrypt.checkpw(input_password, hashed_password):
    print("Password Valid: Akses Diberikan")
else:
    print("Password Tidak Valid: Akses Ditolak")

package main

import (
	"fmt"
	"golang.org/x/crypto/bcrypt"
)

func main() {
	password := []byte("P@ssw0rdRahasia2025!")

	// 1. Generate Hash dengan Cost Factor 12
	hashedPassword, err := bcrypt.GenerateFromPassword(password, 12)
	if err != nil {
		panic(err)
	}
	fmt.Println("Hash:", string(hashedPassword))

	// 2. Verifikasi Password
	err = bcrypt.CompareHashAndPassword(hashedPassword, []byte("P@ssw0rdRahasia2025!"))
	if err == nil {
		fmt.Println("Password Cocok!")
	} else {
		fmt.Println("Password Salah!")
	}
}

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public class PasswordSecurityService {
    public static void main(String[] args) {
        // Inisialisasi encoder dengan strength/cost factor 12
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder(12);

        String plainPassword = "P@ssw0rdRahasia2025!";

        // 1. Generate Bcrypt Hash
        String hashedPassword = passwordEncoder.encode(plainPassword);
        System.out.println("Generated Bcrypt Hash: " + hashedPassword);

        // 2. Verifikasi Password Saat Login
        String userInputPassword = "P@ssw0rdRahasia2025!";
        boolean isMatch = passwordEncoder.matches(userInputPassword, hashedPassword);

        if (isMatch) {
            System.out.println("Login Berhasil: Password Valid!");
        } else {
            System.out.println("Login Gagal: Password Salah!");
        }
    }
}

using System;
using BCrypt.Net;

namespace AppSecurity
{
    public class Program
    {
        public static void Main()
        {
            string rawPassword = "P@ssw0rdRahasia2025!";
            int workFactor = 12;

            // 1. Generate Bcrypt Hash dengan custom work factor 12
            string passwordHash = BCrypt.Net.BCrypt.HashPassword(rawPassword, workFactor);
            Console.WriteLine($"Hash: {passwordHash}");

            // 2. Verifikasi Password Saat Pengguna Login
            string loginInput = "P@ssw0rdRahasia2025!";
            bool isValid = BCrypt.Net.BCrypt.Verify(loginInput, passwordHash);

            if (isValid)
            {
                Console.WriteLine("Otentikasi Berhasil: Password Cocok");
            }
            else
            {
                Console.WriteLine("Otentikasi Gagal: Password Tidak Cocok");
            }
        }
    }
}

Batasan Kritis 72-Byte Algoritma Bcrypt & Cara Mengatasinya

Salah satu karakteristik arsitektur internal dari sandi blok Blowfish yang menjadi fondasi Bcrypt adalah adanya batasan panjang kata sandi maksimal 72 byte.

Strategi Solusi Terbaik: Pre-Hashing (Bcrypt + HMAC-SHA256)

Untuk aplikasi skala besar yang mengizinkan *passphrase* panjang (lebih dari 72 karakter) atau mendukung karakter multi-byte bebas tanpa risiko pemotongan, solusi yang direkomendasikan OWASP adalah menerapkan Pre-Hashing sebelum diteruskan ke fungsi Bcrypt:

1. Input kata sandi pengguna di-hash terlebih dahulu menggunakan HMAC-SHA256 dengan Server Pepper rahasia yang disimpan di environment server terpisah.
2. Hasil digest SHA-256 yang selalu berukuran tetap 32 byte (atau 44 karakter Base64) kemudian di-hash menggunakan algoritma Bcrypt dengan cost factor 12.

FAQ: Tanya Jawab Seputar Algoritma Bcrypt & Password Security