API di autenticazione Python

Question

Sto cercando una libreria Python che mi aiuti a creare un metodo di autenticazione per un'app desktop che sto scrivendo.Ho trovato diversi metodi nel framework web come Django o turbogears.

Voglio solo una sorta di associazione nome utente-password archiviata in un file locale.Posso scriverlo da solo, ma in realtà esiste già e sarà una soluzione migliore (non sono molto esperto con la crittografia).

Answer 1

Tratta quanto segue come pseudo-codice..

try:
    from hashlib import sha as hasher
except ImportError:
    # You could probably exclude the try/except bit,
    # but older Python distros dont have hashlib.
    try:
        import sha as hasher
    except ImportError:
        import md5 as hasher


def hash_password(password):
    """Returns the hashed version of a string
    """
    return hasher.new( str(password) ).hexdigest()

def load_auth_file(path):
    """Loads a comma-seperated file.
    Important: make sure the username
    doesn't contain any commas!
    """
    # Open the file, or return an empty auth list.
    try:
        f = open(path)
    except IOError:
        print "Warning: auth file not found"
        return {}

    ret = {}
    for line in f.readlines():
        split_line = line.split(",")
        if len(split_line) > 2:
            print "Warning: Malformed line:"
            print split_line
            continue # skip it..
        else:
            username, password = split_line
            ret[username] = password
        #end if
    #end for
    return ret

def main():
    auth_file = "/home/blah/.myauth.txt"
    u = raw_input("Username:")
    p = raw_input("Password:") # getpass is probably better..
    if auth_file.has_key(u.strip()):
        if auth_file[u] == hash_password(p):
            # The hash matches the stored one
            print "Welcome, sir!"

Invece di utilizzare un file separato da virgole, consiglierei di utilizzare SQLite3 (che potrebbe essere utilizzato per altre impostazioni e simili.

Inoltre, ricorda che questo non è molto sicuro: se l'applicazione è locale, gli utenti malintenzionati potrebbero probabilmente semplicemente sostituire il file ~/.myauth.txt file..L'autenticazione dell'applicazione locale è difficile da eseguire correttamente.Dovrai crittografare tutti i dati letti utilizzando la password dell'utente e generalmente prestare molta attenzione.

Answer 2

dbr ha detto:

def hash_password(password):
    """Returns the hashed version of a string
    """
    return hasher.new( str(password) ).hexdigest()

Questo è un modo davvero insicuro per eseguire l'hashing delle password.Voi non voglio fare questo.Se vuoi sapere perché leggi il Carta Bycrypt dai ragazzi che hanno realizzato il sistema di hashing delle password per OpenBSD.Inoltre, se desideri una discussione approfondita su come vengono violate le password, dai un'occhiata questa intervista con l'autore di Jack the Ripper (il popolare cracker di password Unix).

Ora B-Crypt è fantastico ma devo ammettere che non utilizzo questo sistema perché non avevo a disposizione l'algoritmo EKS-Blowfish e non volevo implementarlo da solo.Utilizzo una versione leggermente aggiornata del sistema FreeBSD che pubblicherò di seguito.Il succo è questo.Non limitarti ad eseguire l'hashing della password.Salare la password, quindi eseguire l'hash della password e ripetere circa 10.000 volte.

Se ciò non avesse senso ecco il codice:

#note I am using the Python Cryptography Toolkit
from Crypto.Hash import SHA256

HASH_REPS = 50000

def __saltedhash(string, salt):
    sha256 = SHA256.new()
    sha256.update(string)
    sha256.update(salt)
    for x in xrange(HASH_REPS): 
        sha256.update(sha256.digest())
        if x % 10: sha256.update(salt)
    return sha256

def saltedhash_bin(string, salt):
    """returns the hash in binary format"""
    return __saltedhash(string, salt).digest()

def saltedhash_hex(string, salt):
    """returns the hash in hex format"""
    return __saltedhash(string, salt).hexdigest()

Per implementare un sistema come questo la cosa fondamentale da considerare è la costante HASH_REPS.Questo è il fattore di costo scalabile in questo sistema.Sarà necessario eseguire dei test per determinare qual è il periodo di tempo accettabile che si desidera attendere affinché ciascun hash venga calcolato rispetto al rischio di un attacco basato su dizionario offline sul file della password.

La sicurezza è complessa e il metodo che presento non è il modo migliore per farlo, ma è significativamente migliore di un semplice hash.Inoltre è semplicissimo da implementare.Quindi, anche se non scegli una soluzione più complessa, questa non è la peggiore in circolazione.

Spero che questo aiuti, Tim

Answer 3

Penso che dovresti creare il tuo metodo di autenticazione in quanto puoi adattarlo al meglio alla tua applicazione ma utilizzare una libreria per la crittografia, ad esempio pycrypto o qualche altra libreria più leggera.

a proposito, se hai bisogno dei binari di Windows per pycrypto puoi procurarteli Qui

Answer 4

Se vuoi la semplicità, usa un dizionario in cui le chiavi sono i nomi utente e i valori sono le password (crittografate con qualcosa come SHA256). Salamoia da/verso il disco (poiché si tratta di un'applicazione desktop, presumo che il sovraccarico per mantenerla in memoria sarà trascurabile).

Per esempio:

import pickle
import hashlib

# Load from disk
pwd_file = "mypasswords"
if os.path.exists(pwd_file):
    pwds = pickle.load(open(pwd_file, "rb"))
else:
    pwds = {}

# Save to disk
pickle.dump(pwds, open(pwd_file, "wb"))

# Add password
pwds[username] = hashlib.sha256(password).hexdigest()

# Check password
if pwds[username] = hashlib.sha256(password).hexdigest():
   print "Good"
else:
   print "No match"

Tieni presente che questo memorizza le password come a hash - quindi sono sostanzialmente irrecuperabili.Se perdi la password, ti verrà assegnata una nuova, non riavrai quella vecchia.

Answer 5

import hashlib
import random

def gen_salt():
    salt_seed = str(random.getrandbits(128))
    salt = hashlib.sha256(salt_seed).hexdigest()
    return salt

def hash_password(password, salt):
    h = hashlib.sha256()
    h.update(salt)
    h.update(password)
    return h.hexdigest()

#in datastore
password_stored_hash = "41e2282a9c18a6c051a0636d369ad2d4727f8c70f7ddeebd11e6f49d9e6ba13c"
salt_stored = "fcc64c0c2bc30156f79c9bdcabfadcd71030775823cb993f11a4e6b01f9632c3"

password_supplied = 'password'

password_supplied_hash = hash_password(password_supplied, salt_stored)
authenticated = (password_supplied_hash == password_stored_hash)
print authenticated #True

Guarda anche gae-autenticarsi-su-un-sito-di-terze-parti

Answer 6

Usa " md5 " è molto meglio di base64

>>> import md5
>>> hh = md5.new()
>>> hh.update('anoop')
>>> hh.digest
<built-in method digest of _hashlib.HASH object at 0x01FE1E40>