uToolGo Alat Kecil, Dampak Besar

Alat Generasi dan Validasi Kata Sandi

Hasilkan kata sandi kuat dan frasa sandi, dukung validasi massal, keunikan, kekuatan, dan kebijakan, serta sediakan contoh kode multi-bahasa dan pengetahuan praktis.

Pembuat Kata Sandi

Jumlah
Pilih grup simbol
Grup
Umum
Huruf kecil
Huruf besar
Angka
Simbol (berdasarkan grup saat ini)
Tips: Anda dapat mengecualikan dengan memilih grup atau langsung mengklik karakter.
Hasil

Penguji Kebijakan Kata Sandi

Hasil
  • Panjang
  • Huruf Kecil
  • Huruf Besar
  • Angka
  • Simbol
  • Urutan Berurutan
  • Pengulangan
  • Daftar Hitam
Semua pemeriksaan dilakukan secara lokal di browser Anda.

Pembuat Frasa Sandi

Kata dipilih secara acak aman (Web Crypto). Daftar kata demo dibatasi ukurannya.

Tabel Referensi Hash Kata Sandi

Argon2id
  • Gunakan Argon2id dengan parameter memori yang cukup kuat
  • Iterasi ≥ 2, memori ≥ 64MB (sesuaikan berdasarkan lingkungan)
  • Gunakan salt terpisah per pengguna; opsional gunakan pepper di lapisan aplikasi
PBKDF2
  • Pilih SHA-256 atau SHA-512, iterasi ≥ 210k (sesuaikan sesuai kebutuhan)
  • Gunakan salt unik untuk setiap hash; dukung peningkatan parameter
  • Migrasi ke parameter biaya lebih tinggi saat pengguna login berikutnya
BCrypt
  • Biaya 10–14, sesuaikan dengan kemampuan server
  • Hindari masalah pemotongan; lakukan hashing pada seluruh kata sandi
  • Terapkan rate limiting dan pemantauan pada endpoint otentikasi
Referensi: NIST SP 800-63B, OWASP ASVS. Parameter harus disesuaikan dengan kapasitas perangkat keras dan SLO.

Evaluasi Kekuatan Kata Sandi

Kekuatan diperkirakan berdasarkan entropi: entropy = log2(ukuran kumpulan karakter) × panjang. Kumpulan karakter yang lebih besar dan panjang yang lebih panjang meningkatkan ketahanan terhadap tebakan.

  • Lemah: < 50 bit —— Hanya cocok untuk skenario sementara/nilai rendah
  • Cukup: 50–80 bit —— Dapat diterima untuk skenario berisiko rendah
  • Kuat: 80–110 bit —— Target default yang disarankan
  • Sangat Kuat: > 110 bit —— Cocok untuk akun admin/kritis

Catatan: Model serangan nyata bisa berbeda; hindari penggunaan ulang kata sandi dan aktifkan otentikasi multi-faktor (MFA).

Petunjuk Penggunaan

  • Pilih panjang dan himpunan karakter (Lower/Upper/Digits/Symbols); aktifkan Hindari Mirip dan Wajib Setiap jika diperlukan
  • Untuk kontrol lebih detail: eksklusikan karakter/himpunan karakter, atau pilih grup simbol
  • Klik generasi; untuk hasil banyak, aktifkan generasi massal dan salin semua dengan satu klik
  • Untuk memvalidasi kata sandi yang sudah ada, gunakan "Penguji Kebijakan"; untuk frasa sandi yang mudah diingat, gunakan "Generator Frasa Sandi"

Fitur Utama

  • Sumber acak aman (Web Crypto)
  • Himpunan karakter dan grup simbol yang dapat dikonfigurasi
  • Penyaringan karakter serupa dan eksklusi khusus
  • Generasi massal, jaminan keunikan, dan statistik penghapusan duplikat
  • Indikator kekuatan dan entropi
  • Penguji Kebijakan dan Generator Frasa Sandi
  • Contoh kode multi-bahasa （JS、Python、PHP、Go、Java、C#、Rust）
  • Salin satu klik (satu baris/semua)

Contoh Generasi Kata Sandi

Kuat (Strong)
Panjang 24, mencakup huruf besar/kecil/angka/simbol
Mudah Diingat (Memorable)
Panjang 16, mencakup huruf besar/kecil/angka, hindari karakter serupa

Basis Pengetahuan Kata Sandi

