Passphrase Generator Code Examples

<?php
// Diceware-style passphrase generation
function generatePassphrase(int $wordCount = 6): string {
    // EFF's improved wordlist (7776 words)
    $wordlist = ["ability", "able", "about", "above", "accept", /* ... 7771 more words */];

    $words = [];
    for ($i = 0; $i < $wordCount; $i++) {
        $index = random_int(0, count($wordlist) - 1);
        $words[] = $wordlist[$index];
    }

    return implode('-', $words);
}

// Generate 6-word passphrase (the usual Diceware/EFF default)
$passphrase = generatePassphrase(6);
echo $passphrase;
// Example: "ability-country-expand-golden-invent-rocket"

// Calculate entropy: log2(7776^6) ≈ 77.5 bits
// Stronger than most 12-character passwords

// Browser and Node.js compatible
function generatePassphrase(wordCount = 6) {
    // EFF's improved wordlist (7776 words)
    const wordlist = ["ability", "able", "about", "above", "accept", /* ... */];

    const words = [];
    const array = new Uint32Array(wordCount);

    // Global in browsers, Web Workers, Deno and Node.js 19+
    globalThis.crypto.getRandomValues(array);

    for (let i = 0; i < wordCount; i++) {
        const index = array[i] % wordlist.length;
        words.push(wordlist[index]);
    }

    return words.join('-');
}

// Generate passphrase
console.log(generatePassphrase(6));
// "crystal-thunder-mountain-freedom-cascade-brilliant"

import secrets

def generate_passphrase(word_count=6, separator='-'):
    """Generate a Diceware-style passphrase using EFF wordlist."""
    # EFF's improved wordlist (7776 words)
    wordlist = ["ability", "able", "about", "above", "accept", # ... 7771 more
    ]

    # Use secrets.choice() for cryptographic randomness
    words = [secrets.choice(wordlist) for _ in range(word_count)]

    return separator.join(words)

# Generate 6-word passphrase (recommended)
passphrase = generate_passphrase(6)
print(passphrase)
# Output: "galaxy-thunder-phoenix-cascade-velocity-quantum"

# Generate 8-word passphrase for higher security
strong_passphrase = generate_passphrase(8)
print(strong_passphrase)
# Output: "cosmic-mountain-radiant-freedom-nebula-infinite-crystal-harmony"

# Calculate entropy
import math
entropy = 6 * math.log2(7776)
print(f"Entropy: {entropy:.1f} bits")  # 77.5 bits for 6 words

import java.security.SecureRandom;
import java.util.Arrays;
import java.util.List;

public class PassphraseGenerator {
    private static final List<String> WORDLIST = Arrays.asList(
        "ability", "able", "about", "above", "accept" // ... 7771 more words
    );

    private static final SecureRandom random = new SecureRandom();

    public static String generatePassphrase(int wordCount) {
        StringBuilder passphrase = new StringBuilder();

        for (int i = 0; i < wordCount; i++) {
            if (i > 0) passphrase.append("-");
            int index = random.nextInt(WORDLIST.size());
            passphrase.append(WORDLIST.get(index));
        }

        return passphrase.toString();
    }

    public static void main(String[] args) {
        // Generate 6-word passphrase
        String passphrase = generatePassphrase(6);
        System.out.println(passphrase);
        // Output: "crystal-mountain-thunder-freedom-velocity-brilliant"

        // Calculate entropy
        double entropy = 6 * Math.log(WORDLIST.size()) / Math.log(2);
        System.out.printf("Entropy: %.1f bits%n", entropy);  // 77.5 bits
    }
}

using System;
using System.Security.Cryptography;
using System.Linq;

public class PassphraseGenerator
{
    private static readonly string[] Wordlist = new[]
    {
        "ability", "able", "about", "above", "accept" // ... 7771 more words
    };

