+ +

+ Un des secteurs à la fois délicat et important lors d'un test + de site web reste la sécurité. Tester ces schémas est au coeur + des objectifs du testeur web de SimpleTest. +

+ +

Authentification HTTP basique

+ Si vous allez chercher une page web protégée + par une authentification basique, vous hériterez d'une entête 401. + Nous pouvons représenter ceci par ce test... +

+class AuthenticationTest extends WebTestCase {
+    function test401Header() {
+        $this->get('http://www.lastcraft.com/protected/');
+        $this->showHeaders();
+    }
+}
+

+ Ce qui nous permet de voir les entêtes reçues... +

File test

+HTTP/1.1 401 Authorization Required
+Date: Sat, 18 Sep 2004 19:25:18 GMT
+Server: Apache/1.3.29 (Unix) PHP/4.3.4
+WWW-Authenticate: Basic realm="SimpleTest basic authentication"
+Connection: close
+Content-Type: text/html; charset=iso-8859-1
+

1/1 test cases complete. + 0 passes, 0 fails and 0 exceptions.

+ Sauf que nous voulons éviter l'inspection visuelle, + on souhaite que SimpleTest puisse nous dire si oui ou non + la page est protégée. Voici un test en profondeur sur nos entêtes... +

+class AuthenticationTest extends WebTestCase {
+    function test401Header() {
+        $this->get('http://www.lastcraft.com/protected/');
+        $this->assertAuthentication('Basic');
+        $this->assertResponse(401);
+        $this->assertRealm('SimpleTest basic authentication');
+    }
+}
+

+ N'importe laquelle de ces assertions suffirait, + tout dépend de la masse de détails que vous souhaitez voir. +

+ La plupart du temps, nous ne souhaitons pas tester + l'authentification en elle-même, mais plutôt + les pages protégées par cette authentification. + Dès que la tentative d'authentification est reçue, + nous pouvons y répondre à l'aide d'une réponse d'authentification : +

+class AuthenticationTest extends WebTestCase {
+    function testAuthentication() {
+        $this->get('http://www.lastcraft.com/protected/');
+        $this->authenticate('Me', 'Secret');
+        $this->assertTitle(...);
+    }
+}
+

+ Le nom d'utilisateur et le mot de passe seront désormais + envoyés à chaque requête vers ce répertoire + et ses sous-répertoires. + En revanche vous devrez vous authentifier à nouveau + si vous sortez de ce répertoire mais SimpleTest est assez + intelligent pour fusionner les sous-répertoires dans un même domaine. +

+ Vous pouvez gagner une ligne en définissant + l'authentification au niveau de l'URL... +

+class AuthenticationTest extends WebTestCase {
+    function testCanReadAuthenticatedPages() {
+        $this->get('http://Me:Secret@www.lastcraft.com/protected/');
+        $this->assertTitle(...);
+    }
+}
+

+ Si votre nom d'utilisateur ou mot de passe comporte + des caractères spéciaux, alors n'oubliez pas de les encoder, + sinon la requête ne sera pas analysée correctement. + De plus cette entête ne sera pas envoyée aux + sous requêtes si vous la définissez avec une URL absolue. + Par contre si vous naviguez avec des URL relatives, + l'information d'authentification sera préservée. +

+ Pour l'instant, seule l'authentification de base est implémentée + et elle n'est réellement fiable qu'en tandem avec une connexion HTTPS. + C'est généralement suffisant pour protéger + le serveur testé des regards malveillants. + Les authentifications Digest et NTLM pourraient être ajoutées prochainement. +

+ +

Cookies

+ L'authentification de base ne donne pas assez de contrôle + au développeur Web sur l'interface utilisateur. + Il y a de forte chance pour que cette fonctionnalité + soit codée directement dans l'architecture web + à grand renfort de cookies et de timeouts compliqués. +

+ Commençons par un simple formulaire de connexion... +

+<form>
+    Username:
+    <input type="text" name="u" value="" /><br />
+    Password:
+    <input type="password" name="p" value="" /><br />
+    <input type="submit" value="Log in" />
+</form>
+

