<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Documentation Simple Test : tester l'authentification</title>
<link rel="stylesheet" type="text/css" href="docs.css" title="Styles">
</head>
<body>
<div class="menu_back">
<div class="menu">
<h2>
<a href="index.html">SimpleTest</a>
</h2>
<ul>
<li>
<a href="overview.html">Overview</a>
</li>
<li>
<a href="unit_test_documentation.html">Unit tester</a>
</li>
<li>
<a href="group_test_documentation.html">Group tests</a>
</li>
<li>
<a href="server_stubs_documentation.html">Server stubs</a>
</li>
<li>
<a href="mock_objects_documentation.html">Mock objects</a>
</li>
<li>
<a href="partial_mocks_documentation.html">Partial mocks</a>
</li>
<li>
<a href="reporter_documentation.html">Reporting</a>
</li>
<li>
<a href="expectation_documentation.html">Expectations</a>
</li>
<li>
<a href="web_tester_documentation.html">Web tester</a>
</li>
<li>
<a href="form_testing_documentation.html">Testing forms</a>
</li>
<li>
<a href="authentication_documentation.html">Authentication</a>
</li>
<li>
<a href="browser_documentation.html">Scriptable browser</a>
</li>
</ul>
</div>
</div>
<h1>Documentation sur l'authentification</h1>
<div class="content">
        
            <p>
                Un des secteurs &agrave; la fois d&eacute;licat et important lors d'un test de site web reste la s&eacute;curit&eacute;. Tester ces sch&eacute;mas est au coeur des objectifs du testeur web de SimpleTest.
            </p>
        
        <p>
<a class="target" name="basique">
<h2>Authentification HTTP basique</h2>
</a>
</p>
            <p>
                Si vous allez chercher une page web prot&eacute;g&eacute;e par une authentification basique, vous h&eacute;riterez d'une ent&ecirc;te 401. Nous pouvons repr&eacute;senter ceci par ce test...
<pre>
class AuthenticationTest extends WebTestCase {<strong>
    function test401Header() {
        $this-&gt;get('http://www.lastcraft.com/protected/');
        $this-&gt;showHeaders();
    }</strong>
}
</pre>
                Ce qui nous permet de voir les ent&ecirc;tes re&ccedil;ues...
                <div class="demo">
                    <h1>File test</h1>
<pre style="background-color: lightgray; color: black">
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
</pre>
                    <div style="padding: 8px; margin-top: 1em; background-color: green; color: white;">1/1 test cases complete.
                    <strong>0</strong> passes, <strong>0</strong> fails and <strong>0</strong> exceptions.</div>
                </div>
                Sauf que nous voulons &eacute;viter l'inspection visuelle, on souhaite que SimpleTest puisse nous dire si oui ou non la page est prot&eacute;g&eacute;e. Voici un test en profondeur sur nos ent&ecirc;tes...
<pre>
class AuthenticationTest extends WebTestCase {
    function test401Header() {
        $this-&gt;get('http://www.lastcraft.com/protected/');<strong>
        $this-&gt;assertAuthentication('Basic');
        $this-&gt;assertResponse(401);
        $this-&gt;assertRealm('SimpleTest basic authentication');</strong>
    }
}
</pre>
                N'importe laquelle de ces assertions suffirait, tout d&eacute;pend de la masse de d&eacute;tails que vous souhaitez voir.
            </p>
            <p>
                La plupart du temps, nous ne souhaitons pas tester l'authentification en elle-m&ecirc;me, mais plut&ocirc;t les pages prot&eacute;g&eacute;es par cette authentification. D&egrave;s que la tentative d'authentification est re&ccedil;ue, nous pouvons y r&eacute;pondre &agrave; l'aide d'une r&eacute;ponse d'authentification :
