Koden fungerar och gör vad den ska.. men jag vill ha era synpunkter på den...kanske någon säkerhetsgrejj jag missat eller något annat.
Jag var tvungen att lägga allting i två inlägg... mkt tecken
jag vill också nämna att settings.php bara innehåller tre variablar..static_salt, usr_min_lenght och pwd_min_length... och på namnen hör ni vad dem gör.
Såg också att strukturen på koden inte blev helt ok... är nog lättare om man kopierar den till sin egna editor.
<?php
class login
{
private $static_salt; //Lagrar ett statiskt salt. Detta salt finns i settings.php
private $conn; //Lagrar en anslutning till databasen
private $generate; //Lagrar en anslutning till klassen accountHandler
private $usr_min_length; //Lagrar minsta antalet tecken som användarnamn får ha. Går att ställa in i settings.php
private $pwd_min_length; //Lagrar minsta antalet tecken som lösenordet får ha. Går att ställa in i settings.php
private $username; //Lagrar användarnamnet från formuläret
private $password; //Lagrar lösenordet från formuläret
private $db_id; //Lagrar id't från databasen
private $db_username; //Lagrar användarnamnet från databasen
private $db_password; //Lagrar lösenordet från databasen
private $db_salt; //Lagrar saltet från databasen
private $db_x; //Lagrar x från databasen
private $user_exists; //True om användaren existerar, annars False
private $user_length; //True om längden på användarnamnet är acceptabelt, annars False
private $password_length; //True om längden på lösenordet är acceptabelt, annars False
private $password_match; //True om lösenordet från formuläret(efter behandling) matchar lösenordet från databasen, annars False
//Metoden autoladdas så fort klassen körs. Den förser klassen med nädvändig information
public function __construct($username, $password, $static_salt, $usr_min_length, $pwd_min_length, $conn, $hndl)
{
$this->username = $username; //Lagrar användarnamnet från formuläret i klassvariablen username
$this->password = $password; //Lagrar lösenordet från formuläret i klassvariablen password
$this->static_salt = $static_salt; //Lagrar det statiska saltet från settings.php i klassvariablen static_salt
$this->usr_min_length = $usr_min_length; //Lagrar en siffra i klassvariablen $usr_min_length som motsvarar antalet tecken ett användarnamn minst ska ha. Värdet finns i settings.php
$this->pwd_min_length = $pwd_min_length; //Lagrar en siffra i klassvariablen $pwd_min_length som motsvarar antalet tecken ett lösenord minst ska ha. Värdet finns i settings.php
$this->conn = $conn; //Lagrar anslutningen till databasen i klassvariablen $conn
$this->generate = $hndl; //Lagrar en anslutning till kalssen accountHandler i klassvariablen generate
$this->check_values(); //Anropar metoden check_values()
$this->bake_values(); //Anropar metoden bake_values()
$this->set_session(); //Anropar metoden set_sessiob()
}
/*
####
###
##
#
*/
//Metoden för att kontrollera värden från formuläret
private function check_values()
{
//Räknar om det angivna användarnamnet förekommer 0 gånger, eller 1 gång.
$do= $this->conn->prepare ("SELECT COUNT(id) as antal FROM table WHERE username = :user ");
$do->bindParam(':user', $this->username, PDO::PARAM_STR);
$do->execute();
$obj = $do->fetch(PDO::FETCH_OBJ);
$db_count = intval($obj->antal); //Innehåller antalet gånger användarnamnet från formuläret förekommer i databasen
if($db_count < 1){ $this->user_exists = false; } //Kontrollerar om användaren inte existerar
if($db_count > 0){ $this->user_exists = true; } //Kontrollerar om användare existerar
if(strlen($this->username) < $this->usr_min_length) { $this->user_length = false; } //Kontrollerar om längden på användarnamnet inte är acceptabelt
if(strlen($this->username) >= $this->usr_min_length) { $this->user_length = true; } //Kontrollerar om längden på användarnamnet acceptabelt
if(strlen($this->password) < $this->pwd_min_length) { $this->password_length = false; } //Kontrollerar om längden på lösenordet inte är acceptabelt
if(strlen($this->password) >= $this->pwd_min_length) { $this->password_length = true; } //Kontrollerar om längden på lösenordet är acceptabelt
//En checkpoint som måste passeras
if($this->user_exists == true){
if($this->user_length == true){
if($this->password_length == true){
//Hämtar alla nödvändiga uppgifter från databasen
$do2 = $this->conn->prepare ("SELECT id, username, password, salt, x FROM table WHERE username = :user ");
$do2->bindParam(':user', $this->username, PDO::PARAM_STR);
$do2->execute();
$obj = $do2->fetch(PDO::FETCH_OBJ);
$this->db_id = intval($obj->id); //Lagrar kontots id i klassvariablen $db_id
$this->db_username = $obj->username; //Lagrar kontots användarnamn i klassvariablen $db_username
$this->db_password = $obj->password; //Lagrar kontots lösenord i klassvariablen $db_password
$this->db_salt = $obj->salt; //Lagrar kontots salt i klassvariablen $db_salt
$this->db_x = intval($obj->x); //Lagrar kontots x i klassvariablen $db_x
$conn = null; //Stänger anslutningen till databasen
}
}
}
}
/*
####
###
##
#
*/
//Metod som tar hand om lösenord, salt och x. Lagrar även allt i databasen
private function bake_values()
{
//Checkpoint som måste passeras
if($this->user_exists == true){
if($this->user_length == true){
if($this->password_length == true){
//Här tar vi hjälp av en annan klass som tar hand om lösenordet, saltet, x, samt lagrar det i databasen
$baked_pass = $this->generate->system_password($this->password, $this->static_salt, $this->db_salt, $this->db_x);
if($baked_pass == $this->db_password) { $this->password_match = true; } //Kontrollerar om lösenordet från formuläret (efter behandling) matchar lösenordet från databasen
if($baked_pass !== $this->db_password){ $this->password_match = false; } //Kontrollerar om lösenordet från formuläret (efter behandling) inte matchar lösenordet från databasen
}
}
}
}
/*
####
###
##
#
*/
//Metod som skriver ut error-meddelande
public function show_errors()
{
if($this->password_match == false){ $error = "Användarnamn eller lösenord felaktigt!"; } //Om lösenorden inte matchar
if($this->user_length == false){ $error = "Användarnamn eller lösenord felaktigt!"; } //Om längden på användarnamnet inte är acceptabelt
if($this->password_length == false){ $error = "Användarnamn eller lösenord felaktigt!"; } //Om längden på lösenordet inte är acceptabelt
if($this->user_exists == false){ $error = "Användarnamn eller lösenord felaktigt!"; } //Om användaren existerar
echo $error; //Skriver ut meddelandet
}
/*
####
###
##
#
*/
//Metod som skapar sessionen
private function set_session()
{
if($this->password_match == true){
if($this->user_length == true){
if($this->password_length == true){
if($this->user_exists == true){
session_start();
$PROT = sha1(mt_rand($this->db_x, 100));
$_SESSION['accID'] = $this->db_id;
$_SESSION['accUSER'] = htmlspecialchars($this->db_username);
$_SESSION['accPROT'] = $PROT;
$_SESSION['accSEC'] = sha1($_SESSION['accPROT'] . $_SESSION['accID'] . $_SESSION['accUSER'] . strlen($_SESSION['accUSER']));
}
}
}
}
}
} //Avslutar klassen
?>
<?php
class accountHandler
{
//Metod som tar hand om "skapa konto" processen
public function new_system_account($username, $password, $email, $static_salt, $date, $conn)
{
$db_x = mt_rand(2, 20); //Genererar ett slumpat tal mellan 2 och 20. Detta tal används för att bestämma hur många gånger salt-loopen ska köras.
$signs = "abcdefghijklmnopqrstuvxyz 1234567890!@#£%&=?+-"; //Ur denna variablen hämtas alla tecken för det slumpade saltet
$length = strlen($signs); //innehåller värdet på antalet tecken som finns i $signs
//Skapar ett slumpat salt
for($i=0; $i<$db_x; $i++)
{
$rand = mt_rand(0, $length);
$salt .= substr($signs, $rand, 1);
}
$db_salt = sha1($salt.md5($db_x)); //Innehåller det färdiga saltet (dynamiskt)
$db_pass = $this->system_password($password, $static_salt, $db_salt, $db_x); //Anropar metoden system_password för att behandla lösenordet
//Sparar kontot i databasen
$do = $conn->prepare("INSERT INTO table (username, password, salt, x, email, date) VALUES (:user, :pass, :salt, :x, :email, :date)");
$do->bindParam(':user', $username, PDO::PARAM_STR);
$do->bindParam(':pass', $db_pass, PDO::PARAM_STR);
$do->bindParam(':email', $email, PDO::PARAM_STR);
$do->bindParam(':salt', $db_salt, PDO::PARAM_STR);
$do->bindParam(':x', $db_x, PDO::PARAM_INT);
$do->bindParam(':date', $date, PDO::PARAM_STR);
$do->execute();
$conn = null; //Stänger anslutningen till databasen.
}
/*
####
###
##
#
*/
//Metod som behandlar lösenord från formulär
public function system_password($password, $static_salt, $db_salt, $db_x)
{
$password = md5($password); //Hashar lösenordet med md5
//Loop-behandlar lösenordet
for($i=0; $i < $db_x; $i++)
{
$password = md5($static_salt.sha1($password).$db_salt.md5($db_x));
}
$baked_pass = sha1($password); //Färdigt lösenord
return $baked_pass;
}
}
?>
connect.php
<?php
$hostname = 'address'; // Adress till databasen
$username = '****'; //Användarnamn för databasen
$password = '****'; //Lösenord för databasen
$database = '****'; //Namnet på databasen
//Låt denna variabel vara som den är. Används för att införa datum och tid i databasen
$date = date("Y-m-d");
//Följande skapar själva anslutningen till database
try {
$conn = new PDO("mysql:host=$hostname;dbname=$database", $username, $password);
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>
411 ms totalt · 4 externa anrop · v20260731065814-full.0583408b