1) Kekuatan Kata Sandi dan Entropi
  • Entropi ≈ log2(ukuran kumpulan karakter) × panjang; kontribusi panjang biasanya lebih besar
  • Target yang disarankan: Akun umum ≥ 80 bit; akun berwewenang tinggi/keuangan ≥ 110 bit
  • Kumpulan karakter lebih besar + panjang lebih panjang → lebih tahan terhadap tebakan
2) Panjang vs Kompleksitas
  • Menambahkan simbol secara sembarangan kurang efektif daripada memperpanjang panjang
  • Hindari pola yang bisa diprediksi (misalnya selalu "huruf kapital di awal + angka di akhir!")
  • Prioritaskan panjang yang cukup, lalu tingkatkan keragaman karakter secara sewajarnya
3) Kesalahan Umum dan Pola Buruk
  • Urutan papan ketik (qwerty), blok berulang, tanggal lahir/tahun, dll. mudah ditebak oleh aturan
  • "Kata sandi induk + sufiks situs" adalah bentuk pengulangan varian, berisiko terkonsentrasi dan mudah ditebak
  • Jangan gunakan kata sandi yang sama di beberapa situs
4) Saran Manajemen Kata Sandi
  • Gunakan manajer kata sandi; setiap situs memiliki kata sandi unik; aktifkan MFA untuk akun penting
  • Hindari mengirim kata sandi dalam bentuk teks biasa melalui saluran publik; jika perlu, gunakan "kata sandi ramah pelafalan"
  • Segera ganti dan pastikan unik jika menemukan kebocoran atau penggunaan ulang
5) Panduan Passphrase
  • Kombinasi beberapa kata (4–6 kata) biasanya kuat dan mudah diingat
  • Campurkan pemisah, huruf kapital di awal, dan sisipkan angka untuk meningkatkan kekuatan dan keterbacaan
  • Hindari penggabungan langsung frase umum/lirik lagu/kutipan terkenal

Panduan Praktik Keamanan Kata Sandi

Praktik Terbaik
  • Gunakan panjang yang cukup: akun umum 16+ karakter, akun kritis 24+ karakter
  • Untuk kebutuhan ingatan, prioritaskan frasa sandi; untuk sandi acak kuat, gunakan manajer sandi
  • Aktifkan otentikasi multi-faktor (MFA) sebisa mungkin
  • Jangan gunakan ulang sandi di situs berbeda; setiap akun harus memiliki sandi unik
Entropi dan Kekuatan

Entropi mengukur ketidakterdugaan berdasarkan panjang dan ukuran kumpulan karakter; semakin tinggi bit entropi, biasanya semakin kuat.

  • Tingkatkan panjang terlebih dahulu untuk mendapatkan manfaat maksimal
  • Gunakan berbagai himpunan karakter jika memungkinkan
  • Menghindari karakter tertentu secara berlebihan akan memperkecil kumpulan karakter dan mengurangi kekuatan
Kebijakan dan Rotasi
  • Lebih prioritaskan panjang dan daftar hitam sandi umum/terbocor daripada aturan komposisi rumit
  • Hindari rotasi paksa yang sering; ubah hanya saat terjadi kebocoran atau risiko
  • Gunakan daftar sandi yang telah bocor untuk mencegah penggunaan sandi umum/terbocor
Frasa Sandi
  • Gunakan 4–6 kata acak yang dipisahkan oleh pemisah, misalnya lake-CARROT-planet_7
  • Hindari kutipan, lirik lagu, atau frasa umum lainnya; keacakan lebih penting daripada 'kecerdasan'
  • Untuk akun kritis, disarankan menggunakan manajer sandi untuk menyimpan sandi acak dengan entropi tinggi
Petunjuk Pengaturan Pembuat
  • "Require each selected set" memastikan setiap jenis karakter muncul minimal sekali
  • "Avoid similar" meningkatkan keterbacaan, tetapi sedikit mengurangi ukuran kumpulan karakter
  • Simbol dapat dibatasi pada subset yang diterima oleh sistem target
Penyimpanan di Sisi Server
  • Jangan pernah menyimpan sandi dalam bentuk teks biasa; gunakan hash kuat (Argon2id/PBKDF2/BCrypt) dengan salt
  • Atur parameter secara tepat (memori/waktu/biaya); gunakan pepper jika diperlukan
  • Batasi laju percobaan dan pantau upaya gagal; tambahkan CAPTCHA atau verifikasi perangkat saat terjadi serangan
Multi-Faktor dan Pemulihan
  • Prioritaskan TOTP/kunci hardware; hindari SMS sebisa mungkin
  • Lindungi proses pemulihan: gunakan multi-faktor atau verifikasi email dengan periode pendinginan
  • Sediakan kode pemulihan cadangan dan anjurkan pengguna untuk menyimpannya dengan aman
