Vorschläge

[Mr.White]

Hallo,

ich wollte mal fragen was für "erste" Programme ihr empfehlt. Immer wenn ich mir was ausdenke (z.B. Loginsystem) ist es einfach
viel zu schwer um es zu Realisieren. Habe ein Loginsystem angefangen mit Datenbank wo man sich registrieren und einloggen kann
jedoch hab ich damit noch gewaltige Probleme zu überprüfen ob das Passwort zu dem eingegebenen Account gehört.
Also hab ich das erst mal bei Seite gelegt und hebe mir die Codesnippets für was anderes auf.

Ich finde keine wirklichen Projekte die spaß machen zu programmieren oder wo ich später verwendung sehen könnte.
Da mein Buch mir mehr und mehr Probleme verschafft versuche ich momentan nur das zu lernen was ich benötige,
sprich: Je mehr ich brauche - desto mehr halte ich mich in den Docs auf und schaue wie ich was mache.



Vielleicht habt ihr ein paar Vorschläge.
Mr.White.

[Sirius3]

@Mr.White: Du suchst ein Projekt, wo Du später weiter verwenden kannst, fragst Dich aber was das sein könnte?
Wenn Du also weißt, was Du später machen willst, Dir das im Moment aber noch zu kompliziert ist, stell doch hier einfach mal genauer vor, was Du willst, und wo Du gerade hängst.

[Mr.White]

Hatte ursprünglich vor ein Login/Register System zu bauen mit mysql Datenbank.
Kann Daten abrufen und Schreiben etc.

Kann auch prüfen ob eine Eingabe enthalten ist.
Jedoch nicht ob die Eingabe das Passwort vom eingegebenen Username ist.
Finde im netz nicht wirklich das was ich brauche bzw schon aber es funktioniert nicht
so wie ich will.

Also suche ich was anderes.

[/me]

Finde im netz nicht wirklich das was ich brauche bzw schon aber es funktioniert nicht so wie ich will.

Also suche ich was anderes.

Genau das ist dein Problem.

Wenn man etwas nicht versteht was man tun will, dann erarbeitet man sich das. Ich habe das Gefühl, dass du zu schnell aufgibst wenn es nicht direkt funktioniert.

Womit hast du denn in diesem Kontext konkret Probleme? Ist es das Aufsetzen der Datenbank? Ist es SQL? Ist es die Installation des passenden Datenbankmoduls? Ist es die Verwendung des Datenbankmoduls? Welche Dokumentation hast du verwendet und welches Problem konntest du damit nicht lösen?

Wir helfen dir hier gerne weiter wenn du jeweils dein konkretes Problem beschreibst. Ein "funktioniert nicht" ist nichts worauf wir bei einer Antwort aufbauen könnten.

[Mr.White]

Datenbankmodul - Installiert (mysqlconnector)
Datenbankserver - xxamp (funktioniert)
Datenbankverbindung - funktioniert
Datenbankerstellung - Klappt
Daten schreiben (db) - Klappt
Daten auslesen (db) - Klappt

Prüfen ob Username und Passwort in der DB enthalten ist klappt soweit auch,
was nicht klappt ist das überprüfen ob das Passwort zum Username gehört.

Ich sitze da jetzt seit 3 Tagen dran und finde nichts.


Habe im internet geschaut (python-kurs.de uvm.) und in meinem Buch.
Da steht aber nichts drin was hilfreich sein könnte

[thorius]

Prüfen ob Username und Passwort in der DB enthalten ist klappt soweit auch,
was nicht klappt ist das überprüfen ob das Passwort zum Username gehört.

Wenn du prüfst ob Nutzername und Passwort in der Datenbank enthalten sind, dann hast du diese Information ja schon in den Händen. Da leider kein Code zum näheren Betrachten da ist kann man ab jetzt nur noch ins Blaue raten.

Code: Alles auswählen

if password_aus_db == von_nutzer_eingegebenes_passwort:
    print('Passwörter sind gleich')
else:
    print('Passwort war falsch')

edit: typo.

[BlackJack]

