| | function realip() {
if (isSet($_SERVER)) {
if (isSet($_SERVER["HTTP_X_FORWARDED_FOR"])) {
$realip = $_SERVER["HTTP_X_FORWARDED_FOR"];
} elseif (isSet($_SERVER["HTTP_CLIENT_IP"])) {
$realip = $_SERVER["HTTP_CLIENT_IP"];
} else {
$realip = $_SERVER["REMOTE_ADDR"];
}
} else {
if ( getenv( 'HTTP_X_FORWARDED_FOR' ) ) {
$realip = getenv( 'HTTP_X_FORWARDED_FOR' );
} elseif ( getenv( 'HTTP_CLIENT_IP' ) ) {
$realip = getenv( 'HTTP_CLIENT_IP' );
} else {
$realip = getenv( 'REMOTE_ADDR' );
}
}
return $realip;
}
|
|
Auteur : Sub0
| | Version : 16/01/2006 | | |
| |
Le login est définit dans le script. Le fichier .htaccess permet d'utiliser la variable $_SERVER['REMOTE_USER'] pour mémoriser la saisie durant toute la session.
En effet, lorsque PHP est éxécuté en mode CGI, les variables 'PHP_AUTH_USER' et 'PHP_AUTH_PW' seront toujours vides.
Voici donc la solution :
<?php
$cfg['adm_login'] = 'admin';
$cfg['adm_pass'] = 'pass';
if((!isset($_SERVER['PHP_AUTH_USER']) ||
!isset($_SERVER['PHP_AUTH_PW'])) &&
preg_match('/Basic\s+(.*)$/i',$_SERVER['REMOTE_USER'],$matches)){
list($name,$pass)=explode(':',base64_decode($matches[1]));
$_SERVER['PHP_AUTH_USER']=strip_tags($name);
$_SERVER['PHP_AUTH_PW']=strip_tags($pass);
}
if($_SERVER['PHP_AUTH_USER']!=$cfg['adm_login'] ||
$_SERVER['PHP_AUTH_PW']!=$cfg['adm_pass']){
header('WWW-Authenticate: Basic realm="Connexion..."');
header('HTTP/1.0 401 Unauthorized');
die('Erreur : Identification incorrecte !');
}
echo 'Authentification acceptée.';
?>
|
| Le .htaccess | <IfModule mod_rewrite.c>
RewriteEngine on
RewriteRule .* - [E=REMOTE_USER:%{HTTP:Authorization},L]
</IfModule>
|
|
| |
Avant tout, il faut vérifier que le fichier php.ini contienne bien :
extension=ldap.so
<?php
if($saisieEffectuer) {
$ds=ldap_connect("W.X.Y.Z");
if ($ds) {
if (ldap_bind($ds)) {
$dn = "uid=$login , dc=MaSociete, dc=fr";
$value = "{MD5}".base64_encode( pack( 'H*' , md5($pass) ) );
$attr = "userpassword";
$r=ldap_compare($ds, $dn, $attr, $value);
if ($r === -1) {
echo "Erreur : ".ldap_error($ds);
} elseif ($r === TRUE) {
echo "Mot de passe correct.";
} elseif ($r === FALSE) {
echo "Mot de passe incorrect : ".$value;
}
} else {
echo "Impossible de se connecter au serveur LDAP.";
}
ldap_close($ds);
} else {
echo "Impossible de se connecter au serveur LDAP.";
}
}
?>
<html>
<head>
<title>Authentification</title>
</head>
<body>
<br>
<script language="Javascript">
function verifierSaisie() {
if(document.authentification.login.value=="") {
alert("Login non saisi.");
}
else {
if(document.authentification.pass.value=="") {
alert("Pass non saisi");
}
else {
document.authentification.cours.value="en cours...";
document.authentification.submit();
}
}
}
</script>
<div align="center">
<form name="authentification" action="<?php $PHP_SELF ?>" method="post">
<table width="90%" border="0" cellspacing="0" >
<tr>
<td colspan="2" align="center"><b><font size="+1">Authentification</font></b></td>
</tr>
<tr>
<td>Login :</td>
<td><input style="border-style:solid" type="text" name="login" size="16" maxlength="30"></td>
</tr>
<tr>
<td>Pass :</td>
<td><input style="border-style:solid" type="password" name="pass" size="16" maxlength="30"></td>
</tr>
<tr>
<td colspan="2" align="center"><input type="hidden" value="true" name="saisieEffectuer">
<input type="button" value="Annuler" onclick="window.close()">
<input type="button" OnClick="verifierSaisie()" value="Ok"></td>
</tr>
</table>
<input type='text' style='border:none; ' name='cours' value='' size=11 >
</form>
</div>
</body>
</html>
|
|
Auteur : Galak`
| | Version : 17/01/2006 | | |
| |
Ce script permet de faire l'interface entre toutes vos taches cron php et toutes les facons possibles de les exécuter.
Chacune de vos taches sera placée dans un fichier php qui sera inclu par le script ci-dessous
(vous pouvez donc placer les includes et connexion à la base dans ce fichier pour ne pas avoir à les mettre dans
vos scripts de taches cron), toutes vos taches (donc tous vos scripts) devant se retrouver dans un même dossier.
Vous pourrez exécuter vos taches, par l'intermédiaire de ce script, aussi bien en ligne de commande (PHP CGI ou CLI)
que par un simple appel dans votre navigateur (pour débug, paliatif en cas d'indisponibilité de cron ou pour webcron.org).
Lors de l'appel par le navigateur, vous pouvez passer en paramêtre
- Une fréquence de rafraichissement pour exécuter la tache toutes les X secondes, ainsi qu'un nombre de rafraichissement
optionnel dans le cas ou elle ne doit pas s'exécuter indéfiniment
- Un temps d'attente avant de lancer la tache pour pouvoir par exemple exécuter 2 fois la même tache à la même heure en décalant
la 2e pour qu'elle laisse le temps à la première de finir (utile pour webcron.org qui ne permet d'exécuter les taches que toutes les heures)
- Un paramêtre pour exécuter la tache en arrière plan. Dans ce cas le navigateur n'attend pas que la tache se termine
(le mail envoyé permettant de savoir comment s'est déroulée la tache).
- ne pas planter la tache si on ferme le navigateur
- ne pas laisser le navigateur mouliner pour rien
- avoir une fréquence d'exécution plus précise (le navigateur rafraichissant la page au bout de X seconde APRES le chargement
de la page, donc apres l'exécution de la tache quand elle n'est pas exécutée en arrière plan, ce qui décale le rafraichissement)
-
ne pas interrompre les rafraichissements quand la tache ne se termine pas (timeout par exemple)
36001
<br />
define('CRONS_PATH','crons/modules/');
chdir('/home/www');
if ($_GET['file'])
{
$cmode='http';
$cr="<br />";
$file=$_GET['file'];
$refresh=$_GET['refresh'];
$nbrefresh=$_GET['nbrefresh'];
$background=$_GET['bg'];
$param1=$_GET['p1'];
$param2=$_GET['p2'];
$sleep=$_GET['sleep'];
if ($sleep > 60) $sleep=60;
if ($sleep) sleep($sleep);
$head='<html><head>';
if ($refresh and $nbrefresh != 1)
{
$nbrefresh--;
$head.='<meta http-equiv="refresh" content="'.$refresh.';URL='.preg_replace('/nbrefresh=([0-9]+)/ie',
"'nbrefresh=$nbrefresh'",$_SERVER['REQUEST_URI']).'">';
}
$head.='</head><body>';
$foot='</body></html>';
}
else
{
$cmode='cgi';
$cr="\n";
$file=$argv[1];
$param1=$argv[2];
$param2=$argv[3];
$background=$refresh=$nbrefresh=$sleep='';
$foot='';
}
if (!$file) echo 'Vous devez préciser le fichier à exécuter.';
elseif (!is_file(CRONS_PATH.$file.'.php')) echo 'Le fichier "'.$file.'.php" demandé n\'existe pas.';
else
{
if ($cmode == 'http')
{
// Si la tache est appelée en http et qu'il est demandé à ce qu'elle soit exécutée en arriere plan...
if ($background)
{
header("HTTP/1.1 200 OK"); // On envoi l'header OK
header("Content-Length: 256");
echo str_pad($head.date("d/m à H:i:s").' - La tache va s\'exécuter en arrière plan. Vous recevrez un mail
lorsqu\'elle sera terminée.</body></html>', 256);
flush(); // On vide le buffer de sortie
}
else echo $head;
ob_start(); // On démarre la bufferisation pour pouvoir récupérer le contenu de la page et l'envoyer par mail
}
Vos include ici
Connexion à mysql et sélection de la base si vos crons les utilisent
echo 'Tache exécutée le '.date("d/m à H:i:s").'.'.$cr.$cr;
$timestart=getmicrotime();
$nbquery=0;
$txt1=$txt2='';
include CRONS_PATH.$file.'.php';
$time=round(getmicrotime() - $timestart,2);
echo $cr.'Tache exécutée en '.$time.' secs'.$txt1.' avec '.$nbquery.' requêtes'.$txt2.'.';
@mysql_close($dblink);
if ($cmode == 'http')
{
mail('example@example.com', 'Cron : '.$_SERVER['REQUEST_URI'],str_replace('<br />',
"\n",ob_get_contents()),"From: cron@domain.tld\nReply-To: cron@domain.tld");
ob_end_flush();
}
}
echo $foot;
?>
|
La fonction getmicrotime utilisée ci-dessus (issue de la doc PHP de la fonction microtime()) :
function getmicrotime()
{
list($usec,$sec)=explode(' ',microtime());
return ((float)$usec + (float)$sec);
}
|
|
Auteur : Kioob
| | Version : 27/07/2006 | | |
| | Donc, voici une petite classe qui "limite" les possibilités de vol de session.
J'utilise cette classe au sein d'un framework, et ait donc été obligé d'enlever pas mal de trucs afin de la rendre portable, j'espère que je n'en ai pas trop enlevé.
Deux mécanismes sont utilisés :
- Vérification de la durée de la session.
- Controle d'un ID transmis en même temps que l'ID de session, mais qui change à chaque hit. Pour les accès concurrents, un timeout de 10 secondes est utilisé.
Dans cette version l'ID est changé au moment du "session_close()". Et il faut qu'il soit appelé avant que du contenu soit envoyé. Cela ne devrait pas poser de problème sur un site "bien construit".
La classe est à utilisée comme singleton (pas de double instanciation).
Je ne vais pas trop détailler le code, qui n'est d'ailleurs que très peu commenté...Aucun support ne sera assuré.
Mode d'emploi : | Ouverture de la session | $session = new k_session();
$session->enabled();
|
puis <?php
class k_session
{
var $is_new = true;
var $enabled = false;
var $concurrency_timeout = 10 ;
var $history_trigger_nb = 5 ;
var $history_expire = 60 ;
function k_session()
{
if( !empty( $_COOKIE[ session_name() ] ) )
{
$this->start();
}
}
function start()
{
if( $this->enabled === true ) return;
$this->enabled = true;
$random_id = @ $_COOKIE[ 'K_SID' ];
$start_time = time();
session_start();
$valid = true;
if( $valid and isset( $_SESSION['_k_time'] ) )
{
if( $_SESSION['_k_time'] + ini_get( 'session.gc_maxlifetime' ) < time() )
{
$valid = false;
}
}
if( $valid and isset( $_SESSION[ '_k_random_id' ] ) )
{
if( $random_id === $_SESSION[ '_k_random_id' ][ 'current' ] )
{
}
elseif( $time = @ $_SESSION[ '_k_random_id' ][ 'old' ][ $random_id ] )
{
if( $time < $start_time )
{
$valid = false;
}
}
else
{
$valid = false;
}
if( count( $_SESSION[ '_k_random_id' ][ 'old' ] ) >= $this->history_trigger_nb )
{
foreach( $_SESSION[ '_k_random_id' ][ 'old' ] as $idx => $time )
{
if( $time + $this->history_expire < $start_time )
{
unset( $_SESSION[ '_k_random_id' ][ 'old' ][ $idx ] );
}
}
}
}
if( ! $valid )
{
$_COOKIE[ 'K_SID' ] = NULL;
$_SESSION = array();
session_destroy();
session_id( md5( uniqid( mt_rand(), true ) ) );
session_start();
}
$this->is_new = ( count( $_SESSION ) > 0 );
$_SESSION['_k_time'] = time();
}
function destroy()
{
if( $this->enabled !== true ) return;
$this->enabled = false;
session_destroy();
setcookie( 'K_SID', NULL, NULL, '/', ini_get( 'session.cookie_domain' ) );
setcookie( session_name(), '', NULL, '/', ini_get( 'session.cookie_domain' ) );
}
function change_id()
{
if( $this->enabled !== true ) return;
static $already_done = false;
if( $already_done !== false ) return;
$already_done = true;
if( ! isset( $_SESSION[ '_k_random_id' ] ) )
$_SESSION[ '_k_random_id' ] = array( 'current' => NULL, 'old' => array() );
$old_id = $_SESSION[ '_k_random_id' ][ 'current' ];
if( $old_id !== NULL )
{
$_SESSION[ '_k_random_id' ][ 'old' ][ $old_id ] = time() + $this->concurrency_timeout ;
}
$new_id = md5( uniqid( mt_rand(), true ) );
$_SESSION[ '_k_random_id' ][ 'current' ] = $new_id;
setcookie( 'K_SID', $new_id, NULL, '/', ini_get( 'session.cookie_domain' ) );
}
function close()
{
if( $this->enabled !== true ) return;
$this->enabled = false;
$this->change_id();
session_write_close();
}
}
?>
|
|
| | Ce code permet de protéger l'accès à une page.
Pour l'essayer :
- Lancer la page sur le serveur
- Saisissez les informations telles que le login et le mot de passe
- Cliquer sur OK
Pour changer le login et le mot de passe, regarder dans le code, tout y est expliqué.
|
Consultez les autres pages sources
 
|
|
