Opiniões sobre essa função de login

[LuanMartinsTI 0]

Bom, uns dias atras abri um topico sobre as melhores criptografias para senha, TOPICO, então seguindo o concelho da galera, fiz usando a Bcripty, e ficou da seguinte forma a função de login

 

Aqui é a criação do objeto e a chamada da função apos o preenchimento no formulário, peguei apenas a parte necessária, já foi tudo filtrado e enviado nessa parte.

$cliente = new Cliente($email, $senha);
$FazerLogin = new ClientePdo();   
$logou = $FazerLogin->fazer_login($cliente, $senha);  
if ($logou === true) {  
   $sessao = new Sessao();
   $sessao->carregaSessao($logou);
}else{
   echo "Verifique os dados";
}

 

Logo então é chamada a função fazer_login, então abaixo o código

public function fazer_login($cliente, $senha){
        try{   
            if($this->validar_senha($cliente, $senha) === true){
                $query = "SELECT * FROM clientes WHERE email = :email";
                $this->Select = $this->Conn->prepare($query);
                $this->Select->BindValue(':email', $cliente->getEmail(), PDO::PARAM_STR);
                $this->Select->execute();
                if($this->Select->rowCount() == 1){
                    return $this->Select->fetch(PDO::FETCH_ASSOC);
                }else{
                    return false;
                } 
            }else{
                return "Senha Invalida!";
            }                     
        } catch (PDOException $ex) {
            exibeMensagens($Msg, $ErrNo);        
        }
    }

Logo na primeira linha da função ja existe uma outra chamada, validar_senha com o objeto e a senha enviada separadamente, e compara se o resultado é true;

então vamos ao código da função.

private function validar_senha($cliente, $senha){
        try{
            $dados = $this->dados_usuario($cliente);
            if($dados != null){
                foreach($dados as $x){
                    $hash = $x['senha'];                    
                    if($hash != null){
                        if (crypt($senha, $hash) === $hash) {
                            return true;
                        } else {
                            return false;
                        }
                    }
                }
            }
        } catch (PDOException $ex) {
            exibeMensagens($Msg, $ErrNo); 
        }
    }

Como podem ver, eu fiz um metodo para comparar as senhas digitada e a senha registrada no banco, e depois, para pegar os dados e fazer o login eu faço ele apenas com um where no email, mas ele entra lá só se as senhas forem iguais, 

 

É a primeira vez que faço dessa forma, a pergunta é, é seguro fazer login comparando senha e email separadamente? Eu fiz varias tentativas aqui, e quando digitava senha errada, ou email errado não entrava, e quando digitava uma senha de uma outra conta tambem não, me pareceu seguro, mas conto com a opinião de vocês, pois é algo grande.

[Don Benatti 28]

 

$cliente = new Cliente($email, $senha);
$FazerLogin = new ClientePdo();   

// Repetição desnecessária de $senha
$logou = $FazerLogin->fazer_login($cliente, $senha);

Em fazer_login você passa a instancia de Cliente e em seguida senha novamente, você já passou $email e $senha para Cliente, o correto é fazer_login aceitar apenas um parâmetro

public function fazer_login(Cliente $cliente)
{
    $senha = $cliente->obterSenha();
}

 

Dito isso, vamos para a questão da criptografia que falamos no outro post:

Primeira coisa que você precisa colocar em prática é a eliminação de dependências, desacoplando o modo como lida com a segurança do seu sistema para que ele trabalhe independente criando pacotes separados.

 

Vou te passar uma ideia de como criar um pacote relacionado a criptografia no seu sistema:

 

Vamos criar um novo projeto e dentro da pasta do projeto uma chamada crypt, pra não alongar, vou fazer um resumo para depois você continuar estudando.

Dentro da pasta crypt cria outra chamada cipher e cria uma classe PHP Crypt.php, vou adicionar apenas dois métodos essenciais.

 

Utilizaremos namespaces como security\crypt\... security será o nome da projeto e da pasta principal e crypt será um package

 

Dentro da pasta cipher, vamos criar uma interface e uma classe concreta chamada Blowfish.

crypt/cipher/CipherInterface.php