Pertahanan terhadap Serangan Brute Force
  • Gunakan penundaan/proses pemblokiran progresif dan skor risiko IP/perangkat
  • Konfigurasikan WAF/limitasi laju untuk API dan formulir login
  • Pantau serangan credential stuffing dan dorong pengguna menggunakan sandi unik
Penyimpanan dan Pemrosesan Lokal
  • Gunakan manajer sandi yang andal untuk penyimpanan dan pengisian otomatis
  • Jangan bagikan sandi dalam bentuk teks biasa melalui obrolan/email; gunakan alat manajemen rahasia untuk tim
  • Jika perlu mencatat secara manual, pastikan keamanan fisik
Pernyataan: Alat ini menghasilkan sandi di browser secara lokal menggunakan Web Crypto; tidak mengirim data ke server.

Cara Menghasilkan Kata Sandi Melalui Bahasa Pemrograman

JavaScript（Web Crypto）
function randomPassword(length = 16, sets = {lower:true, upper:true, digits:true, symbols:true}) {
  const pools = {
    lower: 'abcdefghijklmnopqrstuvwxyz',
    upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
    digits: '0123456789',
    symbols: '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
  };
  let pool = '';
  for (const k of Object.keys(sets)) if (sets[k]) pool += pools[k];
  if (!pool) throw new Error('No charset');
  const bytes = new Uint32Array(length);
  crypto.getRandomValues(bytes);
  let out = '';
  for (let i = 0; i < length; i++) out += pool[bytes[i] % pool.length];
  return out;
}
Python（secrets）
import secrets

def random_password(length=16, lower=True, upper=True, digits=True, symbols=True):
    pools = {
        'lower': 'abcdefghijklmnopqrstuvwxyz',
        'upper': 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits': '0123456789',
        'symbols': '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    }
    pool = ''.join(v for k, v in pools.items() if locals()[k])
    if not pool:
        raise ValueError('No charset')
    return ''.join(secrets.choice(pool) for _ in range(length))
PHP（random_int）
function random_password($length = 16, $sets = ['lower'=>true,'upper'=>true,'digits'=>true,'symbols'=>true]) {
    $pools = [
        'lower' => 'abcdefghijklmnopqrstuvwxyz',
        'upper' => 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits' => '0123456789',
        'symbols' => '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    ];
    $pool = '';
    foreach ($sets as $k => $on) if ($on) $pool .= $pools[$k];
    if ($pool === '') throw new Exception('No charset');
    $out = '';
    for ($i = 0; $i < $length; $i++) {
        $out .= $pool[random_int(0, strlen($pool)-1)];
    }
    return $out;
}
Go（crypto/rand）
package main

import (
  "crypto/rand"
  "math/big"
)

func RandomPassword(length int, pool string) (string, error) {
  out := make([]byte, length)
  for i := 0; i < length; i++ {
    nBig, err := rand.Int(rand.Reader, big.NewInt(int64(len(pool))))
    if err != nil { return "", err }
    out[i] = pool[nBig.Int64()]
  }
  return string(out), nil
}
Java（SecureRandom）
import java.security.SecureRandom;

public class Pw {
  static final String POOL = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
  static final SecureRandom SR = new SecureRandom();
  static String randomPassword(int length) {
    StringBuilder sb = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
      int idx = SR.nextInt(POOL.length());
      sb.append(POOL.charAt(idx));
    }
    return sb.toString();
  }
}
C#（.NET RandomNumberGenerator）
using System;
using System.Security.Cryptography;

public static class Pw {
  public static string RandomPassword(int length, string pool) {
    using var rng = RandomNumberGenerator.Create();
    var bytes = new byte[length];
    rng.GetBytes(bytes);
    var chars = new char[length];
    for (int i = 0; i < length; i++) {
      chars[i] = pool[bytes[i] % pool.Length];
    }
    return new string(chars);
  }
}
Rust（rand + getrandom）
use rand::rngs::OsRng;
use rand::RngCore;

fn random_password(length: usize, pool: &str) -> String {
    let mut bytes = vec![0u8; length];
    OsRng.fill_bytes(&mut bytes);
    let chars: Vec = pool.chars().collect();
    bytes
        .iter()
        .map(|b| chars[(*b as usize) % chars.len()])
        .collect()
}

fn main() {
    let pool = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
    let pw = random_password(16, pool);
    println!("{}", pw);
}
Cari Alat →