API d'authentification Python

Question

Je recherche une bibliothèque python qui m'aidera à créer une méthode d'authentification pour une application de bureau que j'écris. J'ai trouvé plusieurs méthodes dans un framework web tel que django ou turbogears.

Je veux juste une sorte d'association nom d'utilisateur / mot de passe stockée dans un fichier local. Je peux l’écrire moi-même, mais j’existe vraiment et cela sera déjà une meilleure solution (je ne parle pas très bien le cryptage).

Answer 1

Traitez ce qui suit comme un pseudo-code.

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!"

Au lieu d'utiliser un fichier séparé par des virgules, je vous recommande d'utiliser SQLite3 (qui pourrait être utilisé pour d'autres paramètres, par exemple.

N'oubliez pas non plus que ce n'est pas très sécurisé - si l'application est locale, les utilisateurs malveillants pourraient probablement simplement remplacer le fichier ~ / .myauth.txt . L'authentification d'application locale est difficile à effectuer. bien. Vous devrez chiffrer toutes les données lues à l'aide du mot de passe de l'utilisateur et soyez généralement très prudent.

Answer 2

dbr a dit:

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

C’est un moyen vraiment peu sûr de hacher les mots de passe. Vous ne voulez pas faire cela. Si vous voulez savoir pourquoi, lisez le Papier Bycrypt cette interview avec l'auteur de Jack the Ripper (le célèbre pirate des mots de passe unix).

Maintenant, B-Crypt est génial mais je dois avouer que je n’utilise pas ce système car je n’avais pas l’algorithme EKS-Blowfish disponible et je ne voulais pas le mettre en œuvre moi-même. J'utilise une version légèrement mise à jour du système FreeBSD que je publierai ci-dessous. L'essence est la suivante. Ne pas simplement hacher le mot de passe. Salez le mot de passe, puis hachez le mot de passe et répétez 10 000 fois.

Si cela n'a pas de sens, voici le code:

#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()

Pour déployer un système comme celui-ci, l'élément clé à considérer est la constante HASH_REPS. C'est le facteur de coût évolutif de ce système. Vous devrez effectuer des tests pour déterminer le temps qu'il vous faut exceptionnellement pour attendre que chaque hachage soit calculé, par rapport au risque d'une attaque hors dictionnaire par dictionnaire sur votre fichier de mots de passe.

La sécurité est difficile et la méthode que je présente n’est pas la meilleure façon de le faire, mais elle est nettement meilleure qu’un simple hachage. En outre, il est extrêmement simple à mettre en œuvre. Donc, même si vous ne choisissez pas une solution plus complexe, ce n'est pas la pire des solutions.

espérons que cela aide, Tim

Answer 3

Je pense que vous devriez créer votre propre méthode d'authentification, car vous pouvez adapter celle-ci à votre application tout en utilisant une bibliothèque de chiffrement, telle que pycrypto ou une autre bibliothèque plus légère.

btw, si vous avez besoin des fichiers binaires Windows pour pycrypto, vous pouvez les obtenir ici

Answer 4

Si vous voulez simple, utilisez un dictionnaire où les clés sont les noms d'utilisateur et les valeurs les mots de passe (chiffrés avec quelque chose comme SHA256). Pickle sur le disque (car il s'agit d'une application de bureau, m en supposant que le temps système nécessaire pour le garder en mémoire sera négligeable).

Par exemple:

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"

Notez que cela stocke les mots de passe sous forme de hash - ils sont donc essentiellement irrécupérable. Si vous perdez votre mot de passe, vous en obtiendrez un nouveau et non l'ancien.

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

voir aussi gae-authenticate-to-a-3rd-party-site

Answer 6

Utilisez " md5 " c'est beaucoup mieux que base64

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