<pre>
class AuthenticationTest extends WebTestCase {
    function testAuthentication() {
        $this-&gt;get('http://www.lastcraft.com/protected/');<strong>
        $this-&gt;authenticate('Me', 'Secret');</strong>
        $this-&gt;assertTitle(...);
    }
}
</pre>
                Le nom d'utilisateur et le mot de passe seront d&eacute;sormais envoy&eacute;s &agrave; chaque requ&ecirc;te vers ce r&eacute;pertoire et ses sous r&eacute;pertoires. En revanche vous devrez vous authentifier &agrave; nouveau si vous sortez de ce r&eacute;pertoire.
            </p>
            <p>
                Vous pouvez gagner une ligne en d&eacute;finissant l'authentification au niveau de l'URL...
<pre>
class AuthenticationTest extends WebTestCase {
    function testCanReadAuthenticatedPages() {
        $this-&gt;get('http://<strong>Me:Secret@</strong>www.lastcraft.com/protected/');
        $this-&gt;assertTitle(...);
    }
}
</pre>
                Si votre nom d'utilisateur ou mot de passe comporte des caract&egrave;res sp&eacute;ciaux, alors n'oubliez pas de les encoder, sinon la requ&ecirc;te ne sera pas analys&eacute;e correctement. De plus cette ent&ecirc;te ne sera pas envoy&eacute;e aux sous requ&ecirc;tes si vous la d&eacute;finissez avec une URL absolue. Par contre si vous naviguez avec des URL relatives, l'information d'authentification sera pr&eacute;serv&eacute;e.
            </p>
            <p>
                 Pour l'instant, seule l'authentification de base est impl&eacute;ment&eacute;e et elle n'est r&eacute;ellement fiable qu'en tandem avec une connexion HTTPS. C'est g&eacute;n&eacute;ralement suffisant pour prot&eacute;ger le serveur test&eacute; des regards malveillants. Les authentifications Digest et NTLM pourraient &ecirc;tre ajout&eacute;es prochainement.
            </p>
        
        <p>
<a class="target" name="cookies">
<h2>Cookies</h2>
</a>
</p>
            <p>
                L'authentification de base ne donne pas assez de contr&ocirc;le au d&eacute;veloppeur Web sur l'interface utilisateur. Il y a de forte chance pour que cette fonctionnalit&eacute; soit cod&eacute;e directement dans l'architecture web &agrave; grand renfort de cookies et de timeouts compliqu&eacute;s.
            </p>
            <p>
                Commen&ccedil;ons par un simple formulaire de connexion...
<pre>
&lt;form&gt;
    Username:
    &lt;input type="text" name="u" value="" /&gt;&lt;br /&gt;
    Password:
    &lt;input type="password" name="p" value="" /&gt;&lt;br /&gt;
    &lt;input type="submit" value="Log in" /&gt;
&lt;/form&gt;
</pre>
                Lequel doit ressembler &agrave;...
            </p>
            <p>
                <form class="demo">
                    Username:
                    <input type="text" name="u" value="">
<br>
                    Password:
                    <input type="password" name="p" value="">
<br>
                    <input type="submit" value="Log in">
                </form>
            </p>
            <p>
                Supposons que, durant le chargement de la page, un cookie ait &eacute;t&eacute; inscrit avec un num&eacute;ro d'identifiant de session. Nous n'allons pas encore remplir le formulaire, juste tester que nous pistons bien l'utilisateur. Voici le test...
<pre>
class LogInTest extends WebTestCase {
    function testSessionCookieSetBeforeForm() {
        $this-&gt;get('http://www.my-site.com/login.php');<strong>
        $this-&gt;assertCookie('SID');</strong>
    }
}
</pre>
                Nous nous contentons ici de v&eacute;rifier que le cookie a bien &eacute;t&eacute; d&eacute;fini. Etant donn&eacute; que sa valeur est plut&ocirc;t &eacute;nigmatique, elle ne vaut pas la peine d'&ecirc;tre test&eacute;e.
            </p>
            <p>
                Le reste du test est le m&ecirc;me que dans n'importe quel autre formulaire, mais nous pourrions souhaiter nous assurer que le cookie n'a pas &eacute;t&eacute; modifi&eacute; depuis la phase de connexion. Voici comment cela pourrait &ecirc;tre test&eacute; :