@Mr.White: Das was Du da beschreibst kommt nicht aus Büchern oder aus dem Netz sondern muss aus Deinem Kopf kommen. Du hast Daten, willst ein bestimmtes Ergebnis und musst nun die die Schritte überlegen um mit den Daten zum Ergebnis zu kommen. Sich diese Schritte überlegen und dann umsetzen, statt sie von irgendwo abzuschreiben, *das* ist ein wesentlicher Bestandteil vom Programmieren.

Du willst doch eigentlich gar nicht wissen ob das Passwort in der Datenbank bei irgendeinem Benutzer vorkommt, sondern ob das bei dem Benutzer vorkommt der sich da gerade anmelden möchte. Dazu fragt man das Passwort für *den* Benutzer von der Datenbank ab.

Wenn das dann funktioniert sollte übrigens der nächste Schritt sein mit einem für Passwörter geeigneten Algorithmus erstellte ”gesalzene” Hashes in der Datenbank zu speichern. Denn Passwörter gehören da aus Sicherheitsgründen nicht hinein.

[Mr.White]

Okay und ich weiß nicht wie sowas geht.
Hab noch nie ein Login gebaut. Kenne die genauen abläufe ja gar nicht.

[BlackJack]

@Mr.White: Mal davon abgesehen das ich den Ablauf ja beschrieben habe, kann man sich das doch sehr einfach überlegen. Du weisst doch was man üblicherweise bei einem Login angeben muss und dann musst halt einfach überlegen welche Schritte man durchführen muss um diese Angaben zu überprüfen. Was würdest *Du* denn machen wenn jemand sagt hier ist ein Benutzername und ein Passwort, darf der Benutzer rein? Diese Schritte die Du dann manuell durchführen würdest, musst Du dann in einem Programm umsetzen.

[Mr.White]

Ja ich weiß, ich weiß einfach nicht wie ich den Rest realisieren soll!

Ich hab eine Datenbank mit einer Tabelle die nennt sich logindaten.
Darin befindet sich "Usernames" und "Passwords".

Ich check einfach nicht wie ich beim Registrieren das Passwort an den usernamen "binde"
sodass ich prüfen kann ob das Passwort zu diesem "usernamen" gehört. Aber auch nur zu DIESEM EINEN.


Ich finde einfach keine Lösung. Ich hab 3 Zettel mit genauen abläufen wie das Programm
ablaufen soll und wie es aussehen soll wenn es am Ende fertig ist.

Wenn mir einer eine Seite zeigen würde wo genau steht wie man sowas macht dann währe das geil. Denn wie soll ich
mir was überlegen wenn ich davon die grundlagen nicht kenne(mysql connector).

Oder liege ich da falsch..

[/me]

Hab noch nie ein Login gebaut. Kenne die genauen abläufe ja gar nicht.

Das ist der Moment, wo man wirklich anfängt Software zu schreiben. Du musst überlegen welche Daten du hast und wie du sie miteinander in Beziehung bringen kannst um dein Ziel zu erreichen.

Du hast einen Usernamen und ein Passwort. Diese Informationen hast du als Felder in einer Tabelle deiner Datenbank. Jetzt gibt der Benutzer seinen Namen und ein Passwort ein. Du willst jetzt wissen ob es in der Tabelle einen Eintrag gibt bei dem Benutzer und Passwort mit dem eingegebenen Benutzernamen und Passwort übereinstimmen. Im Prinzip ist das schon die komplette Beschreibung deines Anwendungsfalls den du jetzt nur noch in Code umsetzen musst.

Die Eingabe von Benutzername und Passwort sollte kein Problem sein. Dann brauchst du noch eine SQL-Abfrage der Art "SELECT name FROM users WHERE name = eingegebener_name AND password = eingegebenes_passwort". Liefert die Abfrage kein Ergebnis zurück passt es nicht, bekommst du ein Ergebnis ist alles in Ordnung.

