Python API de Autenticação

Question

Eu estou olhando para uma biblioteca em python que vai me ajudar a criar um método de autenticação para um aplicativo de área de trabalho que eu estou escrevendo.Eu encontrei várias método na web framework, tais como django ou turbogears.

Eu só quero uma espécie de nome de usuário-senha associação armazenados em um arquivo local.Eu posso escrever isso por mim, mas eu estou realmente ele já existe e vai ser uma solução melhor (eu não sou muito fluente com criptografia).

Answer 1

Tratar o seguinte pseudo-código.

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

Em vez de usar um arquivo separado por vírgulas, eu recomendaria usar SQLite3 (que poderia ser usado para outras configurações e tal.

Além disso, lembre-se que este não é muito segura - se a aplicação é local, o mal, os usuários poderiam, provavelmente, basta substituir o ~/.myauth.txt arquivo..Local de aplicação auth é difícil fazer o bem.Você vai ter para criptografar os dados que ele lê usando a palavra-passe de utilizadores e, em geral, ser muito cuidadoso.

Answer 2

dbr disse:

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

Este é realmente um inseguro forma de hash de senhas.Você não queremos fazer isso.Se você quer saber por que ler a Bycrypt Papel por que os caras que fizeram o hash da senha do sistema para o OpenBSD.Além disso, se querem uma boa discussão sobre como as senhas são quebrados confira esta entrevista com o autor de Jack, o Estripador (o popular unix password cracker).

Agora B-Crypt é grande, mas eu tenho que admitir que eu não uso esse sistema porque eu não tenho EKS-algoritmo Blowfish disponível e não querem implementar é o meu eu.Eu uso um pouco versão atualizada do sistema FreeBSD que vou postar abaixo.A essência é esta.Não apenas o hash da palavra-passe.Sal a palavra-passe, em seguida, o hash de senha e repita 10.000 ou menos vezes.

Se isso não faz sentido aqui está o código:

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

Para a implantação de um sistema como esse, a principal coisa a se considerar é o HASH_REPS constante.Este é o escalável fator de custo do sistema.Você precisará de fazer testes para determinar o que é o exceptable quantidade de tempo que você quer esperar para cada hash para ser calculado versus o risco de um dicionário offline de ataque com base no seu arquivo de senha.

Segurança é difícil, e o método que eu apresento não é a melhor maneira de fazer isso, mas é significativamente melhor do que um simples hash.Além disso, ele é muito simples de implementar.Assim, mesmo que você não escolha uma solução mais complexa que isso não é a pior que existe.

espero que isso ajude, Tim

Answer 3

Eu acho que você deve fazer o seu próprio método de autenticação que você pode torná-lo caber seu pedido da melhor forma, mas usar uma biblioteca para a criptografia, tais como pycrypto ou algum outro mais leve biblioteca.

btw, se você precisar de binários do windows para pycrypto você pode obtê-los aqui

Answer 4

Se você deseja simples e, em seguida, usar um dicionário onde as chaves são os nomes e os valores são as palavras-passe (encriptadas com algo como SHA256). Picles ele/para o disco (como esta é uma aplicação de ambiente de trabalho, eu estou supondo que o custo de mantê-lo na memória será insignificante).

Por exemplo:

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"

Note que este armazena a senha hash - então eles são, essencialmente, irrecuperável.Se você perder sua senha, você ia ficar alocado um novo, não obter a antiga de volta.

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

veja também gae-autenticar-para-um-3rd-party-site

Answer 6

Use " md5 " é muito melhor do que base64

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