ac1cbaf6bb838aed3f4d4bdda55ac9db60096cbd
[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 $wgCaptchaTriggers = array();
74 $wgCaptchaTriggers['edit']          = false; // Would check on every edit
75 $wgCaptchaTriggers['addurl']        = true;  // Check on edits that add URLs
76 $wgCaptchaTriggers['createaccount'] = true;  // Special:Userlogin&type=signup
77
78 /**
79  * Indicate how to store per-session data required to match up the
80  * internal captcha data with the editor.
81  *
82  * 'CaptchaSessionStore' uses PHP's session storage, which is cookie-based
83  * and may fail for anons with cookies disabled.
84  *
85  * 'CaptchaCacheStore' uses $wgMemc, which avoids the cookie dependency
86  * but may be fragile depending on cache configuration.
87  */
88 global $wgCaptchaStorageClass;
89 $wgCaptchaStorageClass = 'CaptchaSessionStore';
90
91 /**
92  * Number of sections a captcha session should last in the data cache
93  * before expiring when managing through CaptchaCacheStore class.
94  *
95  * Default is a half hour.
96  */
97 global $wgCaptchaSessionExpiration;
98 $wgCaptchaSessionExpiration = 30 * 60;
99
100 /**
101  * Allow users who have confirmed their e-mail addresses to post
102  * URL links without being harassed by the captcha.
103  */
104 global $ceAllowConfirmedEmail;
105 $ceAllowConfirmedEmail = false;
106
107 /**
108  * Regex to whitelist URLs to known-good sites...
109  * For instance:
110  * $wgCaptchaWhitelist = '#^https?://([a-z0-9-]+\\.)?(wikimedia|wikipedia)\.org/#i';
111  * @fixme Use the 'spam-whitelist' thingy instead?
112  */
113 $wgCaptchaWhitelist = false;
114
115 /**
116  * Additional regexes to check for. Use full regexes; can match things
117  * other than URLs such as junk edits.
118  *
119  * If the new version matches one and the old version doesn't,
120  * toss up the captcha screen.
121  *
122  * @fixme Add a message for local admins to add items as well.
123  */
124 $wgCaptchaRegexes = array();
125
126 /** Register special page */
127 global $wgSpecialPages;
128 $wgSpecialPages['Captcha'] = array( /*class*/ 'SpecialPage', /*name*/'Captcha', /*restriction*/ '',
129         /*listed*/ false, /*function*/ false, /*file*/ false );
130
131 /**
132  * Set up message strings for captcha utilities.
133  */
134 function ceSetup() {
135         # Add messages
136         global $wgMessageCache, $wgConfirmEditMessages;
137         foreach( $wgConfirmEditMessages as $lang => $messages )
138                 $wgMessageCache->addMessages( $messages, $lang );
139
140         global $wgHooks, $wgCaptcha, $wgCaptchaClass, $wgSpecialPages;
141         $wgCaptcha = new $wgCaptchaClass();
142         $wgHooks['EditFilter'][] = array( &$wgCaptcha, 'confirmEdit' );
143
144         $wgHooks['UserCreateForm'][] = array( &$wgCaptcha, 'injectUserCreate' );
145         $wgHooks['AbortNewAccount'][] = array( &$wgCaptcha, 'confirmUserCreate' );
146 }
147
148 /**
149  * Entry point for Special:Captcha
150  */
151 function wfSpecialCaptcha( $par = null ) {
152         global $wgCaptcha;
153         switch( $par ) {
154         case "image":
155                 return $wgCaptcha->showImage();
156         case "help":
157         default:
158                 return $wgCaptcha->showHelp();
159         }
160 }
161
162 class SimpleCaptcha {
163         function SimpleCaptcha() {
164                 global $wgCaptchaStorageClass;
165                 $this->storage = new $wgCaptchaStorageClass;
166         }
167         
168         /**
169          * Insert a captcha prompt into the edit form.
170          * This sample implementation generates a simple arithmetic operation;
171          * it would be easy to defeat by machine.
172          *
173          * Override this!
174          *
175          * @return string HTML
176          */
177         function getForm() {
178                 $a = mt_rand(0, 100);
179                 $b = mt_rand(0, 10);
180                 $op = mt_rand(0, 1) ? '+' : '-';
181
182                 $test = "$a $op $b";
183                 $answer = ($op == '+') ? ($a + $b) : ($a - $b);
184
185                 $index = $this->storeCaptcha( array( 'answer' => $answer ) );
186
187                 return "<p><label for=\"wpCaptchaWord\">$test</label> = " .
188                         wfElement( 'input', array(
189                                 'name' => 'wpCaptchaWord',
190                                 'id'   => 'wpCaptchaWord',
191                                 'tabindex' => 1 ) ) . // tab in before the edit textarea
192                         "</p>\n" .
193                         wfElement( 'input', array(
194                                 'type'  => 'hidden',
195                                 'name'  => 'wpCaptchaId',
196                                 'id'    => 'wpCaptchaId',
197                                 'value' => $index ) );
198         }
199
200         /**
201          * Insert the captcha prompt into an edit form.
202          * @param OutputPage $out
203          */
204         function editCallback( &$out ) {
205                 $out->addWikiText( $this->getMessage( 'edit' ) );
206                 $out->addHTML( $this->getForm() );
207         }
208
209         /**
210          * Show a message asking the user to enter a captcha on edit
211          * The result will be treated as wiki text
212          *
213          * @param $action Action being performed
214          * @return string
215          */
216         function getMessage( $action ) {
217                 $name = 'captcha-' . $action;
218                 $text = wfMsg( $name );
219                 # Obtain a more tailored message, if possible, otherwise, fall back to
220                 # the default for edits
221                 return wfEmptyMsg( $name, $text ) ? wfMsg( 'captcha-edit' ) : $text;
222         }
223
224         /**
225          * Inject whazawhoo
226          * @fixme if multiple thingies insert a header, could break
227          * @param SimpleTemplate $template
228          * @return bool true to keep running callbacks
229          */
230         function injectUserCreate( &$template ) {
231                 global $wgCaptchaTriggers, $wgOut;
232                 if( $wgCaptchaTriggers['createaccount'] ) {
233                         $template->set( 'header',
234                                 "<div class='captcha'>" .
235                                 $wgOut->parse( $this->getMessage( 'createaccount' ) ) .
236                                 $this->getForm() .
237                                 "</div>\n" );
238                 }
239                 return true;
240         }
241
242         /**
243          * Check if the submitted form matches the captcha session data provided
244          * by the plugin when the form was generated.
245          *
246          * Override this!
247          *
248          * @param WebRequest $request
249          * @param array $info
250          * @return bool
251          */
252         function keyMatch( $request, $info ) {
253                 return $request->getVal( 'wpCaptchaWord' ) == $info['answer'];
254         }
255
256         // ----------------------------------
257
258         /**
259          * @param EditPage $editPage
260          * @param string $newtext
261          * @param string $section
262          * @return bool true if the captcha should run
263          */
264         function shouldCheck( &$editPage, $newtext, $section ) {
265                 $this->trigger = '';
266
267                 global $wgUser;
268                 if( $wgUser->isAllowed( 'skipcaptcha' ) ) {
269                         wfDebug( "ConfirmEdit: user group allows skipping captcha\n" );
270                         return false;
271                 }
272
273                 global $wgEmailAuthentication, $ceAllowConfirmedEmail;
274                 if( $wgEmailAuthentication && $ceAllowConfirmedEmail &&
275                         $wgUser->isEmailConfirmed() ) {
276                         wfDebug( "ConfirmEdit: user has confirmed mail, skipping captcha\n" );
277                         return false;
278                 }
279
280                 global $wgCaptchaTriggers;
281                 if( !empty( $wgCaptchaTriggers['edit'] ) ) {
282                         // Check on all edits
283                         global $wgUser, $wgTitle;
284                         $this->trigger = sprintf( "edit trigger by '%s' at [[%s]]",
285                                 $wgUser->getName(),
286                                 $wgTitle->getPrefixedText() );
287                         wfDebug( "ConfirmEdit: checking all edits...\n" );
288                         return true;
289                 }
290
291                 if( !empty( $wgCaptchaTriggers['addurl'] ) ) {
292                         // Only check edits that add URLs
293                         $oldtext = $this->loadText( $editPage, $section );
294
295                         $oldLinks = $this->findLinks( $oldtext );
296                         $newLinks = $this->findLinks( $newtext );
297                         $unknownLinks = array_filter( $newLinks, array( &$this, 'filterLink' ) );
298
299                         $addedLinks = array_diff( $unknownLinks, $oldLinks );
300                         $numLinks = count( $addedLinks );
301
302                         if( $numLinks > 0 ) {
303                                 global $wgUser, $wgTitle;
304                                 $this->trigger = sprintf( "%dx url trigger by '%s' at [[%s]]: %s",
305                                         $numLinks,
306                                         $wgUser->getName(),
307                                         $wgTitle->getPrefixedText(),
308                                         implode( ", ", $addedLinks ) );
309                                 return true;
310                         }
311                 }
312
313                 global $wgCaptchaRegexes;
314                 if( !empty( $wgCaptchaRegexes ) ) {
315                         // Custom regex checks
316                         $oldtext = $this->loadText( $editPage, $section );
317
318                         foreach( $wgCaptchaRegexes as $regex ) {
319                                 $newMatches = array();
320                                 if( preg_match_all( $regex, $newtext, $newMatches ) ) {
321                                         $oldMatches = array();
322                                         preg_match_all( $regex, $oldtext, $oldMatches );
323
324                                         $addedMatches = array_diff( $newMatches[0], $oldMatches[0] );
325
326                                         $numHits = count( $addedMatches );
327                                         if( $numHits > 0 ) {
328                                                 global $wgUser, $wgTitle;
329                                                 $this->trigger = sprintf( "%dx %s at [[%s]]: %s",
330                                                         $numHits,
331                                                         $regex,
332                                                         $wgUser->getName(),
333                                                         $wgTitle->getPrefixedText(),
334                                                         implode( ", ", $addedMatches ) );
335                                                 return true;
336                                         }
337                                 }
338                         }
339                 }
340
341                 return false;
342         }
343
344         /**
345          * Filter callback function for URL whitelisting
346          * @return bool true if unknown, false if whitelisted
347          * @access private
348          */
349         function filterLink( $url ) {
350                 global $wgCaptchaWhitelist;
351                 return !( $wgCaptchaWhitelist && preg_match( $wgCaptchaWhitelist, $url ) );
352         }
353
354         /**
355          * The main callback run on edit attempts.
356          * @param EditPage $editPage
357          * @param string $newtext
358          * @param string $section
359          * @param bool true to continue saving, false to abort and show a captcha form
360          */
361         function confirmEdit( &$editPage, $newtext, $section ) {
362                 if( $this->shouldCheck( $editPage, $newtext, $section ) ) {
363                         if( $this->passCaptcha() ) {
364                                 return true;
365                         } else {
366                                 $editPage->showEditForm( array( &$this, 'editCallback' ) );
367                                 return false;
368                         }
369                 } else {
370                         wfDebug( "ConfirmEdit: no new links.\n" );
371                         return true;
372                 }
373         }
374
375         /**
376          * Hook for user creation form submissions.
377          * @param User $u
378          * @param string $message
379          * @return bool true to continue, false to abort user creation
380          */
381         function confirmUserCreate( $u, &$message ) {
382                 global $wgCaptchaTriggers;
383                 if( $wgCaptchaTriggers['createaccount'] ) {
384                         $this->trigger = "new account '" . $u->getName() . "'";
385                         if( !$this->passCaptcha() ) {
386                                 $message = wfMsg( 'captcha-createaccount-fail' );
387                                 return false;
388                         }
389                 }
390                 return true;
391         }
392
393         /**
394          * Given a required captcha run, test form input for correct
395          * input on the open session.
396          * @return bool if passed, false if failed or new session
397          */
398         function passCaptcha() {
399                 $info = $this->retrieveCaptcha();
400                 if( $info ) {
401                         global $wgRequest;
402                         if( $this->keyMatch( $wgRequest, $info ) ) {
403                                 $this->log( "passed" );
404                                 $this->clearCaptcha( $info );
405                                 return true;
406                         } else {
407                                 $this->clearCaptcha( $info );
408                                 $this->log( "bad form input" );
409                                 return false;
410                         }
411                 } else {
412                         $this->log( "new captcha session" );
413                         return false;
414                 }
415         }
416
417         /**
418          * Log the status and any triggering info for debugging or statistics
419          * @param string $message
420          */
421         function log( $message ) {
422                 wfDebugLog( 'captcha', 'ConfirmEdit: ' . $message . '; ' .  $this->trigger );
423         }
424
425         /**
426          * Generate a captcha session ID and save the info in PHP's session storage.
427          * (Requires the user to have cookies enabled to get through the captcha.)
428          *
429          * A random ID is used so legit users can make edits in multiple tabs or
430          * windows without being unnecessarily hobbled by a serial order requirement.
431          * Pass the returned id value into the edit form as wpCaptchaId.
432          *
433          * @param array $info data to store
434          * @return string captcha ID key
435          */
436         function storeCaptcha( $info ) {
437                 if( !isset( $info['index'] ) ) {
438                         // Assign random index if we're not udpating
439                         $info['index'] = strval( mt_rand() );
440                 }
441                 $this->storage->store( $info['index'], $info );
442                 return $info['index'];
443         }
444
445         /**
446          * Fetch this session's captcha info.
447          * @return mixed array of info, or false if missing
448          */
449         function retrieveCaptcha() {
450                 global $wgRequest;
451                 $index = $wgRequest->getVal( 'wpCaptchaId' );
452                 return $this->storage->retrieve( $index );
453         }
454
455         /**
456          * Clear out existing captcha info from the session, to ensure
457          * it can't be reused.
458          */
459         function clearCaptcha( $info ) {
460                 $this->storage->clear( $info['index'] );
461         }
462
463         /**
464          * Retrieve the current version of the page or section being edited...
465          * @param EditPage $editPage
466          * @param string $section
467          * @return string
468          * @access private
469          */
470         function loadText( $editPage, $section ) {
471                 $rev = Revision::newFromTitle( $editPage->mTitle );
472                 if( is_null( $rev ) ) {
473                         return "";
474                 } else {
475                         $text = $rev->getText();
476                         if( $section != '' ) {
477                                 return Article::getSection( $text, $section );
478                         } else {
479                                 return $text;
480                         }
481                 }
482         }
483
484         /**
485          * Extract a list of all recognized HTTP links in the text.
486          * @param string $text
487          * @return array of strings
488          */
489         function findLinks( $text ) {
490                 global $wgParser, $wgTitle, $wgUser;
491
492                 $options = new ParserOptions();
493                 $text = $wgParser->preSaveTransform( $text, $wgTitle, $wgUser, $options );
494                 $out = $wgParser->parse( $text, $wgTitle, $options );
495
496                 return array_keys( $out->getExternalLinks() );
497         }
498
499         /**
500          * Show a page explaining what this wacky thing is.
501          */
502         function showHelp() {
503                 global $wgOut, $ceAllowConfirmedEmail;
504                 $wgOut->setPageTitle( wfMsg( 'captchahelp-title' ) );
505                 $wgOut->addWikiText( wfMsg( 'captchahelp-text' ) );
506         }
507
508 }
509
510 class CaptchaSessionStore {
511         function store( $index, $info ) {
512                 $_SESSION['captcha' . $info['index']] = $info;
513         }
514         
515         function retrieve( $index ) {
516                 if( isset( $_SESSION['captcha' . $index] ) ) {
517                         return $_SESSION['captcha' . $index];
518                 } else {
519                         return false;
520                 }
521         }
522         
523         function clear( $index ) {
524                 unset( $_SESSION['captcha' . $index] );
525         }
526 }
527
528 class CaptchaCacheStore {
529         function store( $index, $info ) {
530                 global $wgMemc, $wgCaptchaSessionExpiration;
531                 $wgMemc->set( wfMemcKey( 'captcha', $index ), $info,
532                         $wgCaptchaSessionExpiration );
533         }
534
535         function retrieve( $index ) {
536                 global $wgMemc;
537                 $info = $wgMemc->get( wfMemcKey( 'captcha', $index ) );
538                 if( $info ) {
539                         return $info;
540                 } else {
541                         return false;
542                 }
543         }
544         
545         function clear( $index ) {
546                 global $wgMemc;
547                 $wgMemc->delete( wfMemcKey( 'captcha', $index ) );
548         }
549 }
550
551 } # End invocation guard
552
553 ?>