une fonction avec instructions MySQL ?

[Jean Francois Ortolo]

Bonjour

C'est dans le but de modifier tout un site, pour sécuriser son mode
d'authentification de ses visiteurs authentifiés.

Désormais, la fonction certitifiant l'authentification, aurait pour
prototype : make_authen($password) , et la fonction vérifiant
l'authentification, aurait pour prototype : verif_authen()

Ces deux fonctions, serait incluses dans un script php nommé
authen.php , et ces deux fonctions, contienraient des instructions MySQL
sur une table MySQL nommée : authentification.

Ces deux fonctions, contiendraient donc chacune, la variable globale
$conn donnant la connexion en cours, à la Base de Données, et le
problème consiste à savoir, à quel endroit des scripts du site, inclure
le script authen.php contenant ces fonctions.

Il va de soi, qu'au moment où l'une de ces deux fonctions est
appelée, la connexion à la Base de Données ( alimentant la variable
$conn ) est toujours active.

Sacahnt celà, est-ce que je pourrais, inclure tout simplement ce
script authen.php, dans le script contenant les fonctions de connexion
et de déconnexion à la Base de Données, sachant que ce dernier script
est lui-même inclus dans chaque scripts du site à modifier, et
qu'effectivement, les connexions à la Base de Données, ne sont pas fait
dans ce dernier script, mais dans les scripts incluant ce dernier script ?

Par exemple, pourrais je avoir une architecture de ce type :


script connect_deconnect.php contenant les fonction connect() et
disconnect(), ainsi que les scripts inclus class_MyPDO.php et authen.php :

connect_deconnect.php
---------------------

-------------------------------------------------------
<?php

include("class_myPDO.php");

global $conn;

function connect()
{
// Instruction de connexion
// alimentant la variable
// globale $conn

}

function disconnect($conn)
{
unset($conn);
}

include("authen.php");

?>
-----------------------------------------------------------


authen.php
----------

-----------------------------------------------------------
<?php

global $conn;

function make_authen($password)
{
global $conn;

// Instructions MySQL
// utilisant la connexion
// à la Base de Données
// donnée par la variable $conn,
// ces instructions assurant
// l'authentification
// du visiteur ayant présenté
// le mot de passe $password

return(true);
}

function verif_authen()
{
global $conn;

// Instructions MySQL
// utilisant la connexion
// à la base de Données
// donnée par la variable $conn,
// cette fonction rend true
// si le visiteur est authentifié
// et false si non authentifié.

}
?>

-----------------------------------------------------


Maintenant, un exemple d'un script php utilisant les fonctions du
script authen.php , alors que la connexion à la Base de Données est active :

script example.php

<?php
session_start();

include("connect_deconnect.php");

global $conn;


$conn = connect();

if(!$conn)
{
// Message d'erreur

exit;
}

// On suppose, que le mot de passe $password
// associé au pseudo $pseudo , a été vérifié, donc
// on authentifie ce visiteur :
$_SESSION['pseudo'] = $pseudo;

if(!make_authen($password))
{
// Message d'erreur,
// visiteur non authentifié

unset($_SESSION['pseudo']);

disconnect($conn);

exit;
}

// Là, le visiteur est authentifié,


// Dans ce script ( mais celà peut être aussi bien dans un autre
script ),on vérifie si le visiteur est authentifié :

if(verif_authen())
{
// Traitement normal,
// le visiteur est authentifié.

}
else
{
// Traitement destiné
// à demander au visiteur
// de fournir un pseudo
// et un mot de passe valide,
// puis le traitement
// vérifie si le pseudo et le password
// sont corrects,
// puis dans ce script,
// déclenche de nouveau la fonction
// make_authen($password);
//
}

disconnect($conn);

// Suite du traitement éventuel.


exit;
?>
-------------------------------------------------


Donc, voici ma question :

A supposer, que la connexion à la Base de Données dans le(s)
script(s) appelant, précède toujours les appels aux fonctions
make_authen($password) et/ou verif_authen() , cette connexion
sera-t-elle valide à l'intérieur de ces deux fonctions, bien que ces
deux fonctions, sont déclarées avant l'instruction de connexion ( $conn
= connect(); ) ?

