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