be229cf3b320b1141370284ac1431c07eb6b3e2e
[toast/cookiecaptcha.git] / ConfirmEdit.php
1 <?php
2
3 /**
4  * Experimental captcha plugin framework.
5  * Not intended as a real production captcha system; derived classes
6  * can extend the base to produce their fancy images in place of the
7  * text-based test output here.
8  *
9  * Copyright (C) 2005, 2006 Brion Vibber <brion@pobox.com>
10  * http://www.mediawiki.org/
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License along
23  * with this program; if not, write to the Free Software Foundation, Inc.,
24  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25  * http://www.gnu.org/copyleft/gpl.html
26  *
27  * @addtogroup Extensions
28  */
29
30 if ( defined( 'MEDIAWIKI' ) ) {
31
32 global $wgExtensionFunctions, $wgGroupPermissions;
33
34 $wgExtensionFunctions[] = 'ceSetup';
35 $wgExtensionCredits['other'][] = array(
36         'name' => 'ConfirmEdit',
37         'author' => 'Brion Vibber',
38         'url' => 'http://www.mediawiki.org/wiki/Extension:ConfirmEdit',
39         'description' => 'Simple captcha implementation',
40 );
41
42 # Internationalisation file
43 require_once( 'ConfirmEdit.i18n.php' );
44
45 /**
46  * The 'skipcaptcha' permission key can be given out to
47  * let known-good users perform triggering actions without
48  * having to go through the captcha.
49  *
50  * By default, sysops and registered bot accounts will be
51  * able to skip, while others have to go through it.
52  */
53 $wgGroupPermissions['*'            ]['skipcaptcha'] = false;
54 $wgGroupPermissions['user'         ]['skipcaptcha'] = false;
55 $wgGroupPermissions['autoconfirmed']['skipcaptcha'] = false;
56 $wgGroupPermissions['bot'          ]['skipcaptcha'] = true; // registered bots
57 $wgGroupPermissions['sysop'        ]['skipcaptcha'] = true;
58
59 global $wgCaptcha, $wgCaptchaClass, $wgCaptchaTriggers;
60 $wgCaptcha = null;
61 $wgCaptchaClass = 'SimpleCaptcha';
62
63 /**
64  * Actions which can trigger a captcha
65  *
66  * If the 'edit' trigger is on, *every* edit will trigger the captcha.
67  * This may be useful for protecting against vandalbot attacks.
68  *
69  * If using the default 'addurl' trigger, the captcha will trigger on
70  * edits that include URLs that aren't in the current version of the page.
71  * This should catch automated linkspammers without annoying people when
72  * they make more typical edits.
73  *
74  * The captcha code should not use $wgCaptchaTriggers, but CaptchaTriggers()
75  * which also takes into account per namespace triggering.
76  */
77 $wgCaptchaTriggers = array();
78 $wgCaptchaTriggers['edit']          = false; // Would check on every edit
79 $wgCaptchaTriggers['create']            = false; // Check on page creation.
80 $wgCaptchaTriggers['addurl']        = true;  // Check on edits that add URLs
81 $wgCaptchaTriggers['createaccount'] = true;  // Special:Userlogin&type=signup
82
83 /**
84  * You may wish to apply special rules for captcha triggering on some namespaces.
85  * $wgCaptchaTriggersOnNamespace[<namespace id>][<trigger>] forces an always on / 
86  * always off configuration with that trigger for the given namespace.
87  * Leave unset to use the global options ($wgCaptchaTriggers).
88  *
89  * Shall not be used with 'createaccount' (it is not checked).
90  */
91 $wgCaptchaTriggersOnNamespace = array();
92
93 #Example:
94 #$wgCaptchaTriggersOnNamespace[NS_TALK]['create'] = false; //Allow creation of talk pages without captchas.
95 #$wgCaptchaTriggersOnNamespace[NS_PROJECT]['edit'] = true; //Show captcha whenever editing Project pages.
96
97 /**
98  * Indicate how to store per-session data required to match up the
99  * internal captcha data with the editor.
100  *
101  * 'CaptchaSessionStore' uses PHP's session storage, which is cookie-based
102  * and may fail for anons with cookies disabled.
103  *
104  * 'CaptchaCacheStore' uses $wgMemc, which avoids the cookie dependency
105  * but may be fragile depending on cache configuration.
106  */
107 global $wgCaptchaStorageClass;
108 $wgCaptchaStorageClass = 'CaptchaSessionStore';
109
110 /**
111  * Number of sections a captcha session should last in the data cache
112  * before expiring when managing through CaptchaCacheStore class.
113  *
114  * Default is a half hour.
115  */
116 global $wgCaptchaSessionExpiration;
117 $wgCaptchaSessionExpiration = 30 * 60;
118
119 /**
120  * Allow users who have confirmed their e-mail addresses to post
121  * URL links without being harassed by the captcha.
122  */
123 global $ceAllowConfirmedEmail;
124 $ceAllowConfirmedEmail = false;
125
126 /**
127  * Regex to whitelist URLs to known-good sites...
128  * For instance:
129  * $wgCaptchaWhitelist = '#^https?://([a-z0-9-]+\\.)?(wikimedia|wikipedia)\.org/#i';
130  * @fixme Use the 'spam-whitelist' thingy instead?
131  */
132 $wgCaptchaWhitelist = false;
133
134 /**
135  * Additional regexes to check for. Use full regexes; can match things
136  * other than URLs such as junk edits.
137  *
138  * If the new version matches one and the old version doesn't,
139  * toss up the captcha screen.
140  *
141  * @fixme Add a message for local admins to add items as well.
142  */
143 $wgCaptchaRegexes = array();
144
145 /** Register special page */
146 global $wgSpecialPages;
147 $wgSpecialPages['Captcha'] = array( /*class*/ 'SpecialPage', /*name*/'Captcha', /*restriction*/ '',
148         /*listed*/ false, /*function*/ false, /*file*/ false );
149
150 /**
151  * Set up message strings for captcha utilities.
152  */
153 function ceSetup() {
154         # Add messages
155         global $wgMessageCache, $wgConfirmEditMessages;
156         foreach( $wgConfirmEditMessages as $lang => $messages )
157                 $wgMessageCache->addMessages( $messages, $lang );
158
159         global $wgHooks, $wgCaptcha, $wgCaptchaClass, $wgSpecialPages;
160         $wgCaptcha = new $wgCaptchaClass();
161         $wgHooks['EditFilter'][] = array( &$wgCaptcha, 'confirmEdit' );
162
163         $wgHooks['UserCreateForm'][] = array( &$wgCaptcha, 'injectUserCreate' );
164         $wgHooks['AbortNewAccount'][] = array( &$wgCaptcha, 'confirmUserCreate' );
165 }
166
167 /**
168  * Entry point for Special:Captcha
169  */
170 function wfSpecialCaptcha( $par = null ) {
171         global $wgCaptcha;
172         switch( $par ) {
173         case "image":
174                 return $wgCaptcha->showImage();
175         case "help":
176         default:
177                 return $wgCaptcha->showHelp();
178         }
179 }
180
181 class SimpleCaptcha {
182         function SimpleCaptcha() {
183                 global $wgCaptchaStorageClass;
184                 $this->storage = new $wgCaptchaStorageClass;
185         }
186         
187         /**
188          * Insert a captcha prompt into the edit form.
189          * This sample implementation generates a simple arithmetic operation;
190          * it would be easy to defeat by machine.
191          *
192          * Override this!
193          *
194          * @return string HTML
195          */
196         function getForm() {
197                 $a = mt_rand(0, 100);
198                 $b = mt_rand(0, 10);
199                 $op = mt_rand(0, 1) ? '+' : '-';
200
201                 $test = "$a $op $b";
202                 $answer = ($op == '+') ? ($a + $b) : ($a - $b);
203
204                 $index = $this->storeCaptcha( array( 'answer' => $answer ) );
205
206                 return "<p><label for=\"wpCaptchaWord\">$test</label> = " .
207                         wfElement( 'input', array(
208                                 'name' => 'wpCaptchaWord',
209                                 'id'   => 'wpCaptchaWord',
210                                 'tabindex' => 1 ) ) . // tab in before the edit textarea
211                         "</p>\n" .
212                         wfElement( 'input', array(
213                                 'type'  => 'hidden',
214                                 'name'  => 'wpCaptchaId',
215                                 'id'    => 'wpCaptchaId',
216                                 'value' => $index ) );
217         }
218
219         /**
220          * Insert the captcha prompt into an edit form.
221          * @param OutputPage $out
222          */
223         function editCallback( &$out ) {
224                 $out->addWikiText( $this->getMessage( $this->action ) );
225                 $out->addHTML( $this->getForm() );
226         }
227
228         /**
229          * Show a message asking the user to enter a captcha on edit
230          * The result will be treated as wiki text
231          *
232          * @param $action Action being performed
233          * @return string
234          */
235         function getMessage( $action ) {
236                 $name = 'captcha-' . $action;
237                 $text = wfMsg( $name );
238                 # Obtain a more tailored message, if possible, otherwise, fall back to
239                 # the default for edits
240                 return wfEmptyMsg( $name, $text ) ? wfMsg( 'captcha-edit' ) : $text;
241         }
242
243         /**
244          * Inject whazawhoo
245          * @fixme if multiple thingies insert a header, could break
246          * @param SimpleTemplate $template
247          * @return bool true to keep running callbacks
248          */
249         function injectUserCreate( &$template ) {
250                 global $wgCaptchaTriggers, $wgOut;
251                 if( $wgCaptchaTriggers['createaccount'] ) {
252                         $template->set( 'header',
253                                 "<div class='captcha'>" .
254                                 $wgOut->parse( $this->getMessage( 'createaccount' ) ) .
255                                 $this->getForm() .
256                                 "</div>\n" );
257                 }
258                 return true;
259         }
260
261         /**
262          * Check if the submitted form matches the captcha session data provided
263          * by the plugin when the form was generated.
264          *
265          * Override this!
266          *
267          * @param WebRequest $request
268          * @param array $info
269          * @return bool
270          */
271         function keyMatch( $request, $info ) {
272                 return $request->getVal( 'wpCaptchaWord' ) == $info['answer'];
273         }
274
275         // ----------------------------------
276
277         /**
278          * @param EditPage $editPage
279          * @param string $action (edit/create/addurl...)
280          * @return bool true if action triggers captcha on editPage's namespace
281          */
282         function captchaTriggers( &$editPage, $action) {
283                 global $wgCaptchaTriggers, $wgCaptchaTriggersOnNamespace;       
284                 //Special config for this NS?
285                 if (isset( $wgCaptchaTriggersOnNamespace[$editPage->mTitle->getNamespace()][$action] ) )
286                         return $wgCaptchaTriggersOnNamespace[$editPage->mTitle->getNamespace()][$action];
287
288                 return ( !empty( $wgCaptchaTriggers[$action] ) ); //Default
289         }
290
291
292         /**
293          * @param EditPage $editPage
294          * @param string $newtext
295          * @param string $section
296          * @return bool true if the captcha should run
297          */
298         function shouldCheck( &$editPage, $newtext, $section ) {
299                 $this->trigger = '';
300
301                 global $wgUser;
302                 if( $wgUser->isAllowed( 'skipcaptcha' ) ) {
303                         wfDebug( "ConfirmEdit: user group allows skipping captcha\n" );
304                         return false;
305                 }
306
307                 global $wgEmailAuthentication, $ceAllowConfirmedEmail;
308                 if( $wgEmailAuthentication && $ceAllowConfirmedEmail &&
309                         $wgUser->isEmailConfirmed() ) {
310                         wfDebug( "ConfirmEdit: user has confirmed mail, skipping captcha\n" );
311                         return false;
312                 }
313
314                 if( $this->captchaTriggers( $editPage, 'edit' ) ) {
315                         // Check on all edits
316                         global $wgUser, $wgTitle;
317                         $this->trigger = sprintf( "edit trigger by '%s' at [[%s]]",
318                                 $wgUser->getName(),
319                                 $wgTitle->getPrefixedText() );
320                         $this->action = 'edit';
321                         wfDebug( "ConfirmEdit: checking all edits...\n" );
322                         return true;
323                 }
324
325                 if( $this->captchaTriggers( $editPage, 'create' )  && !$editPage->mTitle->exists() ) {
326                         //Check if creating a page
327                         global $wgUser, $wgTitle;
328                         $this->trigger = sprintf( "Create trigger by '%s' at [[%s]]",
329                                 $wgUser->getName(),
330                                 $wgTitle->getPrefixedText() );
331                         $this->action = 'create';
332                         wfDebug( "ConfirmEdit: checking on page creation...\n" );
333                         return true;
334                 }
335
336                 if( $this->captchaTriggers( $editPage, 'addurl' ) ) {
337                         // Only check edits that add URLs
338                         $oldtext = $this->loadText( $editPage, $section );
339
340                         $oldLinks = $this->findLinks( $oldtext );
341                         $newLinks = $this->findLinks( $newtext );
342                         $unknownLinks = array_filter( $newLinks, array( &$this, 'filterLink' ) );
343
344                         $addedLinks = array_diff( $unknownLinks, $oldLinks );
345                         $numLinks = count( $addedLinks );
346
347                         if( $numLinks > 0 ) {
348                                 global $wgUser, $wgTitle;
349                                 $this->trigger = sprintf( "%dx url trigger by '%s' at [[%s]]: %s",
350                                         $numLinks,
351                                         $wgUser->getName(),
352                                         $wgTitle->getPrefixedText(),
353                                         implode( ", ", $addedLinks ) );
354                                 $this->action = 'addurl';
355                                 return true;
356                         }
357                 }
358
359                 global $wgCaptchaRegexes;
360                 if( !empty( $wgCaptchaRegexes ) ) {
361                         // Custom regex checks
362                         $oldtext = $this->loadText( $editPage, $section );
363
364                         foreach( $wgCaptchaRegexes as $regex ) {
365                                 $newMatches = array();
366                                 if( preg_match_all( $regex, $newtext, $newMatches ) ) {
367                                         $oldMatches = array();
368                                         preg_match_all( $regex, $oldtext, $oldMatches );
369
370                                         $addedMatches = array_diff( $newMatches[0], $oldMatches[0] );
371
372                                         $numHits = count( $addedMatches );
373                                         if( $numHits > 0 ) {
374                                                 global $wgUser, $wgTitle;
375                                                 $this->trigger = sprintf( "%dx %s at [[%s]]: %s",
376                                                         $numHits,
377                                                         $regex,
378                                                         $wgUser->getName(),
379                                                         $wgTitle->getPrefixedText(),
380                                                         implode( ", ", $addedMatches ) );
381                                                 $this->action = 'edit';
382                                                 return true;
383                                         }
384                                 }
385                         }
386                 }
387
388                 return false;
389         }
390
391         /**
392          * Filter callback function for URL whitelisting
393          * @return bool true if unknown, false if whitelisted
394          * @access private
395          */
396         function filterLink( $url ) {
397                 global $wgCaptchaWhitelist;
398                 return !( $wgCaptchaWhitelist && preg_match( $wgCaptchaWhitelist, $url ) );
399         }
400
401         /**
402          * The main callback run on edit attempts.
403          * @param EditPage $editPage
404          * @param string $newtext
405          * @param string $section
406          * @param bool true to continue saving, false to abort and show a captcha form
407          */
408         function confirmEdit( &$editPage, $newtext, $section ) {
409                 if( $this->shouldCheck( $editPage, $newtext, $section ) ) {
410                         if( $this->passCaptcha() ) {
411                                 return true;
412                         } else {
413                                 $editPage->showEditForm( array( &$this, 'editCallback' ) );
414                                 return false;
415                         }
416                 } else {
417                         wfDebug( "ConfirmEdit: no need to show captcha.\n" );
418                         return true;
419                 }
420         }
421
422         /**
423          * Hook for user creation form submissions.
424          * @param User $u
425          * @param string $message
426          * @return bool true to continue, false to abort user creation
427          */
428         function confirmUserCreate( $u, &$message ) {
429                 global $wgCaptchaTriggers;
430                 if( $wgCaptchaTriggers['createaccount'] ) {
431                         $this->trigger = "new account '" . $u->getName() . "'";
432                         if( !$this->passCaptcha() ) {
433                                 $message = wfMsg( 'captcha-createaccount-fail' );
434                                 return false;
435                         }
436                 }
437                 return true;
438         }
439
440         /**
441          * Given a required captcha run, test form input for correct
442          * input on the open session.
443          * @return bool if passed, false if failed or new session
444          */
445         function passCaptcha() {
446                 $info = $this->retrieveCaptcha();
447                 if( $info ) {
448                         global $wgRequest;
449                         if( $this->keyMatch( $wgRequest, $info ) ) {
450                                 $this->log( "passed" );
451                                 $this->clearCaptcha( $info );
452                                 return true;
453                         } else {
454                                 $this->clearCaptcha( $info );
455                                 $this->log( "bad form input" );
456                                 return false;
457                         }
458                 } else {
459                         $this->log( "new captcha session" );
460                         return false;
461                 }
462         }
463
464         /**
465          * Log the status and any triggering info for debugging or statistics
466          * @param string $message
467          */
468         function log( $message ) {
469                 wfDebugLog( 'captcha', 'ConfirmEdit: ' . $message . '; ' .  $this->trigger );
470         }
471
472         /**
473          * Generate a captcha session ID and save the info in PHP's session storage.
474          * (Requires the user to have cookies enabled to get through the captcha.)
475          *
476          * A random ID is used so legit users can make edits in multiple tabs or
477          * windows without being unnecessarily hobbled by a serial order requirement.
478          * Pass the returned id value into the edit form as wpCaptchaId.
479          *
480          * @param array $info data to store
481          * @return string captcha ID key
482          */
483         function storeCaptcha( $info ) {
484                 if( !isset( $info['index'] ) ) {
485                         // Assign random index if we're not udpating
486                         $info['index'] = strval( mt_rand() );
487                 }
488                 $this->storage->store( $info['index'], $info );
489                 return $info['index'];
490         }
491
492         /**
493          * Fetch this session's captcha info.
494          * @return mixed array of info, or false if missing
495          */
496         function retrieveCaptcha() {
497                 global $wgRequest;
498                 $index = $wgRequest->getVal( 'wpCaptchaId' );
499                 return $this->storage->retrieve( $index );
500         }
501
502         /**
503          * Clear out existing captcha info from the session, to ensure
504          * it can't be reused.
505          */
506         function clearCaptcha( $info ) {
507                 $this->storage->clear( $info['index'] );
508         }
509
510         /**
511          * Retrieve the current version of the page or section being edited...
512          * @param EditPage $editPage
513          * @param string $section
514          * @return string
515          * @access private
516          */
517         function loadText( $editPage, $section ) {
518                 $rev = Revision::newFromTitle( $editPage->mTitle );
519                 if( is_null( $rev ) ) {
520                         return "";
521                 } else {
522                         $text = $rev->getText();
523                         if( $section != '' ) {
524                                 return Article::getSection( $text, $section );
525                         } else {
526                                 return $text;
527                         }
528                 }
529         }
530
531         /**
532          * Extract a list of all recognized HTTP links in the text.
533          * @param string $text
534          * @return array of strings
535          */
536         function findLinks( $text ) {
537                 global $wgParser, $wgTitle, $wgUser;
538
539                 $options = new ParserOptions();
540                 $text = $wgParser->preSaveTransform( $text, $wgTitle, $wgUser, $options );
541                 $out = $wgParser->parse( $text, $wgTitle, $options );
542
543                 return array_keys( $out->getExternalLinks() );
544         }
545
546         /**
547          * Show a page explaining what this wacky thing is.
548          */
549         function showHelp() {
550                 global $wgOut, $ceAllowConfirmedEmail;
551                 $wgOut->setPageTitle( wfMsg( 'captchahelp-title' ) );
552                 $wgOut->addWikiText( wfMsg( 'captchahelp-text' ) );
553                 if ( $this->storage->cookiesNeeded() ) {
554                         $wgOut->addWikiText( wfMsg( 'captchahelp-cookies-needed' ) );
555                 }
556         }
557
558 }
559
560 class CaptchaSessionStore {
561         function store( $index, $info ) {
562                 $_SESSION['captcha' . $info['index']] = $info;
563         }
564         
565         function retrieve( $index ) {
566                 if( isset( $_SESSION['captcha' . $index] ) ) {
567                         return $_SESSION['captcha' . $index];
568                 } else {
569                         return false;
570                 }
571         }
572         
573         function clear( $index ) {
574                 unset( $_SESSION['captcha' . $index] );
575         }
576
577         function cookiesNeeded() {
578                 return true;
579         }
580 }
581
582 class CaptchaCacheStore {
583         function store( $index, $info ) {
584                 global $wgMemc, $wgCaptchaSessionExpiration;
585                 $wgMemc->set( wfMemcKey( 'captcha', $index ), $info,
586                         $wgCaptchaSessionExpiration );
587         }
588
589         function retrieve( $index ) {
590                 global $wgMemc;
591                 $info = $wgMemc->get( wfMemcKey( 'captcha', $index ) );
592                 if( $info ) {
593                         return $info;
594                 } else {
595                         return false;
596                 }
597         }
598         
599         function clear( $index ) {
600                 global $wgMemc;
601                 $wgMemc->delete( wfMemcKey( 'captcha', $index ) );
602         }
603
604         function cookiesNeeded() {
605                 return false;
606         }
607 }
608
609 } # End invocation guard
610
611 ?>