private static
Is het een goede manier om vanuit een static functie inloggegevens
op te halen?
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php
class DBverbinding{
private static $host;
private static $db;
private static $user;
private static $password;
public static function getHost(){
self::$host = "127.0.0.1";
return self::$host;
}
public static function getDB(){
self::$db = "unthinking";
return self::$db;
}
public static function getUser(){
self::$user = "";
return self::$user;
}
public static function getPW(){
self::$password = "";
return self::$password;
}
}
?>
class DBverbinding{
private static $host;
private static $db;
private static $user;
private static $password;
public static function getHost(){
self::$host = "127.0.0.1";
return self::$host;
}
public static function getDB(){
self::$db = "unthinking";
return self::$db;
}
public static function getUser(){
self::$user = "";
return self::$user;
}
public static function getPW(){
self::$password = "";
return self::$password;
}
}
?>
Met private, protected en public werkt het namelijk allemaal vanuit een andere class.
Alvast bedankt.
Gewijzigd op 19/01/2015 23:08:59 door Unthinking majority
Unthinking majority op 19/01/2015 23:08:26:
Met private, protected en public werkt het namelijk allemaal vanuit een andere class.
Alvast bedankt.
Alvast bedankt.
vanuit de andere classes roep je enkel de methods (functies) aan. Probeer je echter de properties (variabelen) van de class te benaderen dan krijg je een foutmelding tenzij je de properties public maakt. Zo ook als je de methods private of protected maakt in plaats van public.
Gewijzigd op 19/01/2015 23:33:05 door Frank Nietbelangrijk
Ik zou protected methods willen ophalen vanuit de andere class.
DBverbinding::getHost() en de rest heb ik protected gezet.
Dat wil ik dan zo gebruiken maar ik krijg deze fout:
"Fatal error: Call to protected method DBverbinding::getHost() from context 'Unthinking' in i:\think\htdocs\unthinking.php on line 11"
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<?php
include_once "DBverbinding.class.php";
class Unthinking{
private $host;
private $database;
private $username;
private $password;
public function __construct(){
$this->host = DBverbinding::getHost();
$this->database = DBverbinding::getDb();
$this->username = DBverbinding::getUser();
$this->password = DBverbinding::getDb();
try{
$this->db = new PDO("mysql:host=". $this->host .";dbname=". $this->database ."",$this->username /*,$this->password */);
$this->db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
catch(PDOException $e)
{
$this->set_error("Fout op regel: ".$e->getLine());
$this->set_error("Foutmelding: ".$e->getFile());
$this->set_error("Fout in bestand: ".$e->getMessage());
}
}
}
$majority = new Unthinking;
?>
include_once "DBverbinding.class.php";
class Unthinking{
private $host;
private $database;
private $username;
private $password;
public function __construct(){
$this->host = DBverbinding::getHost();
$this->database = DBverbinding::getDb();
$this->username = DBverbinding::getUser();
$this->password = DBverbinding::getDb();
try{
$this->db = new PDO("mysql:host=". $this->host .";dbname=". $this->database ."",$this->username /*,$this->password */);
$this->db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
catch(PDOException $e)
{
$this->set_error("Fout op regel: ".$e->getLine());
$this->set_error("Foutmelding: ".$e->getFile());
$this->set_error("Fout in bestand: ".$e->getMessage());
}
}
}
$majority = new Unthinking;
?>
Gewijzigd op 20/01/2015 00:05:17 door unthinking majority
Als je goed bezig bent komt je code in een version control system (VCS) te staan.
Wachtwoorden wil je niet in dat VCS hebben staan maar in een configuratie bestand.
Zet a.u.b. wel een dummy config bestand in je VCS.
Je mag helemaal zelf weten of dat config bestand een ini file, een yaml file, xml file, json file of iets dergelijks is.
Verder heb je die info alleen nodig om een connectie op te zetten. Zodra de connectie tot stand is gekomen (of dat mislukt) wil je eigenlijk dat die data nergens meer in PHP te vinden is.
Zet je het in een array? Weg met de array!
Maak je een DatabaseConfig class die het config bestand uit leest? Weg met de instantie zodra je de gegevens niet meer nodig hebt!
PS. dat je geen VCS gebruikt is geen reden om een slechte gewoonte aan te leren.
Ik vind die manieren allemaal geweldig maar niet alle lijken mij echt veilig genoeg als ze
van overal bereikbaar kunnen zijn.
Alles in een array zetten is niet zo moeilijk en de array verwijderen of hergebruiken ook niet.
Op de website van yaml hebben ze het over een hack.
XML lijkt me handiger te gebruiken als er al een verbinding met een database is.
Json jquery is sowieso 90 kB en wil het liefst geen 90 kB dataverkeer gebruiken per inlogpoging.
ini lijkt me nog wel een handige manier.
Bij al deze vraag ik me wel af hoe de gegevens protected ingeladen kunnen worden dus niet buiten het object toegankelijk zijn.
Een slechte gewoonte aanleren is niet zo slecht volgens mij maar op gebied van veiligheid is het niet zo verstandig denk ik.
>> XML lijkt me handiger te gebruiken als er al een verbinding met een database is.
Wat bedoel je hiermee? Yaml of xml heeft niks met veiligheid te maken.
In mijn geval lijkt Yaml of xml overbodig omdat ik
gegevens van een centraal punt op zou willen halen om verbinding te maken met MySQL.
Een soort DHCP functie waarbij elke class de gegevens op kan halen om verbinding te maken met MySQL.
Ik vraag me af hoe ik bijvoorbeeld een statische functie zou kunnen gebruiken om daarbij private properties op te kunnen halen.
In ieder geval bedankt.
Gewijzigd op 20/01/2015 15:03:28 door unthinking majority
toegang tot de database hergebruiken.
Inderdaad eerder protected dan private. (srry was foutje)
het gaat om dit stukje:
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
$this->host = DBverbinding::getHost();
$this->database = DBverbinding::getDb();
$this->username = DBverbinding::getUser();
$this->password = DBverbinding::getDb();
?>
$this->host = DBverbinding::getHost();
$this->database = DBverbinding::getDb();
$this->username = DBverbinding::getUser();
$this->password = DBverbinding::getDb();
?>
Ik zou gegevens op willen halen maar ook willen hergebruiken.
Als host heb ik nu localhost of 127.0.0.1.
Maar als ik van host 1 naar host 2 ga wil ik niet dat alles gewijzigd moet maar dat er een vast centraal punt is.
Omdat het ip-adres van de mysql-host meestal niet variabel is, heb ik geleerd om static te gaan gebruiken.
Toevoeging op 20/01/2015 15:33:19:
Misschien een makkelijkere uitleg.
DATABASE gegevens
| |
\|/ \|/
registratie.php login.php
Gewijzigd op 20/01/2015 15:35:35 door unthinking majority
Je zou ook kunnen gaan werken met een service container (dependency injection) maar ik weet niet of je daar de kennis voor hebt.
De vraag was dus eigenlijk of het de beste manier is om een service container te gebruiken of een configuratiebestand.
Deze prioriteit hou ik altijd aan: veiligheid->snelheid->makkelijkheid
Variabel werkt alles maar statisch kan ik het niet veilig maken.
Met een zoekrobotje is dat zo te hacken.
Mijn voorkeur gaat naar een service container.
1 service punt waarbij honderden classen onderling met elkaar kunnen praten.
Ik wil niet dat een object ermee kan praten dus dat het protected blijft.
Objecten moeten ook met je service container praten, dus ik snap niet waar jouw angst vandaan komt. leg eens uit waar je bang voor bent? Wat denk jij dat er kan gebeuren?
zo de mysql login gegvens op kunnen halen.
En zou er remote alle adres en privacy gevoelige informatie opgehaald kunnen worden.
Dat heeft er mee te maken waarom veiligheid mijn eerste prioriteit is.
Dus zet je dat bestand buiten de public folder zodat niemand er bij kan.
Toevoeging op 20/01/2015 16:56:33:
Ik heb namelijk alleen nog maar een localhost.
PHP heb ik nog nooit public gebruikt.
Dus misschien dat mijn kennis daarbij misschien wat minder is.
Uiteraard. Ik denk dat je beter eerst even wat beter in kunt lezen hoe classes werken, want ik merk dat je hier nog niet helemaal goed van op de hoogte bent. Je trekt allerlei "vreemde" conclusies die niet kloppen.
Gewijzigd op 20/01/2015 16:58:39 door Ozzie PHP
Quote:
Je trekt allerlei "vreemde" conclusies die niet kloppen.
Mag ik als leerpuntje mogen weten welke conclusies niet kloppen?
Ja dat mag uiteraard. Je trekt conclusies op basis van dingen die niets met elkaar te maken hebben. Public, protected en private hebben niets te maken met het feit of bestanden binnen of buiten de webroot staan. Het geeft enkel aan hoe de methods en properties in een class (wel of niet) door andere classes benaderd kunnen worden. Dit heeft verder niets te maken met "de buitenwereld". Als je je bestanden buiten de webroot zet, kunnen hackers er niet bij (tenzij ze je server in weten te komen). Vanuit programmeer-oogpunt ga je vervolgens bepalen of je public, protected of private methods en properties gaat gebruiken, maar dit heeft dus niks te maken met veiligheid tegen hackers. Het heeft wel alles te maken met slim programmeren.
Gewijzigd op 20/01/2015 17:11:25 door Ozzie PHP
Ik zie nu niet zo snel waar ik die conclusie heb getrokken.
Een webrobot is totaal verschillend tussen een zoek of hack robot.
Misschien dat ik het onduidelijk neergezet heb ergens.
Public heeft er mee te maken dat het buiten de class als object toegankelijk is.
Protected en Private heeft ermee te maken dat het alleen binnen de class toegankelijk is.
Wanneer alle static properties zowel private, protected of public toegankelijk is, is de veiligheid weg.
En natuurlijk heeft het mede veiligheid tegen hackers te maken.
Wanneer ik op een andere server een stukje php neerzet en een andere class include is het niet de bedoeling dat die mijn static gegevens op kunnen halen.