Im Prinzip ist es wie ein Karteikasten. Auf den Karteikarten stehen Name und Codewort. Jemand sagt dir Namen und Codewort und du blätterst so lange durch den Karteikasten bis du ein passende Karteikarte gefunden hast. Findest du keine Karteikarte mit übereinstimmenden Daten, dann ist derjenige nicht authentifiziert.

[Mr.White]

Ich probiers mal.

Wie vergleiche ich denn das mit variablen ?

cursor.execute("SELECT username FROM userdaten WHERE username = uname AND password = upass")

uname = input
upass = input

[/me]

Wie vergleiche ich denn das mit variablen ?

Die execute-Methode bietet Ersetzungsparameter für die einzusetzenden Werte.

Wie der Ersetzungsparameter konkret aussieht hängt von der Datenbank ab. Bei MySQL ist es meines Wissens nach %s. Damit ergibt sich:

Code: Alles auswählen

result = cursor.execute('SELECT username FROM userdaten WHERE username = %s AND password = %s', (uname, upass))

[Mr.White]

Ich hab das Problem etwas komisch gelöst ...
Vielleicht ein paar verbesserungen - oder rauft euch die Haare

Code: Alles auswählen

import sys, mysql.connector

try:
    connection = mysql.connector.connect \
                 (host = "localhost", user = "root", passwd = "", db = "lgdaten")
    #Erzeugen einer Datenbank
    cursor = connection.cursor()
    cursor.execute("CREATE DATABASE IF NOT EXISTS lgdaten")
    connection.commit()

    cursor.execute("CREATE TABLE IF NOT EXISTS userdaten ("
               "id INT PRIMARY KEY AUTO_INCREMENT, uname varchar(30), passwd varchar(30))")
    connection.commit()

except:
    print("Keine Verbindung zum Server...")
    sys.exit(0)



logged = False
while logged == False:
    uname = input("Username: ")
    upass = input("Password: ")
    datenListe = [upass, uname]
    cursor.execute("SELECT username FROM userdaten WHERE username = %s AND password = %s",(uname,upass))
    result = cursor.fetchall()
    for liste in result:
        if liste in result:
            print("logged!")
            break
        else:
            print("Error!")
            break
    break



cursor.close()
connection.close() 

[BlackJack]

@Mr.White: Das ``try``/``except`` kann/sollte man sich sparen wenn man damit nur das Programm beendet — und zwar mit weniger Fehlerinformation als man ohne diese ”Fehlerbehandlung” bekommen hätte. Die Ausgabe 'Keine Verbindung zum Server...' kann inhaltlich falsch sein, zum Beispiel wenn man keine Rechte hatte die Datenbank anzulegen oder abzufragen.

Bei Namen sollte man möglichst nicht Abkürzen und auch keine sinnfreien Prä- oder Suffixe anhängen. Das gilt auch für Namen in Datenbanken. Das Datenbanken und Tabellen `daten` enthalten muss man nicht im Datenbank- oder Tabellennamen angeben, das ist implizit klar. Die Datenbank könnte man `login` nennen und die Benutzertabelle einfach `user`. Weder beim Namen noch beim Password (dessen Namen man auch ausschreiben könnte) würde ich eine Längenbeschränkung vorgeben. Und `uname` sollte wohl `username` heissen und sollte ein UNIQUE-Constraint haben.

Schleifen die grundsätzlich nur einmal durchlaufen werden sind sinnfrei.

`fetchall()` bei einer Abfrage bei der man entweder kein oder genau ein Ergebnis erwartet ist ”falsch” in dem Sinne das es mit `fetchone()` eine passendere Methode gibt.

Die ``for``-Schleife ist unsinnig weil auch die genau einmal durchlaufen wird wenn es ein Ergebnis gibt. Und der Test macht ebenfalls keinen Sinn. Damit der jemals wahr ist müsste `result` sich selbst enthalten, was niemals passieren wird.

[Hyperion]

Puh... wo fängt man da an... oben

- Zeile 2: Trenne imports nicht per Komma! Besser zwei getrennte Zeilen.

- Allgemein: Code auf Modulebene, der da nicht hingehört! Verwende Funktionen und den ``if __name__ == "__main__"``-Hook:

