Se eu criar um login para um aplicativo que tenha riscos de segurança médios a baixos (em outras palavras, não é um aplicativo bancário ou algo assim), é aceitável verificar uma senha inserida pelo usuário dizendo apenas algo como:

if(enteredPassword == verifiedPassword)
     SendToRestrictedArea();
else
     DisplayPasswordUnknownMessage();

Parece fácil ser eficaz, mas eu certamente não me importaria se isso fosse tudo o que era necessário. Uma verificação simples no nome de usuário / senha é suficiente?

Atualização: o projeto em particular é um serviço da Web, a verificação é inteiramente do servidor e não é de código aberto. O domínio muda como você lidaria com isso?

Não sem SSL

Isso não é seguro se a senha for enviada pela rede em texto sem formatação. Hashing da senha no lado do servidor também não é seguro se a senha for enviada pela rede em texto sem formatação.

Como a <input type="password"/>tag HTML envia seu conteúdo em texto sem formatação, isso será um problema, independentemente de como você armazena a senha no servidor, a menos que o site use SSL para transmitir a senha.

(A autenticação HTTP, que abre uma caixa de diálogo no navegador solicitando uma senha, pode ou não ser um texto não criptografado, dependendo de quais mecanismos de autenticação o servidor e o navegador têm em comum. Portanto, isso pode ser uma maneira de evitar isso sem usar SSL.)

Não se os administradores do site forem suspeitos

Agora, supondo que você esteja usando HTTPS para fazer o site, isso pode ser seguro se você confiar nos administradores do site (que podem ler senhas em texto sem formatação) e em outras pessoas que têm acesso à máquina para se comportarem corretamente. Agora, pode ser óbvio que eles podem fazer o que quiserem com seu site (uma vez que o administram), mas, se puderem ler a senha, também poderão usar os pares de login / senha roubados nos sites de outras pessoas.

Uma maneira de manter as senhas protegidas do administrador

Uma maneira segura de armazenar e verificar senhas é a seguinte:

def change_password user, new_password
  salt = random(65536).to_s(16) #will be 4 characters long
  password_hash = salt + hash(salt + new_password)
  store(user,password_hash)
end

def does_password_match? user, entered_password
  correct_password_hash = retrieve(user)
  salt = correct_password_hash[0...4]
  entered_password_hash = salt + hash(salt + entered_password)
  return correct_password_hash == entered_password_hash
end

Para a função hash, tente usar algo forte e algo que ainda não tenha boas tabelas de arco-íris. Você pode alterar o comprimento do sal, se necessário, contornar as tabelas do arco-íris.

Dependendo do ambiente em que você está, da variabilidade na latência da rede e se os nomes de usuário devem ser conhecidos publicamente, convém ter outro caminho de código computado hash('0000'+entered_password)se o usuário não existir, para impedir que invasores determinar quais nomes de usuário são válidos com base no tempo que leva para determinar se a senha está incorreta.

Isso sugere que você mantenha as senhas em texto aberto, o que é um não-não, mesmo em cenários de baixa segurança.

Você deveria ter:

if(hash(enteredPassword) == storedHash)

Você pode usar hash simples, como por exemplo MD5

Concordo com aqueles que sugerem o hash, mas também há uma roda que você está reinventando aqui. Dependendo da plataforma, é provável que você encontre uma ferramenta de gerenciamento de funções / usuários que cubra todo o material de gerenciamento de usuários com segurança e sem a necessidade de muita intervenção de sua parte.

A segurança é um assunto muito delicado, principalmente porque é preciso haver um equilíbrio entre incomodar seus usuários e garantir que suas informações estejam seguras. Normalmente, a fórmula para quanta segurança você precisa é uma função da importância dos dados. Em resumo:

isSecuritySufficient = effortToBreak > rewardForBreaking