En effet, pour plius de rapidité, je souhaite pouvoir inclure le
script authen.php , tout bonnement dans le script connect_deconnect.php
, ce qui ne fait qu'une seule inclusion pour tous les scripts du site,
puisque le script connect_deconnect.php, est inclus partout où il y a
besoin d'une connexion MySQL.

La variable $cconn étant globale partout, cette architecture de
script est-elle valable ou non ?

Je reconnais que c'est une question très basique en php, mais
j'aimerais bien être sûr avant de commencer à faire ces modifications.

Merci beaucoup de vos réponses.

Bien amicalement.

Jean François Ortolo

[Pascal Poncet]

Le 15/01/2012 16:17, Jean Francois Ortolo a écrit :
>
> Bonjour

Bonjour,

> C'est dans le but de modifier tout un site, pour sécuriser son mode
> d'authentification de ses visiteurs authentifiés.

[...etc...etc...etc...] ouf !!!

Désolé pour la critique ouverte, mais il serait bon de faire preuve d'un
minimum d'esprit de synthèse dans l'exposé.

A part ça, il y a plusieurs principes d'authentification, selon la
complexité des processus de contrôle d'accès (sécurité, rôles, etc.).

Un schéma classique et basique serait le suivant :

Fichier "index.php"
===================
<?php
session_start();
$authenticated = require 'auth.php'; // authentification
if ($authenticated) {
// traitement si authentifié
if (! empty($_REQUEST['logout']) {
session_destroy();
// traitement particulier si déconnecté
}
} else {
// traitement si non authentifié
}
?>

Fichier "auth.php"
==================
<?php
require_once 'db.php'; // connexion SGBDR
function is_auth($login) {
// passage des données de login à une requête SQL
// renvoie les données d'utilisateur ou FALSE
}
$authenticated = FALSE; // <--- important !!!
if (! empty($_SESSION['user'])) {
$user = $_SESSION['user'];
$authenticated = TRUE;
// éventuellement, vérifier l'usurpation de session
} elseif (! empty($_REQUEST['login'])) {
$user = is_auth($_REQUEST['login']);
if ($user) {
$_SESSION['user'] = $user;
$authenticated = TRUE;
} else {
// éventuellement, restreindre les tentatives
}
}
return $authenticated;
?>



--
Cordialement,
Pascal

[Jean Francois Ortolo]

Bonsoir Monsieur

Votre procédé d'authentification, est certifié par des cookies en
clair, et il suffirait à un autre visiteur, de simuler le cookie de
session et d'écrire les autres cookies, pour être authentifié.

Sans compter que, les cookies étant en clair, il suffirait de lire
les cookies dans un visiteur connecté, pour avoir ses données
d'authentification.


Vous comprenez bien, que le problème, pour moi, n'est pas de savoir
comment authentifier un visiteur.

Le problème, est de modifier de la manière la plus rapide possible,
un site entier, devant comportant des authentifications dans un script,
et des vérifications d'authentification dans un grand nombre de scripts.

Pour celà, je cherche, à quel endroit inclure le script contenant ces
deux fonctions ( certifications d'authentification, et vérification
d'authentification ), sachant que ces deux fonctions, nécessitent des
accès en cours valides, à la base de données.

Ceci, compte tenu que les connexions à la base de données, précèdent
dans ce grand nombre de scripts, les appels à ces fonctions, mais
suivent ( de loin ), les déclarations de ces fonctions.

Et aussi, que le script contenant les deux fonctions connect() et
disconnect($conn) de connexion et déconnexion, est inclus dans tous ces
nombreux scripts.

Le problème, consiste uniquement à savoir si je peux inclure le
script contenant ces deux fonctions d'authentification, à la fin du
script contenant les focntions connect() et disconnect($conn), compte
tenu de ce qui précède.

Ce que vous me proposez, irait contre la simplification que j'espère
appliquer, dans la modification de ce site.

Ma question est une pure question php, portant probablement sur la
portée des variables globales, ou le fait de savoir si leurs
modifications sont propagées entre des scripts inclus les uns dans les
autres, sachant que les fonctions d'authentification, seraient donc
déclarées, avant les connexions effectives à la base de données.

Cependant, bien que déclarées avant les connexions à la base de
données, elle seraient exécutées après ces connexions.

Je reconnais que mon premier exposé paraissait un peu abscons et
touffu. J'espère que mon laïus actuel est plus clair.

[Pascal Poncet]

Le 15/01/2012 18:28, Jean Francois Ortolo a écrit :

> Votre procédé d'authentification, est certifié par des cookies en
> clair, et il suffirait à un autre visiteur, de simuler le cookie de
> session et d'écrire les autres cookies, pour être authentifié.

Il n'était pas précisé que l'on passait par un tunnel sécurisé, genre
SSL, ou alors j'ai mal lu.

> Sans compter que, les cookies étant en clair, il suffirait de lire les
> cookies dans un visiteur connecté, pour avoir ses données
> d'authentification.

C'est le cas de l'usurpation de session, que j'ai mentionné en
commentaire dans le code comme une éventualité de traitement.

> Ma question est une pure question php, portant probablement sur la
> portée des variables globales, ou le fait de savoir si leurs
> modifications sont propagées entre des scripts inclus les uns dans les
> autres, sachant que les fonctions d'authentification, seraient donc
> déclarées, avant les connexions effectives à la base de données.
>
> Cependant, bien que déclarées avant les connexions à la base de
> données, elle seraient exécutées après ces connexions.

Nous voilà enfin dans le vif du sujet !

Depuis je ne sais quelle version, mais ça date suffisamment, les
fonctions utilisateur peuvent être déclarées après leur utilisation
(voir "http://php.net/manual/fr/functions.user-defined.php").

De même, les constantes et variables utilisateur sont héritées avec
toute forme d'inclusion de fichier (voir
"http://fr.php.net/manual/fr/function.include.php").

Dans votre cas, si j'ai bien tout compris, la seule chose à vérifier est
que les fichiers de connexion ne comprennent que la définition des
fonctions SGBDR et non pas leur appel, celui-ci étant déporté dans vos
scripts.


--
Cordialement,
Pascal

[Jean Francois Ortolo]

Le 15/01/2012 19:34, Pascal Poncet a écrit :
>
> Nous voilà enfin dans le vif du sujet !
>
> Depuis je ne sais quelle version, mais ça date suffisamment, les
> fonctions utilisateur peuvent être déclarées après leur utilisation
> (voir "http://php.net/manual/fr/functions.user-defined.php").
>
> De même, les constantes et variables utilisateur sont héritées avec
> toute forme d'inclusion de fichier (voir
> "http://fr.php.net/manual/fr/function.include.php").
>
> Dans votre cas, si j'ai bien tout compris, la seule chose à vérifier est
> que les fichiers de connexion ne comprennent que la définition des
> fonctions SGBDR et non pas leur appel, celui-ci étant déporté dans vos
> scripts.
>
>

