uToolGo Alat Kecil, Impak Besar

Alat Penghasil dan Semak Kata Laluan

Hasilkan kata laluan kuat dan frasa kata laluan, menyokong pengesahan berterusan, keunikan, kekuatan, dan strategi, serta menyediakan contoh kod pelbagai bahasa dan pengetahuan praktikal.

Penghasil Kata Laluan

Kuantiti
Pilih kumpulan simbol
Kumpulan
Biasa
Huruf kecil
Huruf besar
Nombor
Simbol (berdasarkan kumpulan semasa)
Petua: Anda boleh mengecualikan dengan memilih kumpulan atau klik terus pada aksara.
Keputusan

Penguji Strategi Kata Laluan

Keputusan
  • Panjang
  • Huruf kecil
  • Huruf besar
  • Nombor
  • Simbol
  • Urutan berturut-turut
  • Pengulangan
  • Senarai blok
Semua pemeriksaan dilakukan secara tempatan di peranti anda.

Penghasil Frasa Kata Laluan

Perkataan dipilih secara rawak selamat (Web Crypto). Senarai perkataan demo terhad kerana had saiz.

Jadual Rujukan Cepat Hash Kata Laluan

Argon2id
  • Gunakan Argon2id dengan parameter memori yang sesuai
  • Jumlah iterasi ≥ 2, memori ≥ 64MB (sesuaikan mengikut persekitaran)
  • Simpan garam unik untuk setiap pengguna; gunakan pepper di peringkat aplikasi jika diperlukan
PBKDF2
  • Pilih SHA-256 atau SHA-512, iterasi ≥ 210k (sesuaikan mengikut keperluan)
  • Guna garam unik untuk setiap hash; sokong peningkatan parameter
  • Alihkan ke parameter kos yang lebih tinggi apabila pengguna log masuk semula
BCrypt
  • Kos 10–14, bergantung kepada kemampuan pelayan
  • Elakkan masalah pemotongan; hash kata laluan sepenuhnya
  • Terapkan pembatasan dan pemantauan pada endpoint autentikasi
Rujukan: NIST SP 800-63B, OWASP ASVS. Parameter perlu sejajar dengan kapasiti peranti dan SLO.

Penilaian Kekuatan Kata Laluan

Kekuatan diperkirakan berdasarkan entropi: entropy = log2(ukuran sumber karakter) × panjang. Sumber karakter yang lebih besar dan panjang yang lebih panjang meningkatkan ketahanan terhadap tekaan.

  • Lemah: < 50 bit —— Sesuai hanya untuk penggunaan sekali atau skenario bernilai rendah
  • Sederhana: 50–80 bit —— Diterima untuk skenario berisiko rendah
  • Kuat: 80–110 bit —— Sasaran lalai yang disarankan
  • Sangat Kuat: > 110 bit —— Sesuai untuk akaun penting/pentadbir

Petua: Model serangan sebenar mungkin berbeza; elakkan penggunaan semula kata laluan dan aktifkan pengesahan dua faktor (MFA).

Arahan Penggunaan

  • Pilih panjang dan set karakter (Lower/Upper/Digits/Symbols); aktifkan Hindari serupa dan Perlukan setiap jika perlu
  • Untuk kawalan lebih tepat: keluarkan karakter/gugusan karakter, atau pilih kumpulan simbol
  • Klik hasilkan; untuk beberapa hasil, aktifkan penghasilan berbilang dan salin semua dengan satu klik
  • Untuk menyemak kata laluan sedia ada, gunakan "Penguji Strategi"; untuk frasa yang mudah diingat, gunakan "Penghasil Frasa Kata Laluan"

Ciri-ciri

  • Sumber rawak selamat (Web Crypto)
  • Set karakter dan kumpulan simbol boleh dikonfigurasi
  • Penapisan karakter serupa dan pengecualian tersuai
  • Penghasilan berbilang, jaminan keunikan, dan statistik penyingkiran duplikat
  • Indikator kekuatan dan entropi
  • Penguji Strategi dan Penghasil Frasa Kata Laluan
  • Contoh kod pelbagai bahasa （JS、Python、PHP、Go、Java、C#、Rust）
  • Salin satu klik (satu baris/semua)

Contoh Penghasilan Kata Laluan

Kuat (Strong)
Panjang 24, termasuk huruf besar/kecil/nombor/simbol
Mudah Diingat (Memorable)
Panjang 16, termasuk huruf besar/kecil/nombor, elakkan aksara serupa

Basis Pengetahuan Kata Laluan

1) Kekuatan Kata Laluan dan Entropi
  • Entropi ≈ log2(ukuran set karakter) × panjang; sumbangan panjang biasanya lebih besar
  • Sasaran cadangan: akaun biasa ≥ 80 bit; akaun penting/keuangan ≥ 110 bit
  • Set karakter yang lebih besar + panjang yang lebih panjang → lebih tahan terhadap tekaan
2) Panjang vs Kerumitan
  • Menambahkan simbol secara sembarangan kurang berkesan daripada menambah panjang
  • Elakkan corak yang boleh diramal (contoh: huruf besar di awal + nombor di akhir!)
  • Utamakan memastikan panjang yang mencukupi, kemudian tingkatkan pelbagai karakter dengan sederhana
