Password Generator

Password Generator क्या है?

Password Generator उपयोगकर्ता खातों, API keys, database credentials और encryption secrets के लिए random character strings बनाता है। इंसानों द्वारा चुने गए पासवर्ड के विपरीत, जनरेट किए गए पासवर्ड संभावित वर्ण संयोजनों के पूर्ण स्थान से लिए जाते हैं, जो उन्हें शब्दकोश हमलों और पैटर्न-आधारित अनुमान के प्रति प्रतिरोधी बनाता है। यह उपकरण आपके ब्राउज़र के अंतर्निर्मित क्रिप्टोग्राफ़िक रैंडम नंबर जनरेटर का उपयोग करके ऑनलाइन मज़बूत रैंडम पासवर्ड बनाता है।

पासवर्ड की मज़बूती दो कारकों पर निर्भर करती है: लंबाई और वर्ण विविधता। अपरकेस, लोअरकेस, अंकों और प्रतीकों का उपयोग करने वाले 20-वर्ण के पासवर्ड में लगभग 131 बिट एन्ट्रॉपी होती है। उस स्तर पर, एक ब्रूट-फ़ोर्स हमला जो प्रति सेकंड एक ट्रिलियन अनुमान परखता है, हर संयोजन को आज़माने के लिए ब्रह्मांड की आयु से भी अधिक समय लेगा। गणित सीधा है: एन्ट्रॉपी = लंबाई × log2(character set size)।

NIST SP 800-63B जैसे मानक कम से कम 8 वर्णों के पासवर्ड की अनुशंसा करते हैं जिनकी कोई ऊपरी सीमा वैलिडेटर द्वारा enforce नहीं की जाती, और ठीक एक प्रतीक की आवश्यकता जैसे बाध्य संरचना नियमों को मना करते हुए लंबे पासफ़्रेज़ को प्राथमिकता देते हैं। मशीन-से-मशीन क्रेडेंशियल और सेवा खातों के लिए, पूर्ण वर्ण सेट से लिए गए 20 या अधिक यादृच्छिक वर्ण अधिकांश सुरक्षा फ़्रेमवर्क और अनुपालन व्यवस्थाओं में स्वीकृत आधार रेखा है।

Password Generator का उपयोग क्यों करें?

इंसान स्वभाव से अच्छे रैंडम नंबर जनरेटर नहीं होते। हम पासवर्ड पुनः उपयोग करते हैं, शब्दकोश के शब्द चुनते हैं, अक्षरों को अनुमानित पैटर्न से बदलते हैं (a के लिए @, e के लिए 3), और छोटी स्ट्रिंग पर निर्भर रहते हैं। Password Generator इस प्रक्रिया से मानवीय पूर्वाग्रह हटा देता है।

Password Generator के उपयोग के मामले

पासवर्ड एन्ट्रॉपी संदर्भ

एन्ट्रॉपी मापती है कि पासवर्ड कितना अनुमानातीत है। इसकी गणना log2(charset_size ^ length) के रूप में की जाती है। अधिक एन्ट्रॉपी का अर्थ है कि किसी हमलावर को अधिक संभावित संयोजनों की खोज करनी होगी। NIST और OWASP उच्च-सुरक्षा अनुप्रयोगों के लिए कम से कम 80 बिट एन्ट्रॉपी की अनुशंसा करते हैं।

क्रैक समय प्रति सेकंड 1 ट्रिलियन अनुमान मानते हैं (आधुनिक GPU के साथ ऑफ़लाइन हमला)। दर सीमा वाले ऑनलाइन हमले कई गुना धीमे होते हैं।

पासवर्ड निर्माण के लिए CSPRNG बनाम Math.random()

यादृच्छिकता का स्रोत पासवर्ड की लंबाई जितना ही महत्वपूर्ण है। अनुमानित यादृच्छिक संख्या जनरेटर से बनाए गए पासवर्ड को कोई हमलावर जो एल्गोरिदम और बीज स्थिति जानता है, पुनः निर्मित कर सकता है। यह उपकरण crypto.getRandomValues() का उपयोग करता है, जो प्रत्येक आधुनिक ब्राउज़र में अंतर्निर्मित क्रिप्टोग्राफ़िक रूप से सुरक्षित छद्म-यादृच्छिक संख्या जनरेटर (CSPRNG) है।

कोड उदाहरण

विभिन्न प्रोग्रामिंग भाषाओं में प्रोग्रामेटिक रूप से पासवर्ड बनाएं। नीचे दिए गए प्रत्येक उदाहरण में क्रिप्टोग्राफ़िक रूप से सुरक्षित यादृच्छिक स्रोत का उपयोग किया गया है, न कि Math.random() या समकक्ष कमज़ोर PRNG का।

// Generate a random password in the browser or Node.js 19+
function generatePassword(length = 20) {
  const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*'
  const values = new Uint32Array(length)
  crypto.getRandomValues(values)
  return Array.from(values, v => charset[v % charset.length]).join('')
}

console.log(generatePassword())    // → "kR7!mZp$Xw2&nLq9@Yf3"
console.log(generatePassword(32))  // → "Hd4%tNx!Qw8#mKp2Rv6&Zj0*Ls3Yb7@"

import secrets
import string

def generate_password(length: int = 20) -> str:
    """Generate a cryptographically secure random password."""
    alphabet = string.ascii_letters + string.digits + string.punctuation
    return ''.join(secrets.choice(alphabet) for _ in range(length))

# Single password
print(generate_password())      # → "kR7!mZp$Xw2&nLq9@Yf3"

# Batch of 5 passwords
for _ in range(5):
    print(generate_password(24))

# Ensure at least one char from each category
def generate_strong(length: int = 20) -> str:
    required = [
        secrets.choice(string.ascii_uppercase),
        secrets.choice(string.ascii_lowercase),
        secrets.choice(string.digits),
        secrets.choice(string.punctuation),
    ]
    remaining = length - len(required)
    alphabet = string.ascii_letters + string.digits + string.punctuation
    all_chars = required + [secrets.choice(alphabet) for _ in range(remaining)]
    secrets.SystemRandom().shuffle(all_chars)
    return ''.join(all_chars)

# OpenSSL — generate 32 random bytes, base64-encode
openssl rand -base64 32
# → "x7Kp2mNqR4wZ8vLs1Yb0Hd6tFj3Xc9Ga5eUi+Wo="

# /dev/urandom with tr — alphanumeric + symbols, 20 chars
tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c 20; echo
# → "kR7!mZp$Xw2&nLq9@Yf3"

# pwgen (install: apt install pwgen / brew install pwgen)
pwgen -sy 20 5
# Generates 5 passwords, 20 chars each, with symbols

package main

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

func generatePassword(length int) (string, error) {
    charset := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"
    result := make([]byte, length)
    for i := range result {
        idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
        if err != nil {
            return "", err
        }
        result[i] = charset[idx.Int64()]
    }
    return string(result), nil
}

func main() {
    pwd, _ := generatePassword(20)
    fmt.Println(pwd) // → "kR7!mZp$Xw2&nLq9@Yf3"
}

सामान्य प्रश्न