Code: Alles auswählen

def main():
    # Deinen Einstiegscode hier rein packen

if __name__ == "__main__":
    main()

- Zeile 16 ist ein NoGo! Fange *niemals* alle Exceptions ab. Fange nur *die* Typen ab, die Du auch sinnvoll behandeln willst! So wirst Du auch die Meldung "Verbindungsproblem" erhalten, wenn es einen ganz *anderen* Fehler gab... was die Ursachenforschung wesentlich schwieriger macht, wie Du Dir ja jetzt leicht vorstellen kannst.

- Ob man das Anlegen der DB wirklich im Code stehen haben will, mag Geschmackssache sein. Ich persönlich mag das nicht und bevorzuge da separate SQL-Scripte.
- Aber auf jeden Fall gehört das Anlegen in mindestens eine separate Funktion!

- Überlege mal, wann die Schleife verlassen wird (Und *wieso*, also aus welchem Grund! Und, ob dabei die Variable ``logged`` eine Rolle spielt!)

- Zeile 23 ist für die wahren Metaller... äh... "Boole-isten"... ``logged`` *ist* vom Typ ``bool``... "falscher" kann es nicht werden, man braucht den Vergleich also nicht! ``while`` prüft auf den *Wahrheitswert* des nachstehenden Ausdrucks. Ein boolescher Ausdruck kann *direkt* ausgewertet werden, ohne, dass man da Vergleiche anstellen müsste. Alle anderen Ausdrücke haben ebenfalls einen Wahrheitswert; Python ermittelt den dann *implizit*. Bei Integerwerten ist die "0" falsch, alles andere ist wahr, leere Strings sind *immer* falsch, alle anderen wahr, usw. Du kannst Dir das einfach angucken, indem Du Dir das mal per ``bool``-Funktion in einer Python-Shell anguckst, also z.B. ``bool("")`` und bool("foo")``...
Drum merke Dir: Vergleiche auf ``True`` oder ``False`` kann man sich *immer* sparen, da der Wert, gegen den man vergleicht, offenbar einen eigenen Wahrheitswert besitzen muss. Und dieser kann *immer* direkt ausgewertet werden.

- Generell würde man da eher ``while True`` schreiben, also die "klassische" Endlosschleife und diese dann an geeigneter Stelle mittels ``break`` verlassen.

- Zeilen 24 & 25: ``uname`` und ``upass`` sind doofe Namen... wieso das ``user`` abkürzen? Autocompletion existiert und auf die Bytes müssen wir beim Quellcode nicht mehr schauen wie noch vielfach in den 80er Jahren.

- Zeile 26: Doofer Name, weil Du eine Typinformation in den Namen verpackst, was Du ebenfalls unterlassen solltest. Vor allem ist die Zeile aber obsolet, weil mit der Liste nichts mehr gemacht wird!

- Zeile 27: Wieso baust Du eine Query, bei der Du etwas zurücklieferst, was Du bereits kennst? (also den Benutzernamen) Da wäre ein ``SELECT COUNT(*) FROM...`` imho sinnvoller, bei dem man anschließend auf die Anzahl == 1 testen sollte.

- Zeile 28: Wäre da ein ``fetchone`` nicht sinnvoller? Ich hätte erwartet, dass es *niemals* zwei Benutzernamen mit denselben Passwörtern geben sollte... (Wobei die Struktur der DB auch suboptimal ist! Da sollte man schon einen unique constraint auf Benutzernamen und Passwort legen - sowie einen Index natürlich)

- Zeile 29: ``liste`` ist ein doofer Name! Da *kann* gar keine "Liste" herauskommen, sondern allenfalls eine Art Tupel (eben eine Ergebniszeile der Query). Benenne es also um.

- Zeile 30: Was glaubst Du passiert da? Meinst Du, da kann überhaupt einmal etwas falsches herauskommen? (Denk mal dran, *woher* ``liste`` stammt und was Du dann mit ``in`` überprüfst)

