# Generator — Manual

> Vollständige Funktionsbeschreibung des Generators: alle sieben Reiter, ihre Parameter und Zeichensätze, die Architektur (server- vs. clientseitig) und die Grenzen.

Source: https://www.jpkc.com/db/tools/generator/manual/

Zurück zur Übersicht: [Generator](https://www.jpkc.com/db/tools/generator/) · Tool live öffnen: [www.jpkc.com/tools/generator/](https://www.jpkc.com/tools/generator/)

Dieses Manual beschreibt den **Generator** vollständig: jeden der sieben Reiter, seine Optionen und Zeichensätze, was server- und was clientseitig läuft und welche Grenzen gelten. Die Oberfläche ist auf Englisch — die Reiter- und Button-Namen stehen deshalb in ihrer englischen Original-Schreibweise (mit deutscher Erläuterung), damit du dich im echten Interface zurechtfindest.

## Architektur und Datenschutz vorab

Der Generator arbeitet zweigeteilt. Das ist die wichtigste Information, um seine Ergebnisse einzuordnen:

- **Serverseitig** (PHP-API): die zufälligen Passwörter aus den vier Standard-Stufen, die Salt-Keys, die WordPress-Standard- und Extreme-Keys, die WLAN-Keys und der APR1-MD5-Block. Das JavaScript fordert den Wert per AJAX vom Server an (Endpunkte wie `?pw/24/`), der ihn mit einem kryptografisch sicheren Zufallsgenerator erzeugt — `random_int()` für die Zeichenauswahl, `random_bytes()` + `bin2hex()` für Hex. Jede Antwort trägt `no-cache`-Header.
- **Clientseitig** (Web-Crypto / WebAssembly, der Wert verlässt den Browser nicht): das **Apple-Stil-Passwort**, die **BCrypt-/Argon2-Hashes** und der gesamte **TOTP**-Reiter.

Heißt: Gibst du im Reiter **Hashes** dein eigenes Passwort ein, wird es **nicht** übertragen — gehasht wird lokal. Auch ein TOTP-Secret bleibt im Browser. Die serverseitig erzeugten Zufallswerte sind frische Einmalwerte ohne Zwischenspeicherung.

## Passwords — Passwort-Generator

Der Standard-Reiter erzeugt zufällige Passwörter. Zwei Steuerelemente:

- **Complexity** (Komplexität / Zeichensatz):
  - `a-z + A-Z + 0-9 + more specials` — voller Zeichensatz inklusive `, . - ; _ # + * ! § $ % & / ( ) = ?`.
  - `a-z + A-Z + 0-9 + less specials` — reduzierte Sonderzeichen (`. - _ + # $ % * , !`) für bessere Kompatibilität.
  - `a-z + A-Z + 0-9` — rein alphanumerisch, keine Sonderzeichen.
  - `a-f + 0-9 (hex)` — hexadezimal (aus `random_bytes()`), nützlich für Tokens und Keys.
  - `Apple-style (memorable, pronounceable)` — siehe unten.
- **Length** (Länge): 6, 8, 10, 12, 14, 16, 18, 20, **24** (Vorgabe), 32, 48, 64. Maximum 64 Zeichen.

Für die vier ersten Stufen holt das Tool den Wert serverseitig. Mit **Generate Password** erzeugst du einen neuen, mit **Copy** kopierst du ihn.

### Apple-Stil — aussprechbar und einprägsam

Wählst du `Apple-style`, wechselt die Oberfläche: Statt **Length** erscheint **Blocks** (Anzahl der Blöcke à 6 Zeichen, durch `-` getrennt) mit den Werten 3 (Vorgabe, = 20 Zeichen) bis 9 (= 62 Zeichen). Diese Variante läuft **rein clientseitig** (Web-Crypto-API) und ahmt das iCloud-Schlüsselbund-Muster nach: Konsonant-Vokal im Wechsel (dadurch aussprechbar), genau **eine** Ziffer und genau **ein** Großbuchstabe im ganzen Passwort, mehrdeutige Zeichen ausgeschlossen. Ein Ergebnis sieht etwa aus wie `kibavu-sed3ro-Nopuky`.

## Salt — Salt-Keys

Erzeugt kryptografische Salt-Keys mit erweitertem Zeichensatz (alle Buchstaben/Ziffern plus zahlreiche Sonderzeichen inklusive Backtick, Klammern und Leerzeichen) für maximale Entropie.

- **Length**: 16, 32, **64** (Vorgabe), 128, 256, 512, 1024. Maximum 1024.

**Generate Salt Key** erzeugt einen Wert (serverseitig). Geeignet für allgemeine Secret-/Salt-Werte in Konfigurationen.

## WordPress — Sicherheitsschlüssel für wp-config.php

Erzeugt die **acht** WordPress-Sicherheitsschlüssel als fertige `define()`-Zeilen: `AUTH_KEY`, `SECURE_AUTH_KEY`, `LOGGED_IN_KEY`, `NONCE_KEY`, `AUTH_SALT`, `SECURE_AUTH_SALT`, `LOGGED_IN_SALT` und `NONCE_SALT`.

- **Key Length**: **64** (Vorgabe), 72, 96, 128.

**Generate Keys** liefert den fertigen Block zum Einsetzen in `wp-config.php` (serverseitig erzeugt).

### Extreme Keys — gehärtete Schlüssel mit hash_hmac()

Der Button **Extreme Keys** (gelb) klappt zuerst ein Optionen-Panel auf; ein zweiter Klick generiert. Dieser Modus baut die Schlüssel nicht statisch, sondern als PHP-Code, der zur Laufzeit per `hash_hmac('sha512', …)` aus **statischen Geheimnissen** und **dynamischen Server-Variablen** abgeleitet wird. Optionen:

- **Key Rotation**: `No rotation`, `Hourly`, `Daily`, `Weekly` (Vorgabe), `Monthly` — wie oft sich die Schlüssel automatisch über `date()` ändern.
- **Dynamic Components** (Schalter): **Client IP** (`REMOTE_ADDR`), **User-Agent** (`HTTP_USER_AGENT`), **Server Address** (`SERVER_ADDR` + `SERVER_NAME`) — alle drei standardmäßig an.

Der erzeugte Code enthält eine Helferfunktion (`jpkcom_extreme_key()`), die statisches Geheimnis und Kontext kombiniert. **Wichtig:** Jede ausgewählte dynamische Komponente, die sich ändert (IP-Wechsel per VPN/Mobilfunk, Browser-Update ändert den User-Agent, das Rotationsintervall läuft ab), invalidiert die laufenden Sessions — die Nutzer müssen sich neu anmelden. Das Optionen-Panel weist mit einer Warnung darauf hin.

## WLAN — WPA/WPA2-Schlüssel

Erzeugt WLAN-Schlüssel, die mit WPA/WPA2 kompatibel sind (20 bis 63 Zeichen).

- **Complexity**: `a-z + A-Z + 0-9 + specials` (mit den sicheren Sonderzeichen `. - _ , +`) oder `a-z + A-Z + 0-9` (rein alphanumerisch).
- **Length**: 20, 30, 40, 50, **63** (Vorgabe). Erlaubt sind 20 bis 63 Zeichen — die Untergrenze entspricht den WPA-Mindestanforderungen, die Obergrenze dem WPA-Maximum.

**Generate WLAN Key** erzeugt den Schlüssel (serverseitig).

## APR1-MD5 — Passwort und Hash für .htpasswd

Erzeugt in einem Schritt ein zufälliges Passwort **und** dessen APR1-MD5-Hash im `$apr1$`-Format, wie ihn Apache für Basic-Auth in `.htpasswd`-Dateien erwartet.

- **Complexity**: dieselben vier Stufen wie beim Passwort-Generator (`more specials`, `less specials`, alphanumerisch, hex).
- **Length**: 8, 12, 16, 20, **24** (Vorgabe), 32.

Die Ausgabe enthält beide Werte untereinander:

```
Password:
<das Klartext-Passwort>

APR1-MD5:
$apr1$<salt>$<hash>
```

Das Klartext-Passwort gibst du der Person/dem System, den `$apr1$`-Hash trägst du in die `.htpasswd` ein. Erzeugung und Hashing laufen hier serverseitig.

## Hashes — BCrypt, Argon2i und Argon2id

Berechnet aus einem Passwort drei moderne Passwort-Hashes — **vollständig clientseitig per WebAssembly** (Bibliothek `hash-wasm`). Das Passwort wird dabei **nicht** an den Server gesendet.

**Eingabe:** Im Feld **Password** gibst du ein eigenes Passwort ein oder erzeugst per **Generate** ein zufälliges (dieses eine kommt aus der serverseitigen API, gesteuert über die beiden Dropdowns **Complexity (generate)** und **Length (generate)**). Der **Hash**-Button rechnet erst, wenn das Feld nicht leer ist.

**Parameter:**

- **BCrypt Cost**: `8 (fast)`, `10 (default)` (Vorgabe), `12 (slow, ~3–8s)` — der Cost-Faktor (Arbeitsfaktor) von BCrypt.
- **Argon2 Memory**: `4 MB (fast)`, `16 MB`, `64 MB (OWASP)` (Vorgabe), `256 MB (slow)` — der Speicherbedarf für beide Argon2-Varianten.

Beim Klick auf **Hash** erzeugt das Tool für jeden Algorithmus ein eigenes zufälliges 16-Byte-Salt (Web-Crypto) und berechnet parallel:

- **BCrypt** mit dem gewählten Cost-Faktor.
- **Argon2i** und **Argon2id** mit fixen Parametern `iterations=3`, `parallelism=1`, `hashLength=32` und dem gewählten Speicher (Vorgabe 64 MB). Eine Info-Zeile zeigt die tatsächlich verwendeten Parameter an.

Alle drei Hashes erscheinen im **encoded**-Format (also inklusive Algorithmus-Kennung, Parametern und Salt) und sind direkt in Anwendungen verwendbar, die diese Formate verifizieren. Die WASM-Berechnung kann je nach Cost-/Speicher-Wahl spürbar dauern (deshalb der Hinweis „~3–8 s" bei Cost 12); ein Lade-Spinner zeigt den Fortschritt an.

## OTP — TOTP-Einmalcodes (RFC 6238)

Richtet eine zeitbasierte Zwei-Faktor-Authentifizierung (TOTP) ein — **vollständig clientseitig** über die Web-Crypto-API. Kompatibel mit jeder Authenticator-App (Google Authenticator, Aegis und weitere).

**Eingaben und Felder:**

- **Account Name** und **Issuer** (Aussteller/Dienstname) — wandern in das Label der Key-URL und des QR-Codes (Vorgaben `user@example.com` bzw. `My Service`).
- **Secret (Base32)** — das geheime Schlüsselmaterial. Mit **Generate** erzeugst du ein neues 20-Byte-Secret (160 Bit, Base32-kodiert); du kannst auch ein vorhandenes Secret eintragen. Für QR und URL muss das Secret mindestens 16 Zeichen lang sein.
- **Secret (Hex)** — schreibgeschützte Hex-Darstellung desselben Secrets.
- **Interval** — Gültigkeitsdauer eines Codes: **30 seconds** (Vorgabe) oder **60 seconds**.
- **Key URL (otpauth://)** — die fertige `otpauth://totp/…`-URL mit `algorithm=SHA1`, `digits=6` und der gewählten `period`. Buttons **Copy** und **Open**.
- **QR-Code** — wird aus der Key-URL gerendert (196 × 196 px, Fehlerkorrektur-Stufe M, an das dunkle Theme angepasst). **Save QR Code** lädt ihn als PNG herunter.

**Live-Anzeige:** Drei Codes nebeneinander — **Previous**, **Current OTP** (mit eigenem Copy-Button) und **Next** — sowie Infokarten zu **Epoch (UTC)**, **Iteration (T)**, **Padded Hex** und **Remaining** (Restsekunden) plus eine Fortschrittsleiste, die bei ≤ 10 s gelb und bei ≤ 5 s rot wird. Die Codes basieren auf HMAC-SHA1 und sind sechsstellig; sie aktualisieren sich jede Sekunde.

## Grenzen — kompakt

- **Passwörter:** maximal 64 Zeichen (Apple-Stil: 3–9 Blöcke à 6 Zeichen, also 20–62 Zeichen).
- **Salt-Keys:** 1 bis 1024 Zeichen.
- **WLAN-Keys:** 20 bis 63 Zeichen (WPA-konform).
- **WordPress-Keys:** acht Schlüssel; Längenvorgaben 64/72/96/128.
- **TOTP:** HMAC-SHA1, 6 Stellen, Periode 30 oder 60 s; Secret 20 Byte (Base32), QR ab 16 Zeichen Secret.
- **Hashes:** BCrypt-Cost 8/10/12; Argon2-Speicher 4/16/64/256 MB, sonst feste Parameter (iter 3, parallelism 1, length 32).
- **Datenschutz:** eigenes Passwort im Hashes-Reiter und TOTP-Secret bleiben im Browser; serverseitig erzeugte Zufallswerte werden mit `no-cache` ausgeliefert.

Für die Zielgruppen und das große Bild siehe die [Übersicht](https://www.jpkc.com/db/tools/generator/). Konkrete Abläufe zeigen die [Beispiele](https://www.jpkc.com/db/tools/generator/examples/), Strategie und Stolperfallen die [Tipps & Tricks](https://www.jpkc.com/db/tools/generator/tips/). Ausprobieren kannst du alles direkt im [Tool](https://www.jpkc.com/tools/generator/).