+ Lequel doit ressembler à... +

+ Supposons que, durant le chargement de la page, + un cookie ait été inscrit avec un numéro d'identifiant de session. + Nous n'allons pas encore remplir le formulaire, + juste tester que nous pistons bien l'utilisateur. + Voici le test... +

+class LogInTest extends WebTestCase {
+    function testSessionCookieSetBeforeForm() {
+        $this->get('http://www.my-site.com/login.php');
+        $this->assertCookie('SID');
+    }
+}
+

+ Nous nous contentons ici de vérifier que le cookie a bien été défini. + Etant donné que sa valeur est plutôt énigmatique, + elle ne vaut pas la peine d'être testée. +

+ Le reste du test est le même que dans n'importe quel autre formulaire, + mais nous pourrions souhaiter nous assurer + que le cookie n'a pas été modifié depuis la phase de connexion. + Voici comment cela pourrait être testé : +

+class LogInTest extends WebTestCase {
+    ...
+    function testSessionCookieSameAfterLogIn() {
+        $this->get('http://www.my-site.com/login.php');
+        $session = $this->getCookie('SID');
+        $this->setField('u', 'Me');
+        $this->setField('p', 'Secret');
+        $this->clickSubmit('Log in');
+        $this->assertWantedPattern('/Welcome Me/');
+        $this->assertCookie('SID', $session);
+    }
+}
+

+ Ceci confirme que l'identifiant de session + est identique avant et après la connexion. +

+ Nous pouvons même essayer de duper notre propre système + en créant un cookie arbitraire pour se connecter... +

+class LogInTest extends WebTestCase {
+    ...
+    function testSessionCookieSameAfterLogIn() {
+        $this->get('http://www.my-site.com/login.php');
+        $this->setCookie('SID', 'Some other session');
+        $this->get('http://www.my-site.com/restricted.php');
+        $this->assertWantedPattern('/Access denied/');
+    }
+}
+

+ Votre site est-il protégé contre ce type d'attaque ? +

+ +

Sessions de navigateur

+ Si vous testez un système d'authentification, + la reconnexion par un utilisateur est un point sensible. + Essayons de simuler ce qui se passe dans ce cas : +

+class LogInTest extends WebTestCase {
+    ...
+    function testLoseAuthenticationAfterBrowserClose() {
+        $this->get('http://www.my-site.com/login.php');
+        $this->setField('u', 'Me');
+        $this->setField('p', 'Secret');
+        $this->clickSubmit('Log in');
+        $this->assertWantedPattern('/Welcome Me/');
+        
+        $this->restart();
+        $this->get('http://www.my-site.com/restricted.php');
+        $this->assertWantedPattern('/Access denied/');
+    }
+}
+

+ La méthode WebTestCase::restart() préserve les cookies + dont le timeout a expiré, mais conserve les cookies temporaires ou expirés. + Vous pouvez spécifier l'heure et la date de leur réactivation. +

+ L'expiration des cookies peut être un problème. + Si vous avez un cookie qui doit expirer au bout d'une heure, + nous n'allons pas mettre le test en veille en attendant + que le cookie expire... +

+ Afin de provoquer leur expiration, + vous pouvez dater manuellement les cookies, + avant le début de la session. +

+class LogInTest extends WebTestCase {
+    ...
+    function testLoseAuthenticationAfterOneHour() {
+        $this->get('http://www.my-site.com/login.php');
+        $this->setField('u', 'Me');
+        $this->setField('p', 'Secret');
+        $this->clickSubmit('Log in');
+        $this->assertWantedPattern('/Welcome Me/');
+        
+        $this->ageCookies(3600);
+        $this->restart();
+        $this->get('http://www.my-site.com/restricted.php');
+        $this->assertWantedPattern('/Access denied/');
+    }
+}
+

+ Après le redémarrage, les cookies seront plus vieux + d'une heure et que tous ceux dont la date d'expiration + sera passée auront disparus. +

+ +

Documentation sur l'authentification

Authentification HTTP basique

File test

Cookies

Sessions de navigateur