    public static string GeneratePassphrase(int wordCount = 6)
    {
        using var rng = RandomNumberGenerator.Create();
        var words = new string[wordCount];

        for (int i = 0; i < wordCount; i++)
        {
            byte[] randomBytes = new byte[4];
            rng.GetBytes(randomBytes);
            uint randomValue = BitConverter.ToUInt32(randomBytes, 0);
            int index = (int)(randomValue % Wordlist.Length);
            words[i] = Wordlist[index];
        }

        return string.Join("-", words);
    }

    public static void Main()
    {
        // Generate 6-word passphrase
        string passphrase = GeneratePassphrase(6);
        Console.WriteLine(passphrase);
        // Output: "thunder-crystal-freedom-mountain-quantum-brilliant"

        // Calculate entropy: log2(7776^6) ≈ 77.5 bits
        double entropy = 6 * Math.Log(Wordlist.Length, 2);
        Console.WriteLine($"Entropy: {entropy:F1} bits");
    }
}

#include <iostream>
#include <vector>
#include <string>
#include <random>
#include <algorithm>

class PassphraseGenerator {
private:
    std::vector<std::string> wordlist = {
        "ability", "able", "about", "above", "accept" // ... 7771 more
    };
    std::random_device rd;

public:
    std::string generate(int wordCount = 6) {
        std::uniform_int_distribution<> dist(0, wordlist.size() - 1);

        std::vector<std::string> words;
        words.reserve(wordCount);

        for (int i = 0; i < wordCount; ++i) {
            words.push_back(wordlist[dist(rd)]);
        }

        // Join words with hyphens
        std::string result;
        for (size_t i = 0; i < words.size(); ++i) {
            if (i > 0) result += "-";
            result += words[i];
        }

        return result;
    }
};

int main() {
    PassphraseGenerator generator;

    // Generate 6-word passphrase
    std::string passphrase = generator.generate(6);
    std::cout << passphrase << std::endl;
    // Output: "crystal-thunder-mountain-freedom-velocity-quantum"

    return 0;
}

require 'securerandom'

class PassphraseGenerator
  WORDLIST = %w[
    ability able about above accept
  ].freeze # ... plus 7771 more words in the real list

  def self.generate(word_count: 6, separator: '-')
    words = Array.new(word_count) do
      WORDLIST[SecureRandom.random_number(WORDLIST.length)]
    end

    words.join(separator)
  end

  def self.entropy(word_count: 6)
    # Entropy = log2(7776^word_count)
    word_count * Math.log2(WORDLIST.length)
  end
end

# Generate 6-word passphrase
passphrase = PassphraseGenerator.generate(word_count: 6)
puts passphrase
# Output: "crystal-thunder-freedom-mountain-velocity-quantum"

# Generate 7-word passphrase for higher security
strong = PassphraseGenerator.generate(word_count: 7)
puts strong

# Show entropy
puts "Entropy: #{PassphraseGenerator.entropy(word_count: 6).round(1)} bits"
# Output: Entropy: 77.5 bits

package main

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

var wordlist = []string{
    "ability", "able", "about", "above", "accept", // ... 7771 more words
}

func GeneratePassphrase(wordCount int) (string, error) {
    words := make([]string, wordCount)
    max := big.NewInt(int64(len(wordlist)))

    for i := 0; i < wordCount; i++ {
        n, err := rand.Int(rand.Reader, max)
        if err != nil {
            return "", fmt.Errorf("random generation failed: %w", err)
        }
        words[i] = wordlist[n.Int64()]
    }

    return strings.Join(words, "-"), nil
}

func main() {
    // Generate 6-word passphrase
    passphrase, err := GeneratePassphrase(6)
    if err != nil {
        panic(err)
    }
    fmt.Println(passphrase)
    // Output: "crystal-thunder-freedom-mountain-velocity-quantum"

    // Generate multiple passphrases
    for i := 0; i < 3; i++ {
        p, _ := GeneratePassphrase(6)
        fmt.Println(p)
    }
}