<pre>
class LogInTest extends WebTestCase {
    ...
    function testSessionCookieSameAfterLogIn() {
        $this-&gt;get('http://www.my-site.com/login.php');<strong>
        $session = $this-&gt;getCookie('SID');
        $this-&gt;setField('u', 'Me');
        $this-&gt;setField('p', 'Secret');
        $this-&gt;clickSubmit('Log in');
        $this-&gt;assertWantedPattern('/Welcome Me/');
        $this-&gt;assertCookie('SID', $session);</strong>
    }
}
</pre>
                Ceci confirme que l'identifiant de session est identique avant et apr&egrave;s la connexion.
            </p>
            <p>
                Nous pouvons m&ecirc;me essayer de duper notre propre syst&egrave;me en cr&eacute;ant un cookie arbitraire pour se connecter...
<pre>
class LogInTest extends WebTestCase {
    ...
    function testSessionCookieSameAfterLogIn() {
        $this-&gt;get('http://www.my-site.com/login.php');<strong>
        $this-&gt;setCookie('SID', 'Some other session');
        $this-&gt;get('http://www.my-site.com/restricted.php');</strong>
        $this-&gt;assertWantedPattern('/Access denied/');
    }
}
</pre>
                Votre site est-il prot&eacute;g&eacute; contre ce type d'attaque ?
            </p>
        
        <p>
<a class="target" name="session">
<h2>Sessions de navigateur</h2>
</a>
</p>
            <p>
                Si vous testez un syst&egrave;me d'authentification, la reconnexion par un utilisateur est un point sensible. Essayons de simuler ce qui se passe dans ce cas :
<pre>
class LogInTest extends WebTestCase {
    ...
    function testLoseAuthenticationAfterBrowserClose() {
        $this-&gt;get('http://www.my-site.com/login.php');
        $this-&gt;setField('u', 'Me');
        $this-&gt;setField('p', 'Secret');
        $this-&gt;clickSubmit('Log in');
        $this-&gt;assertWantedPattern('/Welcome Me/');<strong>
        
        $this-&gt;restart();
        $this-&gt;get('http://www.my-site.com/restricted.php');
        $this-&gt;assertWantedPattern('/Access denied/');</strong>
    }
}
</pre>
                La m&eacute;thode <span class="new_code">WebTestCase::restart()</span> pr&eacute;serve les cookies dont le timeout a expir&eacute;, mais conserve les cookies temporaires ou expir&eacute;s. Vous pouvez sp&eacute;cifier l'heure et la date de leur r&eacute;activation.
            </p>
            <p>
                L'expiration des cookies peut &ecirc;tre un probl&egrave;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...
            </p>
            <p>
                Afin de provoquer leur expiration, vous pouvez dater manuellement les cookies, avant le d&eacute;but de la session.
<pre>
class LogInTest extends WebTestCase {
    ...
    function testLoseAuthenticationAfterOneHour() {
        $this-&gt;get('http://www.my-site.com/login.php');
        $this-&gt;setField('u', 'Me');
        $this-&gt;setField('p', 'Secret');
        $this-&gt;clickSubmit('Log in');
        $this-&gt;assertWantedPattern('/Welcome Me/');
        <strong>
        $this-&gt;ageCookies(3600);</strong>
        $this-&gt;restart();
        $this-&gt;get('http://www.my-site.com/restricted.php');
        $this-&gt;assertWantedPattern('/Access denied/');
    }
}
</pre>
                Apr&egrave;s le red&eacute;marrage, les cookies seront plus vieux d'une heure et que tous ceux dont la date d'expiration sera pass&eacute;e auront disparus.
            </p>
        
    </div>
<div class="copyright">
            Copyright<br>Marcus Baker, Jason Sweat, Perrick Penet 2004
        </div>
</body>
</html>