3) Kesilapan Lazim dan Pola Negatif
  • Urutan papan kekunci (qwerty), blok berulang, tarikh lahir/tahun dll mudah diteka oleh peraturan
  • "Kata laluan induk + imbuhan laman web" adalah penggunaan semula variasi, risiko terpusat dan mudah diteka
  • Jangan gunakan kata laluan yang sama di pelbagai laman web
4) Cadangan Pengurusan Kata Laluan
  • Gunakan pengurus kata laluan; setiap laman unik; aktifkan MFA untuk akaun penting
  • Elakkan menghantar kata laluan dalam bentuk teks biasa melalui saluran awam; jika perlu, gunakan "kata laluan mesra suara"
  • Segera tukar dan pastikan unik sekiranya terdedah atau digunakan semula
5) Panduan Kata Lengkap (Passphrase)
  • Gabungan beberapa perkataan (4–6 perkataan) biasanya kuat dan mudah diingat
  • Campurkan pemisah, huruf besar di awal, dan tambah nombor untuk meningkatkan kekuatan dan keterbacaan
  • Elakkan menyambung secara langsung frasa biasa / lirik lagu / petikan terkenal

Panduan Amalan Keselamatan Kata Laluan

Amalan Terbaik
  • Gunakan panjang yang mencukupi: 16+ untuk akaun biasa, 24+ untuk akaun penting
  • Untuk keperluan ingatan, gunakan frasa laluan; kata sandi rawak berkuat tinggi disarankan disimpan oleh pengurus kata sandi
  • Nyalakan autentikasi pelbagai faktor (MFA) sekiranya memungkinkan
  • Jangan gunakan semula kata sandi di antara laman web; setiap akaun harus unik
Entropi dan Kekuatan

Entropi menggambarkan ketidakpastian berdasarkan panjang dan saiz set karakter; semakin tinggi bit entropi, biasanya semakin kuat.

  • Tingkatkan panjang terlebih dahulu untuk manfaat maksimum
  • Gunakan pelbagai set karakter jika mungkin
  • Mengelakkan karakter secara berlebihan akan mengurangkan saiz set karakter dan menurunkan kekuatan
Dasar dan Pergantian
  • Lebih utamakan panjang dan senarai hitam kata sandi biasa/dibocorkan berbanding peraturan komposisi kompleks
  • Elakkan pergantian paksa kerap; ubah hanya apabila berlaku kebocoran atau risiko
  • Guna senarai kata sandi yang dibocorkan untuk menghalang kata sandi biasa/dibocorkan
Frasa Laluan
  • Gunakan 4–6 perkataan rawak yang dihubungkan dengan pemisah, contohnya lake-CARROT-planet_7
  • Elakkan petikan frasa umum seperti ayat terkenal/lirik lagu; kerauan lebih penting daripada 'kebijaksanaan'
  • Untuk akaun penting, cadangkan menggunakan pengurus kata sandi untuk menyimpan kata sandi rawak berentropi tinggi sebenar
Petua Tetapan Penghasilan
  • "Require each selected set" memastikan setiap jenis muncul sekurang-kurangnya sekali
  • "Avoid similar" meningkatkan kebolehbacaan, tetapi sedikit mengurangkan saiz set karakter
  • Simbol boleh dibataskan kepada subset yang diterima oleh sistem sasaran
Penyimpanan Sisi Pelayan
  • Jangan simpan dalam teks biasa; gunakan hash kuat (Argon2id/PBKDF2/BCrypt) dengan garam
  • Tetapkan parameter yang sesuai (memori/waktu/kos); gunakan pepper jika diperlukan
  • Batasi kadar dan pantau percubaan gagal; tambah CAPTCHA atau pengesahan peranti semasa serangan
Pelbagai Faktor & Pemulihan
  • Utamakan TOTP/kerangka keras; elakkan SMS sebanyak mungkin
  • Lindungi proses pemulihan: gunakan pelbagai faktor atau pengesahan emel dengan tempoh penundaan
  • Sediakan kod pemulihan alternatif dan nasihatkan pengguna untuk menyimpannya dengan selamat
Perlindungan terhadap Serangan Kasar
  • Gunakan penundaan/protek bertahap dan skor risiko IP/peranti
  • Konfigurasikan WAF/pembatasan kadar untuk API dan borang log masuk
  • Pantau serangan kamus dan galakkan pengguna menggunakan kata sandi unik
Penyimpanan & Pemprosesan Tempatan
  • Gunakan pengurus kata sandi yang boleh dipercayai untuk penyimpanan dan pengisian automatik
  • Jangan kongsi kata sandi dalam teks biasa melalui chat/emel; gunakan alat pengurusan rahsia untuk pasukan
  • Jika perlu direkodkan secara fizikal, pastikan keselamatan fizikal
Pernyataan: Alat ini menghasilkan kata sandi secara tempatan di pelayan web menggunakan Web Crypto; data tidak akan dihantar ke pelayan.

Cara Menghasilkan Kata Laluan Melalui Bahasa Pengaturcaraan

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 →