- Die Zeilen 40 & 41 gehören da natürlich auch nicht hin... eine Verbindung sollte man nur schließen, wenn sie auch aufgebaut werden konnte. Iirc unterstützen die DB2-API das Context Manager Protokoll, bzw. ganz simpel ``with``. (Analog zu Dateien ``with open(...) as f``). Ich bin gerade zu faul in der Doku nachzuschlagen Insofern wäre das immer meine erste Wahl, denn da braucht man sich nicht mehr selber um das Schließen kümmern.

Mist, jetzt habe ich so lange editiert, dass BlackJack schneller war

[Mr.White]

Ich such mir ein anderes Projekt.

[thorius]

Na na na - wer wird den so schnell aufgeben.

Da ich selbst auch recht neu bei Python bin, möchte ich dir mal ein paar Dinge auf den Weg geben, die mir gut geholfen haben wenn ich meine eigenen kleinen Sachen geschrieben habe. Bei meinen kleinen Projekten habe ich mir angewöhnt Variablen und Namen in Englisch zu schreiben und Kommentare in Deutsch. Damit habe ich eine erste klare Aussage getroffen, wie mein Code aussehen wird.

Nachdem eine Idee geboren ist fange ich mit einem einfachen Skelett an und füge auch ein, zwei Kommentare hinzu:

Code: Alles auswählen

def main():
    # Dokumentation im Code nicht vergessen!
    # 1. Nutzernamen und Nutzerpasswort einlesen
    # 2. Nutzernamen und Nutzerpasswort mit der Datenbank vergleichen
    print('main() wurde aufgerufen')

if __name__ == '__main__':
    main()

Dieses Stückchen Programm ist damit schon lauffähig und macht nichts kaputt. Der Vorteil dieses if __name__ == '__main__'-Kostruktes ist, dass ich das Programm allein starten kann, als auch als Modul benutzen kann:

Code: Alles auswählen

~/Dev/python$ python3 login.py 
main() wurde gerufen

Code: Alles auswählen

>>> import login
>>> login.main()
main() wurde gerufen

letzteres ist beim Testen von Codeschnippseln ganz praktisch.

Als nächstes füge ich dann Teil für Teil dem Programm hinzu. Wenn ich mir nicht ganz sicher bin ob das so funktioniert oder ich einen Schreibfehler gemacht habe, dann lade ich den Code als Modul und probiere es gleich aus.

Code: Alles auswählen

def main():
    # Dokumentation im Code nicht vergessen!
    # 1. Nutzernamen und Nutzerpasswort einlesen
    # 2. Nutzernamen und Nutzerpasswort mit der Datenbank vergleichen
    user_db = {'NutzerA': 'pwa', 'NutzerB': 'pwb'}   # Beispieldaten! Um die Datenbank kümmere ich mich später
    user_name = input('Bitte Nutzernamen eingeben: ')
    user_password = input('Bitte Passwort eingeben: ')
    
    if userdb[username] == user_password:
        print('Login erfolgreich')
    else:
        print('Login fehlgeschlagen')

if __name__ == '__main__':
    main()

Wenn ich nun dieses Codeschnippsel ausprobieren möchte wird es sicher fehlschlagen, ich habe mich bestimmt irgendwo verschrieben. Ich kenn mich halt.

Nach Bereinigung der Fehler und etwas probieren fällt auf, dass ich einen hässlichen Fehler bekomme, wenn der Nutzer überhaupt nicht in meiner (temporären) Datenbank ist. Also verbessere ich das auch noch:

Code: Alles auswählen

def main():
    # Dokumentation im Code nicht vergessen!
    # 1. Nutzernamen und Nutzerpasswort einlesen
    # 2. Nutzernamen und Nutzerpasswort mit der Datenbank vergleichen
    user_db = {'NutzerA': 'pwa', 'NutzerB': 'pwb'}   # Beispieldaten! Um die Datenbank kümmere ich mich später
    user_name = input('Bitte Nutzernamen eingeben: ')
    user_password = input('Bitte Passwort eingeben: ')

    if user_name in user_db:
        if user_db[user_name] == user_password:
            print('Login erfolgreich')
        else:
            print('Login fehlgeschlagen, Passwort nicht korrekt')
    else:
        print('Nutzername unbekannt')