<?php

namespace security\crypt\cipher;

interface CipherInterface
{
    /**
     * @param string|null $raw_password
     */
    public function __construct($raw_password = null);
    
    /**
     * @return string
     * @throws \InvalidArgumentException
     */
    public function crypt();
    
    /**
     * @return string
     */
    public function genSalt();
    
    /**
     * @var string $salt
     * @return void
     */
    public function setSalt($salt);
    
    /**
     * @return string
     */
    public function getSalt();
    
    /**
     * @param int $cost
     * @return void
     * @throws \InvalidArgumentException
     */
    public function setCost($cost);
    
    /**
     * @return int
     */
    public function getCost();
    
    /**
     * @param string $raw_password
     * @return void
     */
    public function setRawPassword($raw_password);
    
    /**
     * @return string
     */
    public function getRawPassword();
    
    /**
     * @param string $crypted
     * @return void
     */
    public function setCryptedPassword($crypted);
    
    /**
     * @return string
     */
    public function getCryptedPassword();
    
    /**
     * @return boolean
     */
    public function verify();
}

Agora vamos implementar nossa interface na classe a seguir

crypt/cipher/Blowfish.php

<?php

namespace security\crypt\cipher;

class Blowfish implements CipherInterface
{
    private $rawPassword = null;
    
    private $salt = null;
    
    private $cryptedPassword = null;
    
    private $cost = 10;
    
    /**
     * @param string|null $raw_password
     */
    public function __construct($raw_password = null)
    {
        $this->setRawPassword($raw_password);
    }
    
    /**
     * @return string
     */
    public function genSalt()
    {
        return $this->salt = mcrypt_create_iv(22, MCRYPT_DEV_URANDOM);
    }
    
    /**
     * @var string $salt
     * @return void
     */
    public function setSalt($salt)
    {
        $this->salt = $salt;
    }
    
    /**
     * @return string
     */
    public function getSalt()
    {
        return $this->salt;
    }
    
    /**
     * @param int $cost
     * @return void
     * @throws \InvalidArgumentException
     */
    public function setCost($cost)
    {
        if (!is_int($this->cost)) {
            throw new \InvalidArgumentException("Expected type int, got " . gettype($cost));
        }
        
        if ($this->cost < 5) {
            throw new \InvalidArgumentException("Invalid cost, min is 5!");
        }
        
        $this->cost = $cost;
    }
    
    /**
     * @return int
     */
    public function getCost()
    {
        return $this->cost;
    }
    
    /**
     * @param string $raw_password
     * @return void
     */
    public function setRawPassword($raw_password)
    {
        $this->rawPassword = $raw_password;
    }
    
    /**
     * @return string
     */
    public function getRawPassword()
    {
        return $this->rawPassword;
    }
    
    /**
     * @param string $crypted
     * @return void
     */
    public function setCryptedPassword($crypted)
    {
        $this->cryptedPassword = $crypted;
    }
    
    /**
     * @return string
     */
    public function getCryptedPassword()
    {
        return $this->cryptedPassword;
    }
    
    /**
     * @return string
     * @throws \InvalidArgumentException
     */
    public function crypt()
    {
        if ($this->rawPassword === null || (!strlen(trim($this->rawPassword)))) {
            throw new \InvalidArgumentException("Raw password is invalid!");
        }
        
        if ($this->salt === null) {
            $this->genSalt();
        }
        
        if (function_exists("password_hash")) {
            return $this->cryptedPassword = password_hash($this->rawPassword, PASSWORD_BCRYPT, [
                'cost' => $this->cost,
                'salt' => $this->salt
            ]);
        }
        else {
            $this->setSalt(strtr(base64_encode(mcrypt_create_iv(16, MCRYPT_DEV_URANDOM)), "+=", ".."));
            return $this->cryptedPassword = crypt($this->rawPassword, "$2a$" . $this->cost . "$" . $this->salt . "$");
        }
    }
    
