Aktionen

PasswortgeneratorTest: Unterschied zwischen den Versionen

Aus znilwiki

← Zum vorherigen Versionsunterschied
VisuellWikitext
KKeine Bearbeitungszusammenfassung
KKeine Bearbeitungszusammenfassung
 
(Eine dazwischenliegende Version desselben Benutzers wird nicht angezeigt)
Zeile 7: Zeile 7:
         font-family: "Consolas", monospace;
         font-family: "Consolas", monospace;
         margin: 5px 0;
         margin: 5px 0;
         font-size: 16px; /* 'size 26' ist ungültiges CSS, durch font-size ersetzt */
         font-size: 16px;  
         }
         }
         .form-field {
         .form-field {
Zeile 146: Zeile 146:
            // #endregion Cookie-Funktionen
            // #endregion Cookie-Funktionen


            // #region Original-Passwortgenerator-Logik
            // #region Passwortgenerator-Logik
            // (Ihre Original-Logik, leicht angepasst zur Nutzung von getCurrentSettings)
             
 
            function generatePasswordLogic() {
            function generatePasswordLogic() {
                // Werte aus dem Formular einlesen (jetzt über Funktion)
                // Werte aus dem Formular einlesen (jetzt über Funktion)
Zeile 174: Zeile 173:
                  var useVowel = Math.random() < 0.5;
                  var useVowel = Math.random() < 0.5;


                  // Logik zur Fehlervermeidung, falls eine Zeichenart fehlt
                  if (vowels.length === 0 && consonants.length > 0) useVowel = false;
                  if (vowels.length === 0 && consonants.length > 0) useVowel = false;
                  if (consonants.length === 0 && vowels.length > 0) useVowel = true;
                  if (consonants.length === 0 && vowels.length > 0) useVowel = true;
Zeile 181: Zeile 179:
                    if (useVowel && vowels.length > 0) {
                    if (useVowel && vowels.length > 0) {
                      sequence += randomChar(vowels);
                      sequence += randomChar(vowels);
                      // Nur wechseln, wenn Konsonanten verfügbar sind
                      if (consonants.length > 0) useVowel = false;
                      if (consonants.length > 0) useVowel = false;
                    } else if (!useVowel && consonants.length > 0) {
                    } else if (!useVowel && consonants.length > 0) {
                      sequence += randomChar(consonants);
                      sequence += randomChar(consonants);
                      // Nur wechseln, wenn Vokale verfügbar sind
                      if (vowels.length > 0) useVowel = true;
                      if (vowels.length > 0) useVowel = true;
                    } else {
                    } else {
                      // Fallback: Wenn beide fehlen oder nur eine Art, die Schleife verlassen oder ein Ersatzzeichen verwenden
                      break;
                      break;
                    }
                    }
Zeile 198: Zeile 193:
                for(var p = 0; p < passwordCount; p++){
                for(var p = 0; p < passwordCount; p++){
                  // Berechne die Länge des nicht-numerischen Teils
                  // Berechne die Länge des nicht-numerischen Teils
                  // ACHTUNG: Die Zeile "letterSectionLength = letterSectionLength -1;" vor der Definition ist fehlerhaft und wurde entfernt.
                  // Die Logik besagt: Gesamt - Zahlenlänge = Restlänge (Wörter + 2 Specials)
                  var letterSectionLength = totalLength - numDigits;
                  var letterSectionLength = totalLength - numDigits;
                   
                   
                  // Die Gesamtlänge der Wörter ist Restlänge - 2 Sonderzeichen
                  // Die Gesamtlänge der Wörter ist Restlänge - 2 Sonderzeichen (gemäß Ihren Regeln)
                  var totalWordLength = letterSectionLength - 2;
                  var totalWordLength = letterSectionLength - 2;
                  if (totalWordLength < 0) totalWordLength = 0; // Fehler abfangen, falls das Passwort zu kurz ist
                  if (totalWordLength < 0) totalWordLength = 0;  
                 
 
                  // Bestimme die Basislänge für den ersten Buchstabenteil: GesamtWortLänge geteilt durch 2, gerundet
                  // Bestimme die Basislänge für den ersten Buchstabenteil
                  var baseFirstPart = Math.round(totalWordLength / 2);
                  var baseFirstPart = Math.round(totalWordLength / 2);
                  // Zufällige Anpassung um -1, 0 oder 1
                  // Zufällige Anpassung um -1, 0 oder 1
Zeile 216: Zeile 209:
                  if(firstPartLength > totalWordLength) firstPartLength = totalWordLength;
                  if(firstPartLength > totalWordLength) firstPartLength = totalWordLength;
                   
                   
                  // Die Länge des zweiten Buchstabenteils ergibt sich aus dem Rest
                  // Die Länge des zweiten Buchstabenteils
                  var secondPartLength = totalWordLength - firstPartLength;
                  var secondPartLength = totalWordLength - firstPartLength;
                  
                  
                  // Erzeuge den ersten alternierenden Buchstabenteil
                  // Erzeuge die Teile
                  var firstPart = generateAlternatingSequence(firstPartLength, vowels, consonants);
                  var firstPart = generateAlternatingSequence(firstPartLength, vowels, consonants);
                  // Erzeuge den zweiten alternierenden Buchstabenteil
                  var secondPart = generateAlternatingSequence(secondPartLength, vowels, consonants);
                  var secondPart = generateAlternatingSequence(secondPartLength, vowels, consonants);
                  
                  
                  // Stelle sicher, dass der erste Buchstabe beider Wörter groß geschrieben wird, falls vorhanden
                  // Ersten Buchstaben groß schreiben
                  if(firstPart.length > 0) {
                  if(firstPart.length > 0) {
                    firstPart = firstPart.charAt(0).toUpperCase() + firstPart.slice(1);
                    firstPart = firstPart.charAt(0).toUpperCase() + firstPart.slice(1);
Zeile 232: Zeile 224:
                  }
                  }
                  
                  
                  // Zufälliges Sonderzeichen zwischen den Wörtern auswählen
                  // Sonderzeichen auswählen (wenn vorhanden)
                  var specialChar1 = specials.length > 0 ? randomChar(specials) : '';
                  var specialChar1 = specials.length > 0 ? randomChar(specials) : '';
                  // Zufälliges Sonderzeichen zwischen Wörtern und Zahl auswählen
                  var specialChar2 = specials.length > 0 ? randomChar(specials) : '';
                  var specialChar2 = specials.length > 0 ? randomChar(specials) : '';
                  
                  
                  // Erzeuge den numerischen Teil (Ziffern)
                  // Numerischen Teil erzeugen
                  var digitSequence = "";
                  var digitSequence = "";
                  for(var d = 0; d < numDigits && digitsAllowed.length > 0; d++){
                  for(var d = 0; d < numDigits && digitsAllowed.length > 0; d++){
Zeile 243: Zeile 234:
                  }
                  }
                  
                  
                  // Komplettes Passwort zusammensetzen
                  // Komplettes Passwort zusammensetzen und ggf. kürzen
                  var password = firstPart + specialChar1 + secondPart + specialChar2 + digitSequence;
                  var password = firstPart + specialChar1 + secondPart + specialChar2 + digitSequence;


                  // Kürzen, falls das Passwort zu lang ist, was theoretisch passieren kann, falls totalWordLength sehr klein ist, aber numDigits groß.
                  if (password.length > totalLength) {
                  if (password.length > totalLength) {
                    password = password.substring(0, totalLength);
                    password = password.substring(0, totalLength);
Zeile 258: Zeile 248:
            }
            }


            // #endregion Original-Passwortgenerator-Logik
            // #endregion Passwortgenerator-Logik




            // Event Listener einrichten
            // Event Listener einrichten
            window.addEventListener("load", function() {
            window.addEventListener("load", function() {
              // Versuche, Einstellungen aus Cookie zu laden
              // Lade Cookie-Einstellungen beim Start
              getCookie();
              getCookie();
               
               
              // Hier wird die Funktion direkt zugewiesen
              document.getElementById("generate").addEventListener("click", generatePasswordLogic);
              document.getElementById("generate").addEventListener("click", generatePasswordLogic);
               
               
Zeile 302: Zeile 293:
   </body>
   </body>
</html>
</html>
----
<u>'''Changelog:'''</u>
* 22.02.2025 erste Version
* 09.06.2025 Länge auf 17 Zeichen erhöht, 2. Sonderzeichen vor der Zahl, Beschreibung angepasst
* 09.07.2025 Fehler Sonderzeichen behoben, es wurde 2 mal das gleiche genommen
----
<comments />

Aktuelle Version vom 16. Dezember 2025, 12:07 Uhr

                Passwortgenerator                    

     

         
                                 
         
                                 
         
                                 
         
                                 
         
                                 
         
                                 
         
                                 
         
                                             
         
                     
               

     

         Der Passwortgenerator funktioniert nach folgenden Regeln:
         
               
  • Hinten werden Zahlen angehängt
    •            
  • Die Zahl besteht aus den Ziffern die in dem Feld vorkommen (man kann auch was anderes hinzufügen oder löschen)
    •            
  • Die Anzahl der Stellen ist festgelegt, z.B. auf 4
    •            
  • Die Gesamtlänge - Anzahl der Stellen ergibt die Restlänge (Wörter + 2 Sonderzeichen)
    •            
  • Von dieser Restlänge wird **2 abgezogen** (1 für das Sonderzeichen zwischen den Wörtern und 1 für das Sonderzeichen zwischen dem 2. Wort und der angehängten Zahl). Bei 17 Zeichen - 4 Zahlen - 2 Sonderzeichen bleibt also **11 Buchstaben**.
    •            
  • Diese Restlänge wird durch **2 geteilt**. Ggf. wird dabei aufgerundet. Das ergibt die Basislänge des ersten Wortes, z.B. $\text{Rund}(\frac{11}{2}) = 6$
    •            
  • Diese Länge wird zufällig um 1 erhöht oder verringert  oder unverändert gelassen. Die neue Länge ist in diesem Beispiel also 5, 6 oder 7
    •            
  • Für den ersten Teil wird zufällig entschieden ob mit einem Vokal oder einen Konsonanten begonnen wird
  •            
  • Es werden nun abwechseln Konsonanten und Vokale aneinander gereiht bis die Wortlänge erreicht ist
    •            
  • Der erste Buchstabe wird in einen Großbuchstaben geändert
    •            
  • Es wird ein Sonderzeichen angehängt ($\text{specialChar1}$)
    •            
  • Das zweite Wort wird nach den gleichen Regeln wie das erste erzeugt (Restlänge der Buchstaben). Also wieder zufällig ob Konsonant oder Vokal, danach abwechselnd, erster Buchstabe groß
    •            
  • Danach wird das 2. Sonderzeichen ($\text{specialChar2}$) und die Zahl angehängt
    •          
         
         Das ganze habe ich erstellt weil ich sehr gerne den Gaijin Password Generator benutze.
         Dort insbesondere die Internet-Passwörter 3 (14 Zeichen)
         Wenn man aber weis das ich das gerne mache, ließen sich meine Passwörter so leicht erraten. Ich habe dann schon immer variiert bzw. mehrere dieser Kennwörter hintereinander gehängt.
         Der Generator hier verwendet mehr Zufälle und variiert auch die Länge der Wörter und Zahlen auf Wunsch.          Ich mag einfach das dabei künstliche Wörter herauskommen die sich leichter Tippen und bei Bedarf sogar merken lassen.
     

     

   

Abgerufen von „https://znil.net/index.php?title=PasswortgeneratorTest&oldid=15738“