if __name__ == '__main__':
    main()

Das sieht erstmal nach einem einfachen login aus. Noch etwas aufräumen und dann kümmere ich mich um die richtige Datenbank, Verschlüsselung der Passwörter etc pp. Ausserdem mache ich noch Kommentare an Funktionen, die ich für verbesserungswürdig halte.

Code: Alles auswählen

def input_username():
    # todo: Nutzername nur in Kleinbuchstaben zurückgeben?
    user_name = input('Bitte Nutzernamen eingeben: ')
    return user_name

def input_user_password():
    # todo: Passwort 'unsichtbar' schreiben lassen?
    user_password = input('Bitte Passwort eingeben: ')
    return user_password

def login_check(user_name, user_password):
    # Beispieldaten! Um die Datenbank kümmere ich mich später
    user_db = {'NutzerA': 'pwa', 'NutzerB': 'pwb'}
    
    if user_name in user_db:
        if user_db[user_name] == user_password:
            print('Login erfolgreich')
            return True # liefert True wenn erfolgreich
        else:
            print('Login fehlgeschlagen, Passwort nicht korrekt')
    else:
        print('Nutzername unbekannt')
    return False # in jedem andere Fall wird False zurückgegeben
        
def main():
    # Dokumentation im Code nicht vergessen!
    # 1. Nutzernamen und Nutzerpasswort einlesen
    # 2. Nutzernamen und Nutzerpasswort mit der Datenbank vergleichen
    user_name = input_username()
    user_password = input_user_password()

    logon = login_check(user_name, user_password)
    return logon

if __name__ == '__main__':
    main()

Das soll dir nur als kleines Beispiel dienen. Die Leute mit langjähriger Programmiererfahrung werden auch in meinen Beispielen noch Lücken finden und diese kritisieren. Aber dafür ist dieses Forum auch da und auch durch Kritik lernt man dazu.

Ab hier kannst du weitermachen, mach was draus

[BlackJack]

@thorius: Okay, Kritik: Die Kommentare zu den Rückgabewerten der `login_check()`-Funktion bieten keinen Mehrwert. Das steht da ja schon im Code.

Vom Vorgehen her ist es ungünstig bei der Ausgabe zwischen nicht vorhandenem Benutzer und falschem Passwort zu unterscheiden weil man es dadurch Angreifern leichter macht. Statt eine gültige Nutzername/Passwort-Kombination zu raten kann ein Angreife so erst einmal irgendein Passwort nehmen und Nutzernamen raten, und sobald das erste mal die Ausgabe kommt das Passwort sei falsch, kennt er definitiv einen Benutzernamen und kann anfangen nur noch das Passwort für diesen Benutzer zu raten. Und wenn man beide Fälle nicht mehr unterscheiden muss, dann vereinfacht sich der Test drastisch:

Code: Alles auswählen

def login_check(user_name, user_password):
    # Beispieldaten! Um die Datenbank kümmere ich mich später
    user_db = {'NutzerA': 'pwa', 'NutzerB': 'pwb'}
    return user_db.get(user_name) == user_password

Die Ausgaben gehören nicht die Funktion.

[Hyperion]

Ich such mir ein anderes Projekt.

Nichts für ungut, aber glaubst Du wirklich, dass das dann automatisch besser wird? Code Reviews dienen nicht dazu, Dich lächerlich zu machen, Deine Fähigkeiten in Frage zu stellen, o.ä., sondern Dir zu *helfen*, Deinen Code und Deine Fähigkeiten und Kenntnisse zu verbessern. Das klappt aber nur, wenn Du die Kritik veruschst anzunehmen und *umzusetzen*. Einfach in ein neues Projekt "flüchten" führt da imho zu keinem Lerneffekt...

Lass Dich doch nicht so schnell ins Bockshorn jagen! Programmieren lernen ist eine *lange* und oftmals *frustrierende* Erfahrung - da gibt es keine Abkürzungen