    /**
     * @return boolean
     * @throws \UnexpectedValueException
     */
    public function verify()
    {
        if ($this->rawPassword === null || (!strlen(trim($this->rawPassword)))) {
            throw new \UnexpectedValueException("Invalid raw password!");
        }
        
        if ($this->cryptedPassword === null || (!strlen(trim($this->cryptedPassword)))) {
            throw new \UnexpectedValueException("Invalid crypted password!");
        }
        
        if (function_exists("password_verify")) {
            return password_verify($this->rawPassword, $this->cryptedPassword);
        }
        
        return (crypt($this->rawPassword, $this->cryptedPassword) === $this->cryptedPassword);
    }
}

Fiz aqui apenas um teste básico dessa implementação, escrevi ela rapidamente exclusivamente para nossa conversa sobre criptografia do outro post e desse agora, espero que seja útil para seus estudos.

 

Agora Luan, vamos criar a classe que servirá de ponte para nossos ciphers, mas não sabemos o que tem do outro lado, por isso usaremos a interface CipherInterface para eliminar dependências de um tipo de criptografia apenas, dessa maneira no futuro você poderá mudar de Blowfish para outro sem precisar refatorar seu sistema inteiro

 

crypt/Crypt.php

<?php

namespace security\crypt;

use security\crypt\cipher\CipherInterface;

class Crypt
{
    /**
     * @var CipherInterface
     */
    private $cipher = null;
    
    /**
     * @param CipherInterface $cipher
     */
    public function __construct(CipherInterface $cipher)
    {
        $this->cipher = $cipher;
    }
    
    /**
     * @return CipherInterface
     */
    public function getCipher()
    {
        return $this->cipher;
    }
}

Depois vamos definir um tipo de criptografia por padrão para não ter que passar Blowfish o tempo todo que instanciar Crypt, mas antes por questões didáticas vamo instanciar Crypt.

 

test.php dentro da pasta security que estamos usando no exemplo e dentro dela temos o package crypt

<?php

include "crypt/Crypt.php";
include "crypt/cipher/CipherInterface.php";
include "crypt/cipher/Blowfish.php";

use security\crypt\Crypt;
use security\crypt\cipher\Blowfish;

$password = "123";

// Instanciamos e usamos Blowfish
$crypt = new Crypt(new Blowfish($password));

/*
 * Exemplo básico
 * */
$cipher = $crypt->getCipher();

try {
    $hash = $cipher->crypt();
    
    //var_dump($hash);
    
    // Agora validando
    $cipher->setCryptedPassword($hash);
    
    var_dump($cipher->verify());
}
catch (\InvalidArgumentException $e) {
    echo $e->getMessage();
}

O PHP 7 em diante não gosta da ideia de você gerar um salt, o preferível é deixar o padrão, mas para explicar melhor aqui, vamos setar outras coisas.

<?php
/*
 * Exemplo com mais opções
 * */
$cipher = $crypt->getCipher();

try {
    $cipher->setCost(11);
    $cipher->setSalt(/* Seu salt aqui */);
}
catch (\InvalidArgumentException $e) {
    echo $e->getMessage();
    exit(1);
}

Agora vamos deixar um tipo de criptografia padrão, para isso vamos aceitar null lá em Crypt.php

Agora o método __construct de Crypt ficou assim:

/**
 * @param CipherInterface|null $cipher
 */
public function __construct(CipherInterface $cipher = null)
{
    if ($cipher === null) {
        $cipher = new Blowfish();
    }
    $this->cipher = $cipher;
}

Se optar pelo algoritmo padrão, terá que setar um password

/*
 * Exemplo com um algoritmo padrao
 * */
$crypt = new Crypt();

$cipher = $crypt->getCipher();
$cipher->setRawPassword("123");

try {
    $hash = $cipher->crypt();
    
    //var_dump($hash);
    
    // Agora validando
    $cipher->setCryptedPassword($hash);
    
    var_dump($cipher->verify());
}
catch (\InvalidArgumentException $e) {
    echo $e->getMessage();
    exit(1);
}

Depois disso Luan, você poderá usar qualquer algoritmo implementando apenas CipherInterface

class MyAlgoritm implements CipherInterface
{}

Fiz apenas alguns testes básicos aqui, apenas para colocar pra funcionar, mas acredito que didaticamente vai ser útil para seus estudos.