Bonsoir Monsieur

Merci beaucoup de votre avis.

J'ai reçu confirmation sur le forum du site www.webrankinfo.com , que
je pouvais tout simplement, insérer le code des deux fonctions
d'authentification , dans le script contenant les fonctions de connexion
et de déconnexion de la base de données.

Normalement, ces modifications devraient être assez rapides, bien
qu'il existe actuellement deux versions du site : Une version Posix (
fonctions type ereg ) et fonctions MySQL anciennes de type mysql_*() ,
et une version PCRE ( fonctions type preg_*() ), avec des fonctions
MySQL objet de type PDO.

Je viens d'aspirer tout les scripts du site sur mon ordinateur, j'ai
déjà la version nouvelle du script comportant les fonctions de connexion
et déconnexion, avec les deux fonctions d'authentification intégrées, je
vais adapter ces deux fonctions à l'ancienne version, pour l'ancienne
version du script comportant les fonctions de connexion et déconnexion. ;)

Je suis obligé de tout faire en pouvant modifier le site très
rapidement en transférant tous les scripts modifiés en une seule passe
ftp, puis vérifier que çà marche bien, sinon je rétablirai immédiatement
l'ancien mode d'authentification.

Heureusement, il n'y a rien de changé pour les visiteurs connectés,
qui veulent se déconnecter.

Merci encore pour votre aimable aide.