Um mal-entendido comum sobre pessoas que fazem coisas ruins é o que elas buscam. A maioria deles pretende destruir a confiança . Você sempre deve fazer tudo o que puder para proteger a confiança de seus usuários. Parte disso é fazer sua devida diligência para garantir que a identidade deles seja segura. Eles podem se importar menos com os dados que armazenam, mas se preocupam com sua identidade - mesmo no limite mais baixo de segurança.

Há várias opções de baixo custo (para implementar e impactar o usuário) disponíveis. Um deles é o hash da senha no mínimo. Qualquer serviço que armazene algo tão sensível quanto uma senha em texto simples merece o constrangimento de ser invadido.

Princípios gerais para proteção de senha

• Nunca armazene senhas em texto simples
• Hash usando uma função de hash seguro como SHA-1 ou mesmo SHA-512 (até o MD5 é muito fácil de encontrar um hash correspondente)
• Use um valor de sal de aplicativo. O salt é bytes aleatórios adicionados a uma senha para dificultar a adivinhação. O sal deve ser gerado no tempo de execução e usando informações sobre a máquina como um valor inicial, em vez de armazenado e referenciado de qualquer forma.
• Use um valor de sal específico do usuário. Use isso em conjunto com o seu sal de aplicação.
• Criptografe todas as solicitações de autenticação que passam por uma rede. Isso significa usar SSL para aplicativos da web.

Como você usaria SSL para a autenticação, no mínimo você deseja criptografar todas as páginas que lidam com a conta do usuário. Isso permite que o máximo possível da identidade de um usuário seja protegido.

Uma observação sobre o gerenciamento de senhas : os usuários esquecem suas senhas de tempos em tempos. A pior coisa que você pode fazer é enviar a senha deles por e-mail. Se você implementar os princípios descritos acima, não poderá fazer isso de qualquer maneira. É muito melhor fornecer uma maneira de redefinir sua senha usando um link enviado para o endereço de e-mail registrado. Esse link de redefinição terá um código de uso único para garantir que a pessoa que acessa a página seja ela.

Tudo bem, a menos que a senha seja usada para qualquer outra coisa. Ainda existe o risco de o usuário decidir que pode reutilizar a senha, por isso seria ainda melhor com:

if(hash(enteredPassword) == hashOfValidPassword)

Se é para você ou para alguém que sabe que a senha está armazenada em texto sem formatação, tudo bem.

O código fonte está disponível? Mesmo se não, tenho certeza de que a senha pode ser encontrada nas instruções da máquina, caso o binário esteja disponível. Eu recomendaria fazer uma soma de verificação e compará-la.

Nunca negligencie a segurança, mesmo que não seja muito importante na sua opinião.

Absolutamente não. Leia isso e descreve como os hackers invadiram um site de segurança. Você planeja ter você como o elo mais fraco da cadeia.

Foi observado em algumas respostas que você não deve armazenar a senha em si, mas um hash - e você deve usar SSL.

Você pode dizer, qual é o grande problema? Se meu aplicativo for invadido, isso é de pouca preocupação. Bem, é um padrão bastante comum para os usuários reutilizarem a mesma senha em todos os sites. Se um hacker invadisse seu site e ganhasse acesso às senhas dos usuários, o hacker poderia se passar por muitos desses usuários em outros sites de maior importância para esses usuários. Portanto, invadir seu site pode ser o primeiro passo para um hacker obter acesso a informações bancárias para os usuários.

E apenas o hash da senha não é suficiente. Você precisa misturá-lo com sal. Os hackers têm tabelas de pesquisa inversa de hash, portanto, para um determinado hash, eles podem encontrar uma senha correspondente.

Se você optar por não implementar esses recursos, informe os usuários dessa falta de segurança, incentivando-os a não usar a mesma senha que eles usam em outros lugares.

Contanto que este seja o lado do servidor .. Então sim.

Se você quiser um pouco mais de segurança, vá para https e criptografe \ hash a senha no banco de dados.