Passwort Generator

[Bobby35]

Hallo an alle,


ich bin ein absoluter Noob in Programmieren und jetzt müssen wir für den ITG-Kurs nen Passwortgenerator programmiere, nur ich hab keine ahnung wie das geht. ich kenne mich auch nicht mit C / C++ und sonstigem Aus deswegen wollte ich einfach mal hier nach Hilfe fragen



mfg
Bobby

[darkmessias]

Hallo,

um ein Passwort zu generieren, musst du zunächst bestimme in welchem Zeichnebereich die Zeichen liegen sollen, die du benutzen möchtest. Hierzu empfiehlt sich ein Blick in eine ASCII-Tabelle, da findest du die entsprechenden Zahlenwerte für die Zeichen.

Um das Passwort dann zu generieren, musst du einfach eine Zufallszahl in dem ASCII-Bereich generieren.

Beispielcode:

Code:

int zeichenAnzahl = 8; //Festlegen der anzahl der Zeichen des Passwortes

while (anzahl-- > 0)
{
  int i = 33 + (int) (93.0*rand() / (RAND_MAX+1.0));
  printf ("%c", (char)i);
}

Der Code generiert ein passwort mit der Länge 8 mit Zeichen zwischen 33 und 126.

[Bobby35]

ok das versteh ich so halb. wir müssen ein Passwort mit 8-16 Zeichen generieren wo Buchstaben und Zahlen hat.


mfg
Bobby

[Darkslide]

Pythoncode mit Kommentaren:

Code:

import random          
#Modul um Zufallszahl zu erzeugen
import string

pwdlen=random.randint(8, 16)
#erzeuge Zufallszahl zwischen 8 und 16 (Passwortlänge)
zeichensatz=string.lowercase+string.uppercase+string.digits
#zeichensatz="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
passwort=""

for zeichen in range(pwdlen):
    zufallszeichen=random.randint(0, 61)
    passwort+=zeichensatz[zufallszeichen]

#Führe die Schleife solange aus wie die Passwortlänge ist z.B. 10 mal
#Erzeuge eine Zufallszahl innerhalb des Zeichensatzes (Der Zeichensatz hat
62 Zeichen, das a ist das 0. Zeichen, deswegen nur bis 61)
#Dem String passwort wird jeweils das Zufallszeichen aus dem Zeichensatz hinzugefügt

print passwort

noch Unklarheiten?

//edit: Es wäre vorteilhaft in wie weit deine Programmierkentnisse vorhanden sind....welche Sprache, was kannst du in dieser Sprache: Datentypen, Bedingungen, Schleifen, Funktionen, Klassen, etc.

[Bobby35]

jop was für ein programm brauch ich dafür?


/edit Bin ein kompletter Neuling in Programmieren will es mir aber selbst bebringen

PS2: kenne mich mit keinem Programm aus

[Darkslide]

Wie sollst du einen Passwortgenerator programmieren ohne jegliche Programmierkentnisse?Habt ihr nen Koch als IT Lehrer eingestellt?

Wenn ich jetzt sage, dass du zunächst anfangen solltest programmieren zu lernen, dann wird deine nächste Frage sicherlich sein: Und welche Programmiersrache soll ich nehmen? Da ich hier keinen Glaubenskrieg anfangen will, da dir jeder eine andere Sprache empfehlen wird und seine Meinung die Richtige ist, sage ich einfach mal: Schau dir ein paar Sprachen an, lese dich ein und bleibe bei der Sprache, die dir am besten gefällt.

http://de.wikipedia.org/wiki/Liste_von_P...ersprachen *SCNR*

Ich geb mal ein paar Vorschläge:

Pascal, Delphi, C, C++, Assembler *g*, Python, Ruby, Visual Basic, Perl, Java, C#, Brainfuck *g*

[GrafZahl]

codebeispiel in java ... wenn du das hier bis zu deiner nächsten stunde verstanden hast, sollte dir das fach keine größeren probleme bereiten können *g*

was du dir thematisch angucken solltest um das hier in groben zügen zu verstehen: java syntax, primitive datentypen in java, arrays, funktionen, bedingte verzweigungen, schleifen

was darüber hinaus das verständnis der details anbelangt: Klassen und Objekte (objektorientierte Programmierung, oop)

was der code an welcher stelle tut, steht in den kommentaren, aber wenn du das nachvollziehen willst, empfehle ich dir einfach eine ide wie eclipse oder netbeans und das jdk (java development kit ... bringen IDEs mitunter auch gleich mit) zu installieren und das ganze einfach mal im debugger schritt für schritt laufen zu lassen

Code:

