Opiniões sobre essa função de login

$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.