Zufallsstring-Generator
Ein kostenloser Online-Generator für zufällige Zeichenketten. Kryptografisch sicher, gleichverteilt, und nichts wird je an einen Server gesendet.
Weitere Optionen
Über diesen Zufallsstring-Generator
Ein Zufallsstring-Generator erzeugt eine Folge von Zeichen, bei der jede Position zufällig aus einem Alphabet Ihrer Wahl gezogen wird. Entwickler verwenden zufällige Zeichenketten als API-Schlüssel, Sitzungstoken, Links zum Zurücksetzen von Passwörtern, Datenbank-IDs, Dateinamen, Einladungscodes und Testdaten. Einen guten Generator unterscheidet von einem schlechten nur, woher der Zufall kommt und wie er in Zeichen umgewandelt wird, und beides sieht man dem Ergebnis nicht an. Eine Zeichenkette, die zufällig aussieht, ist noch lange keine, die es auch ist.
Dieser Zufallsstring-Generator läuft online im Tab Ihres Browsers und nie auf einem Server. Er nutzt dieselbe kryptografische Quelle, die Ihr Betriebssystem Passwortmanagern und TLS-Bibliotheken bereitstellt, wandelt sie ohne Verzerrung in Zeichen um und zeigt Ihnen genau, wie viel Entropie das Ergebnis enthält. Er ist kostenlos, braucht kein Konto und funktioniert weiter, wenn Sie nach dem Laden der Seite die Netzwerkverbindung trennen.
So funktioniert es
- Stellen Sie die Länge über das Zahlenfeld oder den Regler ein. Voreingestellt sind 24 Zeichen, der Regler reicht von 1 bis 128, und das Zahlenfeld akzeptiert bis zu 4.096.
- Wählen Sie einen Zeichensatz. Die Schalter aktivieren oder deaktivieren Großbuchstaben, Kleinbuchstaben, Ziffern und Sonderzeichen, und die Auswahlliste bietet fertige Alphabete wie Hexadezimal, Base58, Base32 und Base64 URL-sicher.
- Klicken Sie auf Generieren oder drücken Sie die Taste G. Oben erscheint eine neue Zeichenkette, darunter ihre Stärke in Bit.
- Klicken Sie auf Kopieren. Für mehrere Werte öffnen Sie Weitere Optionen, geben eine Anzahl von bis zu 10.000 an und wählen eine pro Zeile, kommagetrennt, ein JSON-Array, eine Liste in Anführungszeichen oder
.env-Zuweisungen. Anschließend kopieren oder laden Sie den ganzen Stapel herunter.
Zufällige Zeichenketten mit Sonderzeichen
Der Schalter für Sonderzeichen fügt zwölf Zeichen hinzu: ! # $ % * + - = ? @ ^ _. Diese Auswahl ist bewusst getroffen. Jedes davon steht auf den Positivlisten für Passwörter von Microsoft Entra ID, Active Directory und OWASP, und keines zerstört einen Shell-Befehl, eine URL oder einen Konfigurationswert in Anführungszeichen, wie es ein Backslash, ein Anführungszeichen oder ein Leerzeichen tun. Zusammen mit Buchstaben und Ziffern ergibt das ein Alphabet von 74 Zeichen oder 6,2095 Bit pro Zeichen, nur 5,3 % weniger als der vollständige Satz von 94 druckbaren ASCII-Zeichen. Wenn Sie alle Sonderzeichen oder eine andere Auswahl brauchen, tragen Sie Ihr eigenes Alphabet in das Feld für den eigenen Zeichensatz ein. Die Seite über zufällige Zeichenketten mit Sonderzeichen (auf Englisch) erklärt, welche Systeme welche Zeichen ablehnen.
Lange zufällige Zeichenketten
Lange zufällige Zeichenketten eignen sich für Verschlüsselungsschlüssel, Signaturgeheimnisse und dafür, ein Feld bis an seine Grenze zu füllen, um zu sehen, was dabei kaputtgeht. Dieses Werkzeug erzeugt eine einzelne Zeichenkette mit bis zu 4.096 Zeichen, bei jeder Länge mit derselben unverzerrten Auswahl. Länge und Alphabet multiplizieren sich: 24 Buchstaben und Ziffern tragen etwa 143 Bit, schon mehr, als jeder Brute-Force-Angriff erreichen kann, während 64 Zeichen etwa 381 Bit tragen. Ab etwa 128 Bit bringt ein längeres Geheimnis keine praktische Sicherheit mehr, sondern nur noch Größe, also passen Sie die Länge an den Zweck an. Der Generator für Zeichenketten mit 64 Zeichen und der Entropierechner (beide auf Englisch) zeigen die Rechnung für jede Kombination.
Was einen Zufallsstring-Generator sicher macht
Zwei Dinge, und die meisten Generatoren machen mindestens eines davon falsch. Das erste ist die Quelle. Ein sicherer Zufallsstring-Generator liest aus einem kryptografisch sicheren Zufallszahlengenerator: im Browser crypto.getRandomValues(), das seine Werte vom Betriebssystem bezieht. Viele Online-Werkzeuge verwenden noch immer Math.random(), das schnell und für Spiele ausreichend ist, aber für jeden vorhersagbar, der einige Ausgaben beobachtet. Das wird ausführlich in Warum Math.random() nicht sicher ist (auf Englisch) erklärt.
Das zweite ist die Umwandlung. Eine Zufallszahl modulo der Alphabetgröße zu nehmen, macht manche Zeichen wahrscheinlicher als andere. Dieser Generator beseitigt das durch die Verwerfungsmethode, wie weiter unten und in Modulo-Verzerrung erklärt (auf Englisch) beschrieben. Die statistischen Tests, die das bestätigen, sind auf der Seite zur Methodik veröffentlicht, zusammen mit einer absichtlich fehlerhaften Implementierung, die dieselben Tests erkennen.
Online oder im eigenen Code
Ein Online-Zufallsstring-Generator ist die schnellste Wahl, wenn Sie sofort einen Wert brauchen: ein Geheimnis für eine .env-Datei, Testdaten, ein einmaliges Passwort. Muss die Zeichenkette zur Laufzeit in einer Anwendung entstehen, erzeugen Sie sie in der jeweiligen Sprache, statt sie einzufügen. Die Beispiele weiter unten auf dieser Seite zeigen den richtigen Weg für jede Plattform:
- Python: das Modul
secrets, niemalsrandom. - Java:
SecureRandom, niemalsjava.util.Random. - JavaScript:
crypto.getRandomValues()im Browser und in Node.js, niemalsMath.random(). - C++:
std::uniform_int_distributionüberstd::random_device, oder libsodium, wenn es eine Garantie braucht. - PHP:
random_int(), niemalsrand()odermt_rand(). - C#:
RandomNumberGenerator.GetString()unter .NET 8, oderGetInt32()unter .NET 6 und 7. - PowerShell:
RandomNumberGeneratorin PowerShell 7, oderGet-Random -Maximumfür jedes Zeichen in 5.1. Fügen Sie niemals-SetSeedhinzu und bauen Sie die Zeichenkette nie mit-Count.
Zufallsstring-Generatoren richtig vergleichen
Die meisten Werkzeuge zum Erzeugen zufälliger Zeichenketten sehen gleich aus, also beurteilen Sie sie nach dem, was Sie selbst prüfen können. Entsteht der Wert in Ihrem Browser, oder kommt er von einem Server, wo er protokolliert werden kann? Nennt die Website die verwendete Zufallsquelle? Sinkt die angezeigte Stärke, wenn Sie alle Zeichenarten verlangen, so wie es sein sollte? Können Sie verwechselbare Zeichen wie 0 O 1 l I für Zeichenketten ausschließen, die Menschen lesen müssen? Öffnen Sie die Entwicklertools Ihres Browsers, wechseln Sie zum Tab Netzwerk und klicken Sie auf Generieren: Auf dieser Website erscheint nichts. Für speziellere Aufgaben gibt es den Massen-Generator für zufällige Zeichenketten, den Generator mit eigenen Zeichen, den Passwort-Generator oder alle Generatoren der Website (auf Englisch).
Wie dieser Generator arbeitet
Jeder Wert stammt aus crypto.getRandomValues(), der Schnittstelle des Browsers zum kryptografischen Zufallszahlengenerator des Betriebssystems. Es gibt keinen Ausweichweg: Kann ein Browser keine sichere Quelle bereitstellen, verweigert dieses Werkzeug die Erzeugung, statt stillschweigend eine schwächere zu verwenden.
Bei der Umwandlung dieser Rohbits in Zeichen machen die meisten Generatoren Fehler. Der naheliegende Ansatz, den Rest einer Zufallszahl geteilt durch die Alphabetgröße zu nehmen, geht nicht glatt auf und verschiebt die Ausgabe zu den Zeichen am Anfang des Alphabets. Wird ein einzelnes Byte auf 62 Zeichen abgebildet, sind die ersten acht 1,25-mal so wahrscheinlich wie die übrigen vierundfünfzig. Dieses Werkzeug verwirft die Werte, die in den letzten unvollständigen Durchlauf fallen, sodass jedes Zeichen exakt gleich wahrscheinlich ist.
Dieselbe Sorgfalt gilt für die Option, mindestens ein Zeichen jeder Art zu verlangen. Statt eine Ziffer an eine feste Position zu zwingen, was ein sichtbares Muster hinterlässt, erzeugt der Generator eine vollständige Kandidatin und verwirft sie, wenn sie die Bedingung nicht erfüllt. Jede gültige Zeichenkette ist gleich wahrscheinlich, und die Entropieanzeige sinkt auf den echten Wert statt auf den, den die naive Formel liefert.
Wir veröffentlichen die Testergebnisse, statt Sie um Vertrauen zu bitten. Über 500.000 erzeugte Zeichen ergibt der Chi-Quadrat-Test auf Zeichenhäufigkeit p = 0,673. Dieselbe Testreihe erkennt eine absichtlich verzerrte Implementierung mit Chi-Quadrat = 3345 bei 61 Freiheitsgraden. Daran sehen wir, dass die Tests empfindlich genug sind, damit das saubere Ergebnis etwas bedeutet. Zur vollständigen Methodik (auf Englisch).
Im eigenen Code umsetzen
Wenn Sie das in einer Anwendung statt in einem Browser-Tab brauchen, finden Sie hier den richtigen Weg für jede Sprache. Jedes Beispiel nutzt die kryptografische Quelle der Plattform und eine unverzerrte Umwandlung.
JavaScript (Browser und Node 19+)
const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
function randomString(length) {
const n = ALPHABET.length;
// Largest multiple of n that fits in a uint32. Values at or above this
// are discarded, which is what removes the modulo bias.
const limit = Math.floor(2 ** 32 / n) * n;
const out = new Array(length);
const buf = new Uint32Array(length);
crypto.getRandomValues(buf);
for (let i = 0, j = 0; i < length; i++) {
let v = buf[j++];
while (v >= limit) {
// Refill one word at a time on the rare rejection.
const extra = new Uint32Array(1);
crypto.getRandomValues(extra);
v = extra[0];
}
out[i] = ALPHABET[v % n];
}
return out.join("");
}
randomString(24);crypto.getRandomValues() lehnt eine einzelne Anfrage über 65.536 Byte ab, daher muss eine große Menge in Blöcke aufgeteilt werden.
Python 3.6+
import secrets
import string
ALPHABET = string.ascii_letters + string.digits
def random_string(length: int) -> str:
# secrets.choice() is unbiased: it uses randbelow(), which is itself
# rejection sampling over os.urandom. Do not use random.choice() here,
# which is a Mersenne Twister and is not cryptographically secure.
return "".join(secrets.choice(ALPHABET) for _ in range(length))
random_string(24)secrets gehört seit Python 3.6 zur Standardbibliothek. Alles, was das Modul random verwendet, ist für ein Geheimnis das falsche Werkzeug.
Go
package main
import (
"crypto/rand"
"math/big"
)
const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
func randomString(length int) (string, error) {
out := make([]byte, length)
max := big.NewInt(int64(len(alphabet)))
for i := range out {
// rand.Int is unbiased; it rejects internally.
n, err := rand.Int(rand.Reader, max)
if err != nil {
return "", err
}
out[i] = alphabet[n.Int64()]
}
return string(out), nil
}crypto/rand, niemals math/rand. Seit Go 1.20 erhält der globale Generator von math/rand von selbst einen zufälligen Startwert, was an seiner Vorhersagbarkeit nichts ändert.
Rust
// rand = "0.9"
use rand::Rng;
use rand::distr::{Alphanumeric, SampleString};
fn random_string(length: usize) -> String {
// rand::rng() is a thread-local ChaCha12 CSPRNG, seeded from the
// operating system and reseeded periodically.
// Alphanumeric samples uniformly over A-Z a-z 0-9.
Alphanumeric.sample_string(&mut rand::rng(), length)
}
// With an arbitrary alphabet, random_range rejection-samples:
fn random_from(alphabet: &[u8], length: usize) -> String {
let mut rng = rand::rng();
(0..length)
.map(|_| alphabet[rng.random_range(0..alphabet.len())] as char)
.collect()
}In rand 0.8 lauten die Pfade anders: rand::distributions statt rand::distr, DistString statt SampleString, gen_range statt random_range und rand::thread_rng() statt rand::rng().
PHP 7+
<?php
function randomString(int $length): string {
$alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
$n = strlen($alphabet);
$out = '';
for ($i = 0; $i < $length; $i++) {
// random_int() is unbiased and cryptographically secure.
// rand() and mt_rand() are neither.
$out .= $alphabet[random_int(0, $n - 1)];
}
return $out;
}
echo randomString(24);Java 17+
import java.security.SecureRandom;
public final class RandomString {
private static final String ALPHABET =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
private static final SecureRandom RANDOM = new SecureRandom();
public static String generate(int length) {
StringBuilder sb = new StringBuilder(length);
for (int i = 0; i < length; i++) {
// nextInt(bound) rejects internally, so it is unbiased.
sb.append(ALPHABET.charAt(RANDOM.nextInt(ALPHABET.length())));
}
return sb.toString();
}
}SecureRandom, nicht java.util.Random und nicht Math.random(), die beide lineare Kongruenzgeneratoren mit 48 Bit sind.
C# / .NET 6+
using System.Security.Cryptography;
public static class RandomStringGenerator
{
private const string Alphabet =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
public static string Generate(int length)
{
// GetString was added in .NET 8 and is unbiased.
return RandomNumberGenerator.GetString(Alphabet, length);
}
// On .NET 6 and 7, GetInt32 is the unbiased primitive:
public static string GenerateLegacy(int length)
{
var chars = new char[length];
for (int i = 0; i < length; i++)
chars[i] = Alphabet[RandomNumberGenerator.GetInt32(Alphabet.Length)];
return new string(chars);
}
}C++11 und neuer
#include <random>
#include <string>
std::string random_string(std::size_t length) {
static const std::string alphabet =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
// uniform_int_distribution is specified to give every value in the range
// equal probability, so there is no modulo bias to remove by hand.
std::random_device rd;
std::uniform_int_distribution<std::size_t> pick(0, alphabet.size() - 1);
std::string out;
out.reserve(length);
for (std::size_t i = 0; i < length; ++i) {
out += alphabet[pick(rd)];
}
return out;
}std::random_device liest unter libstdc++, libc++ und MSVC die Quelle des Betriebssystems, aber der Standard erlaubt eine deterministische Implementierung, und MinGW-Builds vor GCC 9.2 waren genau das. Wenn es auf eine Garantie ankommt, verwenden Sie randombytes_uniform() aus libsodium. Niemals std::rand() oder std::mt19937 für ein Geheimnis.
PowerShell 7
$chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
# GetInt32 draws from the OS CSPRNG and rejection samples internally.
-join (1..24 | ForEach-Object {
$chars[[System.Security.Cryptography.RandomNumberGenerator]::GetInt32($chars.Length)]
})Windows PowerShell 5.1 läuft auf .NET Framework, das kein GetInt32 kennt. Wählen Sie dort jedes Zeichen mit Get-Random -Maximum $chars.Length, das den CSPRNG des Systems nutzt, solange kein -SetSeed angegeben ist. Vermeiden Sie Get-Random -Count, das kein Zeichen wiederholt.
Shell
# 24 alphanumeric characters from the kernel CSPRNG.
LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 24; echo
# Base64, URL-safe, from 32 bytes of entropy.
openssl rand -base64 32 | tr '+/' '-_' | tr -d '='tr verwirft Bytes außerhalb der Menge, statt sie hineinzufalten, daher ist diese Pipeline unverzerrt. Steht `head -c 24` vor `tr`, erhalten Sie nur den alphanumerischen Anteil von 24 Rohbytes, also eine kürzere Zeichenkette mit schwankender Länge statt 24 Zeichen.
Ausführliche Anleitungen (auf Englisch) zu Token, Passwörtern, Massenerzeugung und typischen Fehlern in jeder Sprache, jedes Beispiel in der echten Laufzeitumgebung ausgeführt:
Die richtige Länge wählen
Die Länge hat nur zusammen mit dem Alphabet eine Bedeutung. Eine Zeichenkette aus 20 Ziffern trägt etwa 66 Bit, 20 Zeichen aus den 62 Buchstaben und Ziffern tragen 119. Die Tabelle zeigt, wie viele Zeichen Sie für eine bestimmte Stärke brauchen, und der Generator zeigt den genauen Wert für Ihre aktuelle Auswahl.
| Alphabet | Bit/Zeichen | 64 Bit | 112 Bit | 128 Bit |
|---|---|---|---|---|
| Nur Ziffern (10) | 3,3219 | 20 | 34 | 39 |
| Kleinbuchstaben (26) | 4,7004 | 14 | 24 | 28 |
| Hex (16) | 4,0000 | 16 | 28 | 32 |
| Buchstaben und Ziffern (62) | 5,9542 | 11 | 19 | 22 |
| Ohne verwechselbare Zeichen (49) | 5,6147 | 12 | 20 | 23 |
| Mit sicheren Sonderzeichen (74) | 6,2095 | 11 | 19 | 21 |
Verwechselbare Zeichen auszuschließen kostet 0,3395 Bit pro Zeichen oder 5,70 %. Ein zusätzliches Zeichen auf je siebzehn gleicht das aus, und das lohnt sich meist bei allem, was ein Mensch vorlesen oder abtippen muss.
Häufige Fragen
Was ist ein Zufallsstring-Generator?
Ein Zufallsstring-Generator ist ein Werkzeug, das eine Zeichenkette erzeugt, indem es jedes Zeichen zufällig aus einem Alphabet wie Buchstaben, Ziffern und Sonderzeichen auswählt. Ein guter Generator nutzt eine kryptografisch sichere Zufallsquelle und gibt jedem Zeichen genau dieselbe Wahrscheinlichkeit, sodass das Ergebnis weder vorhergesagt noch reproduziert werden kann.
Wofür wird eine zufällige Zeichenkette verwendet?
Zufällige Zeichenketten dienen als API-Schlüssel, Sitzungstoken, Links zum Zurücksetzen von Passwörtern und zur E-Mail-Bestätigung, CSRF-Token, Passwörter, Geheimnisse zum Verschlüsseln und Signieren, IDs für Datenbanken und Dateien, Gutschein- und Einladungscodes sowie als Testdaten, um zu prüfen, wie eine Anwendung mit Eingaben einer bestimmten Länge umgeht.
Ist ein Online-Zufallsstring-Generator sicher?
Ja, wenn die Zeichenkette in Ihrem Browser erzeugt und nirgendwohin gesendet wird und das Werkzeug eine sichere Zufallsquelle verwendet. Auf dieser Website können Sie das selbst prüfen: Öffnen Sie in den Entwicklertools Ihres Browsers den Tab Netzwerk und klicken Sie auf Generieren, und es erscheint keine Anfrage. Ein Generator, der den Wert auf einem Server erzeugt, muss ihn Ihnen schicken, und unterwegs kann er protokolliert werden.
Ist dieser Zufallsstring-Generator kostenlos?
Ja. Er ist kostenlos, ohne Konto, ohne Nutzungslimit und ohne Einschränkung für kommerzielle Zwecke. Er läuft online in Ihrem Browser und funktioniert nach dem Laden der Seite auch offline weiter.
Wie erzeuge ich eine zufällige Zeichenkette mit Sonderzeichen?
Aktivieren Sie den Schalter !#$%. Er fügt zwölf Zeichen hinzu, ! # $ % * + - = ? @ ^ _, die fast jede Passwortrichtlinie akzeptiert und die weder Shell-Befehle noch URLs zerstören. Für andere Sonderzeichen tragen Sie das gewünschte Alphabet unter Weitere Optionen in das Feld für den eigenen Zeichensatz ein.
Wie erzeuge ich eine lange zufällige Zeichenkette?
Geben Sie die Länge in das Zahlenfeld neben dem Regler ein. Der Regler reicht bis 128, das Feld akzeptiert aber jede Länge bis 4.096 Zeichen. Die Entropieanzeige aktualisiert sich beim Tippen, sodass Sie sehen, wann die Zeichenkette für ihren Zweck lang genug ist.
Wie erzeuge ich eine zufällige alphanumerische Zeichenkette?
Lassen Sie die Schalter A-Z, a-z und 0-9 aktiviert und den Schalter für Sonderzeichen deaktiviert, das ist die Voreinstellung. Das ergibt ein Alphabet von 62 Zeichen, etwa 5,95 Bit pro Zeichen, sodass eine Zeichenkette mit 24 Zeichen etwa 143 Bit trägt. Für reine Buchstaben deaktivieren Sie 0-9, für reine Ziffern beide Buchstabenschalter.
Kann ich mehrere zufällige Zeichenketten auf einmal erzeugen?
Ja. Öffnen Sie Weitere Optionen und geben Sie eine Anzahl von bis zu 10.000 an. Die Ergebnisse lassen sich eine pro Zeile, kommagetrennt, als JSON-Array, als Liste in Anführungszeichen oder als .env-Zuweisungen anzeigen und kopieren oder als Datei herunterladen. Aktivieren Sie „Alle Ergebnisse müssen sich voneinander unterscheiden“, wenn der Stapel keine Duplikate enthalten darf.
Sind zufällige Zeichenketten eindeutig?
Nicht garantiert, aber eine ausreichend lange Zeichenkette ist in der Praxis eindeutig. Duplikate folgen dem Geburtstagsparadoxon: Mit etwa 143 Bit, also 24 Buchstaben und Ziffern, müssten Sie rund 2^71 Zeichenketten erzeugen, bevor eine Wiederholung wahrscheinlich wird. Bei kurzen Zeichenketten ist das anders; ein Code mit 6 Zeichen wiederholt sich viel früher, prüfen Sie die Eindeutigkeit dann in Ihrer Datenbank.
Was macht einen Zufallsstring-Generator sicher?
Eine kryptografisch sichere Zufallsquelle wie crypto.getRandomValues() im Browser und eine unverzerrte Umwandlung von Zufallszahlen in Zeichen. Ein Generator auf Basis von Math.random() ist vorhersagbar, und einer, der den Modulo-Operator ohne Verwerfungsmethode nutzt, macht manche Zeichen wahrscheinlicher als andere. Dieses Werkzeug tut beides nicht und veröffentlicht seine Testergebnisse.
Wie erzeuge ich eine zufällige Zeichenkette in Python?
Verwenden Sie das Modul secrets: "".join(secrets.choice(string.ascii_letters + string.digits) for _ in range(24)). secrets.choice ist kryptografisch sicher und unverzerrt. Verwenden Sie nicht random.choice, das auf dem Mersenne-Twister beruht und sich aus seiner Ausgabe vorhersagen lässt.
Wie erzeuge ich eine zufällige Zeichenkette in Java?
Erstellen Sie ein einziges java.security.SecureRandom und rufen Sie für jedes Zeichen nextInt(alphabet.length()) auf, wobei Sie alphabet.charAt() an einen StringBuilder anhängen. nextInt mit Obergrenze ist unverzerrt. Verwenden Sie nicht java.util.Random oder Math.random(), beides vorhersagbare 48-Bit-Generatoren.
Wie erzeuge ich eine zufällige Zeichenkette in JavaScript?
Füllen Sie ein Uint32Array mit crypto.getRandomValues(), verwerfen Sie Werte ab dem größten Vielfachen der Alphabetgröße und indizieren Sie das Alphabet mit den übrigen. Das funktioniert in jedem modernen Browser und in Node.js ab Version 19. Die vollständige Funktion finden Sie in den Codebeispielen auf dieser Seite. Math.random() ist dafür nicht sicher.
Wie erzeuge ich eine zufällige Zeichenkette in C++?
Verwenden Sie std::uniform_int_distribution über std::random_device und indizieren Sie Ihr Alphabet. Die Verteilung ist laut Spezifikation unverzerrt. std::random_device liest bei den gängigen Compilern die Quelle des Betriebssystems, der Standard garantiert das aber nicht, verwenden Sie daher randombytes_uniform() aus libsodium, wenn es darauf ankommt. Vermeiden Sie std::rand().
Wie erzeuge ich eine zufällige Zeichenkette in PHP?
Rufen Sie für jedes Zeichen random_int(0, strlen($alphabet) - 1) auf und hängen Sie das Zeichen an dieser Position an. random_int ist kryptografisch sicher, unverzerrt und seit PHP 7 eingebaut. Verwenden Sie für Geheimes nicht rand(), mt_rand() oder str_shuffle().
Wie erzeuge ich eine zufällige Zeichenkette in C#?
Ab .NET 8 rufen Sie RandomNumberGenerator.GetString(alphabet, length) auf, sicher und unverzerrt in einer Zeile. Unter .NET 6 und 7 rufen Sie für jedes Zeichen RandomNumberGenerator.GetInt32(alphabet.Length) auf. System.Random ist für Geheimnisse nicht geeignet.
Wie erzeuge ich eine zufällige Zeichenkette in PowerShell?
Ab PowerShell 7.4 rufen Sie [System.Security.Cryptography.RandomNumberGenerator]::GetString($chars, 24) auf. In Windows PowerShell 5.1, dem diese Methode fehlt, hängen Sie für jedes Zeichen $chars[(Get-Random -Maximum $chars.Length)] an. Get-Random nutzt den kryptografischen Generator des Systems, solange Sie kein -SetSeed angeben. Vermeiden Sie Get-Random -Count, das kein Zeichen wiederholt.
Wie erzeuge ich eine zufällige Zeichenkette in Node.js?
Für eine hexadezimale oder URL-sichere Zeichenkette verwenden Sie crypto.randomBytes(16).toString("hex") oder crypto.randomBytes(18).toString("base64url"). Für ein eigenes Alphabet wählen Sie jedes Zeichen mit crypto.randomInt(alphabet.length), sicher und unverzerrt. Bauen Sie keine Geheimnisse mit Math.random().
Wie erzeuge ich eine zufällige Zeichenkette unter Linux oder in Bash?
Führen Sie LC_ALL=C tr -dc "A-Za-z0-9" < /dev/urandom | head -c 24 für 24 Buchstaben und Ziffern aus, oder openssl rand -hex 16 für eine hexadezimale Zeichenkette mit 32 Zeichen. Beide lesen die Zufallsquelle des Kernels. Vermeiden Sie $RANDOM, einen 15-Bit-Wert aus einem nicht kryptografischen Generator.
Wie erzeuge ich eine zufällige Zeichenkette in Go?
Verwenden Sie crypto/rand. Ab Go 1.24 liefert rand.Text() eine Base32-Zeichenkette mit 26 Zeichen und mindestens 128 Bit Zufall. Für ein eigenes Alphabet wählen Sie jedes Zeichen mit rand.Int(rand.Reader, big.NewInt(int64(len(alphabet)))). Verwenden Sie für Geheimnisse niemals math/rand.
Wie erzeuge ich eine zufällige Zeichenkette in Excel?
In Excel 365 liefert =TEXTJOIN("",TRUE,CHAR(RANDARRAY(10,1,65,90,TRUE))) zehn zufällige Großbuchstaben, die sich bei jeder Neuberechnung des Blatts ändern. In deutschem Excel lautet dieselbe Formel meist =TEXTVERKETTEN("";WAHR;ZEICHEN(ZUFALLSMATRIX(10;1;65;90;WAHR))). Die Zufallsfunktionen von Excel sind nicht kryptografisch sicher, verwenden Sie das also nur für Testdaten und erzeugen Sie Passwörter oder Schlüssel mit einem sicheren Werkzeug.
Wird etwas von dem, was ich erzeuge, an einen Server gesendet?
Nein. Die Erzeugung läuft vollständig in Ihrem Browser über die Web Crypto API. Es gibt kein Backend, an das etwas gesendet werden könnte, und Sie können das selbst prüfen: Öffnen Sie die Entwicklertools Ihres Browsers, wechseln Sie zum Tab Netzwerk und klicken Sie auf Generieren. Es erscheint nichts.
Was ist der Unterschied zu Math.random()?
Math.random() ist nicht kryptografisch sicher. V8 implementiert es mit xorshift128+, einem nicht kryptografischen 128-Bit-Generator, und die JavaScript-Spezifikation verlangt nicht, dass seine Ausgabe unvorhersagbar ist. Veröffentlichte Arbeiten zeigen, dass jemand, der einige Ausgaben beobachtet, den inneren Zustand rekonstruieren und alle vergangenen und künftigen Werte reproduzieren kann. Dieses Werkzeug verwendet crypto.getRandomValues(), das aus dem CSPRNG des Betriebssystems schöpft.
Was ist Modulo-Verzerrung, und hat dieses Werkzeug sie?
Eine Zufallszahl mit dem Modulo-Operator zu verkleinern, verschiebt das Ergebnis zum Anfang des Alphabets. Ein Byte auf 62 Zeichen abzubilden ergibt 256 = 4x62 + 8, daher sind die ersten acht Zeichen 1,25-mal so wahrscheinlich wie die übrigen. Dieses Werkzeug beseitigt das mit der Verwerfungsmethode: Werte, die in den letzten unvollständigen Durchlauf fallen, werden verworfen statt eingerechnet.
Warum sinkt die Entropie, wenn ich alle Zeichenarten verlange?
Weil sie sinken muss. Mindestens eine Ziffer zu verlangen, schließt jede Zeichenkette ohne Ziffer aus, es gibt also weniger mögliche Ergebnisse, und die echte Entropie liegt unter Länge x log2(Alphabetgröße). Die meisten Generatoren zeigen weiter den höheren Wert an. Dieser zählt die gültigen Zeichenketten per Inklusion und Exklusion und zeigt den echten Wert, mit dem Wert ohne Einschränkungen in Klammern, damit Sie die Kosten sehen.
Wie lang sollte eine zufällige Zeichenkette sein?
Das hängt davon ab, was sie schützt. Für einen Wert, den ein Angreifer nur online gegen einen Dienst mit Anfragebegrenzung erraten kann, sind 64 Bit reichlich. Für ein Geheimnis, das abgefangen und offline angegriffen werden könnte, sollten es 112 Bit oder mehr sein; 19 alphanumerische Zeichen erreichen 113 Bit. Für Passwörter verlangt NIST SP 800-63B mindestens 15 Zeichen und rät ausdrücklich von Kompositionsregeln ab.
Kann ich das für Passwörter, API-Schlüssel und Sitzungstoken verwenden?
Ja. Die Zufallsquelle ist dieselbe, die Ihr Betriebssystem jeder Anwendung bereitstellt, und die Umwandlung in Zeichen ist unverzerrt. Was das Werkzeug nicht kann, ist den Wert zu schützen, nachdem er diese Seite verlassen hat. Behandeln Sie das Ergebnis also wie jedes andere Geheimnis.
Geschwindigkeit
10.000 Zeichenketten mit je 32 Zeichen zu erzeugen, dauert 17 ms. Große Mengen werden in Blöcken erzeugt, zwischen denen der Hauptthread freigegeben wird, sodass die Seite reaktionsfähig bleibt und der Vorgang abgebrochen werden kann. Drei der Generatoren, die derzeit auf der ersten Google-Seite stehen, haben überhaupt keine Mengenbegrenzung und frieren stattdessen den Tab ein.