public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)
    {
        // das alphabet für das passwort
        char[] alphabet="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".toCharArray();
        int laenge=8;// wie lang soll das Passwort werden
        //ausgabe
        for(int i=0;i<20;i++) // 20 zeilen
        {
            for(int j=0;j<10;j++) // mit je 10 spalten
            {
                System.out.print(generatePW(alphabet, laenge, new SecureRandom())); //erzeuge ein passwort und schreibe es in die console
                System.out.print(" ");//schreibe ein leerzeichen in die console
            }
            System.out.println();//schreibe einen zeilenumbruch in die console
        }
    }

    /**
     * Diese Funktion erzeugt einen zufälligen Wert wählbarer
     * Länge zur Zahlenbasis <code>alphabet.length</code> unter Verwendung der
     * Ziffern aus <code>alphabet</code>.
     *
     *
     * @param alphabet das Alphabet, oder die Ziffern der Zahlenbasis (es findet keine Prüfung auf doppelte Zeichen statt)
     * @param laenge Anzahl an Stellen in der Ausgabe
     * @return ein Zufälliger Wert in Darstellung der entsprechenden
     * Zahlenbasis
     */
    public static String generatePW(char[] alphabet, int laenge, Random rnd)
    {
        if(laenge<1)
            throw new IllegalArgumentException("Parameter überprüfen! laenge");
        if(alphabet.length<2)
            throw new IllegalArgumentException("Parameter überprüfen! kein alphabet");

        //Die Klasse BigInteger erlaubt ganzzahlige Berechnungen beliebiger Größen ... der verfügbare Arbeitsspeicher ist das Limit
        //Primitive Typen wie z.B. int und long haben im gegensatz dazu eine feste maximale Größe die man nicht überschreiten sollte.
        //wird ein primitiver Typ zu groß, läuft er über und fängt am unteren ende seines Wertebereichs wieder an ...
        //soll heißen: Integer.MAX_VALUE+1 ist exakt das Gleiche wie Integer.MIN_VALUE

        BigInteger zahlenbasis = BigInteger.valueOf(alphabet.length); // die länge unseres alphabets als BigInteger ... unsere zahlenbasis
        BigInteger val = zahlenbasis.pow(laenge);   //wir bringen das ganze mal auf die gewünschte länge...
                                                    //bei normalen Zahlen kennen wir 10 verschiedene Ziffern: 0 - 9
                                                    //somit bekommen wir bei zahlen eine stelle mehr wenn wir sie mit 10 multiplizieren
                                                    //man spricht von einer zahl zur basis 10.
                                                    //hier führen wir nun eine andere basis ein ... entsprechend der anzahl der möglichen
                                                    //passwort zeichen in unserem alphabet
                                                    //um in der gewünschten Zahlenbasis die entsprechende länge zu erreichen
                                                    //multiplizieren wir also nicht x mal mit 10 sondern x mal mit der entsprechenden basis...

        val = val.xor(BigInteger.probablePrime(val.bitLength()-1,rnd));
                                                    //wir erzeigen eine primzahl die mindestens ein bit kürzer ist als unsere zahl
                                                    //(bei gleicher länge würde evtl das ergebnis nicht die richtige länge haben...
                                                    //viel kürzer darf sie aber auch nicht sein, da sonst die ersten paar stellen immer
                                                    //gleich wären)

        StringBuilder sb = new StringBuilder(laenge); //ein zwischenspeicher für unser ergebnis ...

        while(val.compareTo(BigInteger.ONE)>=0) // solange in unserer zahl noch ein wert größer oder gleich 1 steht, wiederhole das zwischen den klammern...
        {
            BigInteger[] arr = val.divideAndRemainder(zahlenbasis); //Teile MIT REST durch die zahlenbasis
                                                                    //arr[0] ist das divisionsergebnis
                                                                    //arr[1] ist der REST
            sb.append(alphabet[arr[1].intValue()]); //der rest entsprich logischer weise einem element aus dem alphabet
                                                    //dieses element suchen wir aus dem alphabet, und fügen es unserem ergebnis an...
            val = arr[0];//unsere zahl wird mit dem divisionsergebnis neu besetzt, und das spielchen beginnt für das nächste zeichen ...
        }
        //ist die ganze zahl verarbeitet, können wir das ergebnis aus unserem zwischenspeicher in einen string umwandeln lassen und ausgeben...
        return sb.toString();
    }

}

beispielhafte ausgabe:

Code:

jOsZhLr6 HMqR0OB1 JkzRMkq0 h3lxQ5I5 XsQTnXk0 pwUJxZLX BiveqneY 55PPWmj3 NVwctjz6 3da5YhK1
VRk93ZFO PeycE05V RVta5BQW RbTQkRBW pE1wAeLU 3Xcdtqv0 xi7GOd46 Xd3zjFLY fHx8WcK5 vHkUUHS0
F4ByMXKU jSPt8DNX JDZnHpIO 75HluqAZ VuNI1r0O F9934ULZ bHhUqjKT lc3y4u2O TsZniqmO TRmuq0yW
Zzkx9bOV l0uHsWcQ F2V4i4uS pY7pLB40 zoLCJzlW 75nwFYxS 51oYKYT0 F7vPjxqW putmDlX1 xsVFWc0O
vJAZkK8X n0z9mxZ0 ztgSWAcO xA6uVOdX blweYmIY D7EzewkW vcmMwlr6 9TEC3fs5 VF4fvU1P pAArrIj1
NOAF2zhU J4CZBCAQ 7tOBDpS5 7uULX084 h5cM3FZ3 RVstJlOZ JDbc2ToY BZiHOyq5 PLvwwUvP DWd3gzeZ
NTBLQlz3 T6eNAK0X VFgsWCiO pla44UdT 7cyftG50 DEPCOuf6 xs4K4RJ3 BmL90M17 v6A3bPG2 ROyQpgmT
Bg6E4pa4 LlfmK2bV NMLmvhRX 3JfD7dM7 5CBMAeDY RY2ifzC2 rUleqsXU DmUxxCkV tZG2pBY2 jEHkUblR
rzrneWh2 XAEA3OIZ ZNrDJ1J2 P6VN9AiV N2QJbtYY nb52qd9Q ryUe87l0 jAYanXA1 xRj4embT jrKXilyR
vtLbnXTR 1INz2M3O Tzb34UvX BOpdyvWU d1VY05HX Nc02R7e4 lwnXtbx0 nq2F5KY0 LWaqnIf2 zpZulDfP
xfnPAgWQ 9KVXzQTU 3ckgQ55S xip3JG63 jo1Dpg2P Zhh72wSP 5cqDDSj7 Fv4f97uV HGeOPOuY hHTaIHe3
3smmJog2 3UI6zjIT RIiH9603 1QqBIja2 R1a7aoJ6 lKSc9eRP T1PAJaE7 lB0jBJG6 ru9BjPR6 bRB7mUT6
Vbb26fs4 d4MdsvdX 1fZMiP4P 7xNKvALT rckkBix1 dHQ7KulZ 51fqva1R X1YW6ARZ Zc0EtDZZ N7nz4GT0
55StWQuW x7UAU4F5 H6DINBHU 30FmmybR 3No66m9Z TDlxeDfV BH1QhwTW XckKY3tT HOYUvNjS 9mMmHKUZ
NIPwoVn1 R74U2C26 dANlytJ5 391m7qoY bGlgCuZ3 NFfeNpaT vosQsb0Q p2UaCwBO pc3UQLIY XCUM6TB5
lWNPpgNW fDLieqIR bwMsWSFY JpjefNVS Jy4xFrV2 7IQThxn7 NbUjHhD6 1TMQFu24 foRzV8vO 7id2qY40
Phde8PAR Lo8lRJ71 N9shID4Z 1zFvDMP5 bIoyDcY1 x47vjCD7 P3OhMjI7 DTJIFv0Y NzXf5DjU bIB6XUoP
R4QaUJzZ f6mUGnbS hB1H7RqS 5gfnwVRS Jop6pUpZ Jsmxxyd4 nlijjwy6 9uK27F90 nswDSR3Z xS42LuaY
V4X2kpvS 3lGIBHlZ p8W4P4C4 rJNaJ0W0 z5h53lUP Fxc3dwiQ l0aZr9JV VobwksrR d6kaZD31 vABdlat6
hsWgwtF4 Xdxetqi5 HPT9kMQQ dSEYDMlU 7E7LvP0Z bPwVi0I2 FWg7ESpZ BebUNdu2 rIfOudzO rFPJJ7u1

nachtrag:
wer es lieber kurz, knapp und performant mag:

Code:

public static String genPWfast(char[] alphabet,int len, Random rnd)
    {
        StringBuilder sb=new StringBuilder(len);

        while(len>0)
        {
            sb.append(alphabet[rnd.nextInt(alphabet.length)]);
            len--;
        }

        return sb.toString();
    }

was natürlich den lernfaktor angeht ...

[Ferry]

ja genau so ist es schließ mich grafzahl an

[Bobby35]

ohje das wird ne ziemlich harte nuss. wo bekomm ich dieses JDK her?



mfg
Bobby

[GrafZahl]

http://www.gidf.de/jdk