Captcha.php

   1 <?php
   2
   3 class SimpleCaptcha {
   4         function getCaptcha() {
   5                 $a = mt_rand( 0, 100 );
   6                 $b = mt_rand( 0, 10 );
   7
   8                 /* Minus sign is used in the question. UTF-8,
   9                    since the api uses text/plain, not text/html */
  10                 $op = mt_rand( 0, 1 ) ? '+' : '−';
  11
  12                 // No space before and after $op, to ensure correct
  13                 // directionality.
  14                 $test = "$a$op$b";
  15                 $answer = ( $op == '+' ) ? ( $a + $b ) : ( $a - $b );
  16                 return array( 'question' => $test, 'answer' => $answer );
  17         }
  18
  19         function addCaptchaAPI( &$resultArr ) {
  20                 $captcha = $this->getCaptcha();
  21                 $index = $this->storeCaptcha( $captcha );
  22                 $resultArr['captcha']['type'] = 'simple';
  23                 $resultArr['captcha']['mime'] = 'text/plain';
  24                 $resultArr['captcha']['id'] = $index;
  25                 $resultArr['captcha']['question'] = $captcha['question'];
  26         }
  27
  28         /**
  29          * Insert a captcha prompt into the edit form.
  30          * This sample implementation generates a simple arithmetic operation;
  31          * it would be easy to defeat by machine.
  32          *
  33          * Override this!
  34          *
  35          * @return string HTML
  36          */
  37         function getForm() {
  38                 $captcha = $this->getCaptcha();
  39                 $index = $this->storeCaptcha( $captcha );
  40
  41                 return "<p><label for=\"wpCaptchaWord\">{$captcha['question']}</label> = " .
  42                         Xml::element( 'input', array(
  43                                 'name' => 'wpCaptchaWord',
  44                                 'id'   => 'wpCaptchaWord',
  45                                 'tabindex' => 1 ) ) . // tab in before the edit textarea
  46                         "</p>\n" .
  47                         Xml::element( 'input', array(
  48                                 'type'  => 'hidden',
  49                                 'name'  => 'wpCaptchaId',
  50                                 'id'    => 'wpCaptchaId',
  51                                 'value' => $index ) );
  52         }
  53
  54         /**
  55          * Insert the captcha prompt into an edit form.
  56          * @param OutputPage $out
  57          */
  58         function editCallback( &$out ) {
  59                 $out->addWikiText( $this->getMessage( $this->action ) );
  60                 $out->addHTML( $this->getForm() );
  61         }
  62
  63         /**
  64          * Show a message asking the user to enter a captcha on edit
  65          * The result will be treated as wiki text
  66          *
  67          * @param $action string Action being performed
  68          * @return string
  69          */
  70         function getMessage( $action ) {
  71                 $name = 'captcha-' . $action;
  72                 $text = wfMessage( $name )->text();
  73                 # Obtain a more tailored message, if possible, otherwise, fall back to
  74                 # the default for edits
  75                 return wfMessage( $name, $text )->isDisabled() ? wfMessage( 'captcha-edit' )->text() : $text;
  76         }
  77
  78         /**
  79          * Inject whazawhoo
  80          * @fixme if multiple thingies insert a header, could break
  81          * @param $form HTMLForm
  82          * @return bool true to keep running callbacks
  83          */
  84         function injectEmailUser( &$form ) {
  85                 global $wgCaptchaTriggers, $wgOut, $wgUser;
  86                 if ( $wgCaptchaTriggers['sendemail'] ) {
  87                         if ( $wgUser->isAllowed( 'skipcaptcha' ) ) {
  88                                 wfDebug( "ConfirmEdit: user group allows skipping captcha on email sending\n" );
  89                                 return true;
  90                         }
  91                         $form->addFooterText(
  92                                 "<div class='captcha'>" .
  93                                 $wgOut->parse( $this->getMessage( 'sendemail' ) ) .
  94                                 $this->getForm() .
  95                                 "</div>\n" );
  96                 }
  97                 return true;
  98         }
  99
 100         /**
 101          * Inject whazawhoo
 102          * @fixme if multiple thingies insert a header, could break
 103          * @param QuickTemplate $template
 104          * @return bool true to keep running callbacks
 105          */
 106         function injectUserCreate( &$template ) {
 107                 global $wgCaptchaTriggers, $wgOut, $wgUser;
 108                 if ( $wgCaptchaTriggers['createaccount'] ) {
 109                         if ( $wgUser->isAllowed( 'skipcaptcha' ) ) {
 110                                 wfDebug( "ConfirmEdit: user group allows skipping captcha on account creation\n" );
 111                                 return true;
 112                         }
 113                         $template->set( 'header',
 114                                 "<div class='captcha'>" .
 115                                 $wgOut->parse( $this->getMessage( 'createaccount' ) ) .
 116                                 $this->getForm() .
 117                                 "</div>\n" );
 118                 }
 119                 return true;
 120         }
 121
 122         /**
 123          * Inject a captcha into the user login form after a failed
 124          * password attempt as a speedbump for mass attacks.
 125          * @fixme if multiple thingies insert a header, could break
 126          * @param $template QuickTemplate
 127          * @return bool true to keep running callbacks
 128          */
 129         function injectUserLogin( &$template ) {
 130                 if ( $this->isBadLoginTriggered() ) {
 131                         global $wgOut;
 132                         $template->set( 'header',
 133                                 "<div class='captcha'>" .
 134                                 $wgOut->parse( $this->getMessage( 'badlogin' ) ) .
 135                                 $this->getForm() .
 136                                 "</div>\n" );
 137                 }
 138                 return true;
 139         }
 140
 141         /**
 142          * When a bad login attempt is made, increment an expiring counter
 143          * in the memcache cloud. Later checks for this may trigger a
 144          * captcha display to prevent too many hits from the same place.
 145          * @param User $user
 146          * @param string $password
 147          * @param int $retval authentication return value
 148          * @return bool true to keep running callbacks
 149          */
 150         function triggerUserLogin( $user, $password, $retval ) {
 151                 global $wgCaptchaTriggers, $wgCaptchaBadLoginExpiration, $wgMemc;
 152                 if ( $retval == LoginForm::WRONG_PASS && $wgCaptchaTriggers['badlogin'] ) {
 153                         $key = $this->badLoginKey();
 154                         $count = $wgMemc->get( $key );
 155                         if ( !$count ) {
 156                                 $wgMemc->add( $key, 0, $wgCaptchaBadLoginExpiration );
 157                         }
 158
 159                         $wgMemc->incr( $key );
 160                 }
 161                 return true;
 162         }
 163
 164         /**
 165          * Check if a bad login has already been registered for this
 166          * IP address. If so, require a captcha.
 167          * @return bool
 168          * @access private
 169          */
 170         function isBadLoginTriggered() {
 171                 global $wgMemc, $wgCaptchaTriggers, $wgCaptchaBadLoginAttempts;
 172                 return $wgCaptchaTriggers['badlogin'] && intval( $wgMemc->get( $this->badLoginKey() ) ) >= $wgCaptchaBadLoginAttempts;
 173         }
 174
 175         /**
 176          * Check if the IP is allowed to skip captchas
 177          */
 178         function isIPWhitelisted() {
 179                 global $wgCaptchaWhitelistIP;
 180
 181                 if ( $wgCaptchaWhitelistIP ) {
 182                         global $wgRequest;
 183
 184                         $ip = $wgRequest->getIP();
 185
 186                         foreach ( $wgCaptchaWhitelistIP as $range ) {
 187                                 if ( IP::isInRange( $ip, $range ) ) {
 188                                         return true;
 189                                 }
 190                         }
 191                 }
 192                 return false;
 193         }
 194
 195         /**
 196          * Internal cache key for badlogin checks.
 197          * @return string
 198          * @access private
 199          */
 200         function badLoginKey() {
 201                 global $wgRequest;
 202                 $ip = $wgRequest->getIP();
 203                 return wfMemcKey( 'captcha', 'badlogin', 'ip', $ip );
 204         }
 205
 206         /**
 207          * Check if the submitted form matches the captcha session data provided
 208          * by the plugin when the form was generated.
 209          *
 210          * Override this!
 211          *
 212          * @param string $answer
 213          * @param array $info
 214          * @return bool
 215          */
 216         function keyMatch( $answer, $info ) {
 217                 return $answer == $info['answer'];
 218         }
 219
 220         // ----------------------------------
 221
 222         /**
 223          * @param EditPage $editPage
 224          * @param string $action (edit/create/addurl...)
 225          * @return bool true if action triggers captcha on editPage's namespace
 226          */
 227         function captchaTriggers( &$editPage, $action ) {
 228                 global $wgCaptchaTriggers, $wgCaptchaTriggersOnNamespace;
 229                 // Special config for this NS?
 230                 if ( isset( $wgCaptchaTriggersOnNamespace[$editPage->mTitle->getNamespace()][$action] ) )
 231                         return $wgCaptchaTriggersOnNamespace[$editPage->mTitle->getNamespace()][$action];
 232
 233                 return ( !empty( $wgCaptchaTriggers[$action] ) ); // Default
 234         }
 235
 236         /**
 237          * @param $editPage EditPage
 238          * @param $newtext string
 239          * @param $section string
 240          * @param $merged bool
 241          * @return bool true if the captcha should run
 242          */
 243         function shouldCheck( &$editPage, $newtext, $section, $merged = false ) {
 244                 $this->trigger = '';
 245                 $title = $editPage->mArticle->getTitle();
 246
 247                 global $wgUser;
 248                 if ( $wgUser->isAllowed( 'skipcaptcha' ) ) {
 249                         wfDebug( "ConfirmEdit: user group allows skipping captcha\n" );
 250                         return false;
 251                 }
 252                 if ( $this->isIPWhitelisted() )
 253                         return false;
 254
 255
 256                 global $wgEmailAuthentication, $ceAllowConfirmedEmail;
 257                 if ( $wgEmailAuthentication && $ceAllowConfirmedEmail &&
 258                         $wgUser->isEmailConfirmed() ) {
 259                         wfDebug( "ConfirmEdit: user has confirmed mail, skipping captcha\n" );
 260                         return false;
 261                 }
 262
 263                 if ( $this->captchaTriggers( $editPage, 'edit' ) ) {
 264                         // Check on all edits
 265                         global $wgUser;
 266                         $this->trigger = sprintf( "edit trigger by '%s' at [[%s]]",
 267                                 $wgUser->getName(),
 268                                 $title->getPrefixedText() );
 269                         $this->action = 'edit';
 270                         wfDebug( "ConfirmEdit: checking all edits...\n" );
 271                         return true;
 272                 }
 273
 274                 if ( $this->captchaTriggers( $editPage, 'create' )  && !$editPage->mTitle->exists() ) {
 275                         // Check if creating a page
 276                         global $wgUser;
 277                         $this->trigger = sprintf( "Create trigger by '%s' at [[%s]]",
 278                                 $wgUser->getName(),
 279                                 $title->getPrefixedText() );
 280                         $this->action = 'create';
 281                         wfDebug( "ConfirmEdit: checking on page creation...\n" );
 282                         return true;
 283                 }
 284
 285                 if ( $this->captchaTriggers( $editPage, 'addurl' ) ) {
 286                         // Only check edits that add URLs
 287                         if ( $merged ) {
 288                                 // Get links from the database
 289                                 $oldLinks = $this->getLinksFromTracker( $title );
 290                                 // Share a parse operation with Article::doEdit()
 291                                 $editInfo = $editPage->mArticle->prepareTextForEdit( $newtext );
 292                                 $newLinks = array_keys( $editInfo->output->getExternalLinks() );
 293                         } else {
 294                                 // Get link changes in the slowest way known to man
 295                                 $oldtext = $this->loadText( $editPage, $section );
 296                                 $oldLinks = $this->findLinks( $editPage, $oldtext );
 297                                 $newLinks = $this->findLinks( $editPage, $newtext );
 298                         }
 299
 300                         $unknownLinks = array_filter( $newLinks, array( &$this, 'filterLink' ) );
 301                         $addedLinks = array_diff( $unknownLinks, $oldLinks );
 302                         $numLinks = count( $addedLinks );
 303
 304                         if ( $numLinks > 0 ) {
 305                                 global $wgUser;
 306                                 $this->trigger = sprintf( "%dx url trigger by '%s' at [[%s]]: %s",
 307                                         $numLinks,
 308                                         $wgUser->getName(),
 309                                         $title->getPrefixedText(),
 310                                         implode( ", ", $addedLinks ) );
 311                                 $this->action = 'addurl';
 312                                 return true;
 313                         }
 314                 }
 315
 316                 global $wgCaptchaRegexes;
 317                 if ( $wgCaptchaRegexes ) {
 318                         // Custom regex checks. Reuse $oldtext if set above.
 319                         $oldtext = isset( $oldtext ) ? $oldtext : $this->loadText( $editPage, $section );
 320
 321                         foreach ( $wgCaptchaRegexes as $regex ) {
 322                                 $newMatches = array();
 323                                 if ( preg_match_all( $regex, $newtext, $newMatches ) ) {
 324                                         $oldMatches = array();
 325                                         preg_match_all( $regex, $oldtext, $oldMatches );
 326
 327                                         $addedMatches = array_diff( $newMatches[0], $oldMatches[0] );
 328
 329                                         $numHits = count( $addedMatches );
 330                                         if ( $numHits > 0 ) {
 331                                                 global $wgUser;
 332                                                 $this->trigger = sprintf( "%dx %s at [[%s]]: %s",
 333                                                         $numHits,
 334                                                         $regex,
 335                                                         $wgUser->getName(),
 336                                                         $title->getPrefixedText(),
 337                                                         implode( ", ", $addedMatches ) );
 338                                                 $this->action = 'edit';
 339                                                 return true;
 340                                         }
 341                                 }
 342                         }
 343                 }
 344
 345                 return false;
 346         }
 347
 348         /**
 349          * Filter callback function for URL whitelisting
 350          * @param $url string to check
 351          * @return bool true if unknown, false if whitelisted
 352          * @access private
 353          */
 354         function filterLink( $url ) {
 355                 global $wgCaptchaWhitelist;
 356                 $source = wfMessage( 'captcha-addurl-whitelist' )->inContentLanguage()->text();
 357
 358                 $whitelist = wfMessage( 'captcha-addurl-whitelist', $source )->isDisabled()
 359                         ? false
 360                         : $this->buildRegexes( explode( "\n", $source ) );
 361
 362                 $cwl = $wgCaptchaWhitelist !== false ? preg_match( $wgCaptchaWhitelist, $url ) : false;
 363                 $wl  = $whitelist          !== false ? preg_match( $whitelist, $url )          : false;
 364
 365                 return !( $cwl || $wl );
 366         }
 367
 368         /**
 369          * Build regex from whitelist
 370          * @param $lines string from [[MediaWiki:Captcha-addurl-whitelist]]
 371          * @return string Regex or bool false if whitelist is empty
 372          * @access private
 373          */
 374         function buildRegexes( $lines ) {
 375                 # Code duplicated from the SpamBlacklist extension (r19197)
 376
 377                 # Strip comments and whitespace, then remove blanks
 378                 $lines = array_filter( array_map( 'trim', preg_replace( '/#.*$/', '', $lines ) ) );
 379
 380                 # No lines, don't make a regex which will match everything
 381                 if ( count( $lines ) == 0 ) {
 382                         wfDebug( "No lines\n" );
 383                         return false;
 384                 } else {
 385                         # Make regex
 386                         # It's faster using the S modifier even though it will usually only be run once
 387                         // $regex = 'http://+[a-z0-9_\-.]*(' . implode( '|', $lines ) . ')';
 388                         // return '/' . str_replace( '/', '\/', preg_replace('|\\\*/|', '/', $regex) ) . '/Si';
 389                         $regexes = '';
 390                         $regexStart = '/^https?:\/\/+[a-z0-9_\-.]*(';
 391                         $regexEnd = ')/Si';
 392                         $regexMax = 4096;
 393                         $build = false;
 394                         foreach ( $lines as $line ) {
 395                                 // FIXME: not very robust size check, but should work. :)
 396                                 if ( $build === false ) {
 397                                         $build = $line;
 398                                 } elseif ( strlen( $build ) + strlen( $line ) > $regexMax ) {
 399                                         $regexes .= $regexStart .
 400                                                 str_replace( '/', '\/', preg_replace( '|\\\*/|', '/', $build ) ) .
 401                                                 $regexEnd;
 402                                         $build = $line;
 403                                 } else {
 404                                         $build .= '|' . $line;
 405                                 }
 406                         }
 407                         if ( $build !== false ) {
 408                                 $regexes .= $regexStart .
 409                                         str_replace( '/', '\/', preg_replace( '|\\\*/|', '/', $build ) ) .
 410                                         $regexEnd;
 411                         }
 412                         return $regexes;
 413                 }
 414         }
 415
 416         /**
 417          * Load external links from the externallinks table
 418          * @param $title Title
 419          * @return Array
 420          */
 421         function getLinksFromTracker( $title ) {
 422                 $dbr = wfGetDB( DB_SLAVE );
 423                 $id = $title->getArticleID(); // should be zero queries
 424                 $res = $dbr->select( 'externallinks', array( 'el_to' ),
 425                         array( 'el_from' => $id ), __METHOD__ );
 426                 $links = array();
 427                 foreach ( $res as $row ) {
 428                         $links[] = $row->el_to;
 429                 }
 430                 return $links;
 431         }
 432
 433         /**
 434          * Backend function for confirmEdit() and confirmEditAPI()
 435          * @param $editPage EditPage
 436          * @param $newtext string
 437          * @param $section
 438          * @param $merged bool
 439          * @return bool false if the CAPTCHA is rejected, true otherwise
 440          */
 441         private function doConfirmEdit( $editPage, $newtext, $section, $merged = false ) {
 442                 global $wgRequest;
 443                 if ( $wgRequest->getVal( 'captchaid' ) ) {
 444                         $wgRequest->setVal( 'wpCaptchaId', $wgRequest->getVal( 'captchaid' ) );
 445                 }
 446                 if ( $wgRequest->getVal( 'captchaword' ) ) {
 447                         $wgRequest->setVal( 'wpCaptchaWord', $wgRequest->getVal( 'captchaword' ) );
 448                 }
 449                 if ( $this->shouldCheck( $editPage, $newtext, $section, $merged ) ) {
 450                         return $this->passCaptcha();
 451                 } else {
 452                         wfDebug( "ConfirmEdit: no need to show captcha.\n" );
 453                         return true;
 454                 }
 455         }
 456
 457         /**
 458          * The main callback run on edit attempts.
 459          * @param EditPage $editPage
 460          * @param string $newtext
 461          * @param string $section
 462          * @param bool $merged
 463          * @return bool true to continue saving, false to abort and show a captcha form
 464          */
 465         function confirmEdit( $editPage, $newtext, $section, $merged = false ) {
 466                 if ( defined( 'MW_API' ) ) {
 467                         # API mode
 468                         # The CAPTCHA was already checked and approved
 469                         return true;
 470                 }
 471                 if ( !$this->doConfirmEdit( $editPage, $newtext, $section, $merged ) ) {
 472                         $editPage->showEditForm( array( &$this, 'editCallback' ) );
 473                         return false;
 474                 }
 475                 return true;
 476         }
 477
 478         /**
 479          * A more efficient edit filter callback based on the text after section merging
 480          * @param EditPage $editPage
 481          * @param string $newtext
 482          * @return bool
 483          */
 484         function confirmEditMerged( $editPage, $newtext ) {
 485                 return $this->confirmEdit( $editPage, $newtext, false, true );
 486         }
 487
 488         function confirmEditAPI( $editPage, $newtext, &$resultArr ) {
 489                 if ( !$this->doConfirmEdit( $editPage, $newtext, false, false ) ) {
 490                         $this->addCaptchaAPI( $resultArr );
 491                         return false;
 492                 }
 493
 494                 return true;
 495         }
 496
 497         /**
 498          * Hook for user creation form submissions.
 499          * @param User $u
 500          * @param string $message
 501          * @return bool true to continue, false to abort user creation
 502          */
 503         function confirmUserCreate( $u, &$message ) {
 504                 global $wgCaptchaTriggers, $wgUser;
 505                 if ( $wgCaptchaTriggers['createaccount'] ) {
 506                         if ( $wgUser->isAllowed( 'skipcaptcha' ) ) {
 507                                 wfDebug( "ConfirmEdit: user group allows skipping captcha on account creation\n" );
 508                                 return true;
 509                         }
 510                         if ( $this->isIPWhitelisted() )
 511                                 return true;
 512
 513                         $this->trigger = "new account '" . $u->getName() . "'";
 514                         if ( !$this->passCaptcha() ) {
 515                                 $message = wfMessage( 'captcha-createaccount-fail' )->text();
 516                                 return false;
 517                         }
 518                 }
 519                 return true;
 520         }
 521
 522         /**
 523          * Hook for user login form submissions.
 524          * @param $u User
 525          * @param $pass
 526          * @param $retval
 527          * @return bool true to continue, false to abort user creation
 528          */
 529         function confirmUserLogin( $u, $pass, &$retval ) {
 530                 if ( $this->isBadLoginTriggered() ) {
 531                         if ( $this->isIPWhitelisted() )
 532                                 return true;
 533
 534                         $this->trigger = "post-badlogin login '" . $u->getName() . "'";
 535                         if ( !$this->passCaptcha() ) {
 536                                 // Emulate a bad-password return to confuse the shit out of attackers
 537                                 $retval = LoginForm::WRONG_PASS;
 538                                 return false;
 539                         }
 540                 }
 541                 return true;
 542         }
 543
 544         /**
 545          * Check the captcha on Special:EmailUser
 546          * @param $from MailAddress
 547          * @param $to MailAddress
 548          * @param $subject String
 549          * @param $text String
 550          * @param $error String reference
 551          * @return Bool true to continue saving, false to abort and show a captcha form
 552          */
 553         function confirmEmailUser( $from, $to, $subject, $text, &$error ) {
 554                 global $wgCaptchaTriggers, $wgUser;
 555                 if ( $wgCaptchaTriggers['sendemail'] ) {
 556                         if ( $wgUser->isAllowed( 'skipcaptcha' ) ) {
 557                                 wfDebug( "ConfirmEdit: user group allows skipping captcha on email sending\n" );
 558                                 return true;
 559                         }
 560                         if ( $this->isIPWhitelisted() )
 561                                 return true;
 562
 563                         if ( defined( 'MW_API' ) ) {
 564                                 # API mode
 565                                 # Asking for captchas in the API is really silly
 566                                 $error = wfMessage( 'captcha-disabledinapi' )->text();
 567                                 return false;
 568                         }
 569                         $this->trigger = "{$wgUser->getName()} sending email";
 570                         if ( !$this->passCaptcha() ) {
 571                                 $error = wfMessage( 'captcha-sendemail-fail' )->text();
 572                                 return false;
 573                         }
 574                 }
 575                 return true;
 576         }
 577
 578         /**
 579          * @param $module ApiBase
 580          * @param $params array
 581          * @return bool
 582          */
 583         public function APIGetAllowedParams( &$module, &$params ) {
 584                 if ( !$module instanceof ApiEditPage ) {
 585                         return true;
 586                 }
 587                 $params['captchaword'] = null;
 588                 $params['captchaid'] = null;
 589
 590                 return true;
 591         }
 592
 593         /**
 594          * @param $module ApiBase
 595          * @param $desc array
 596          * @return bool
 597          */
 598         public function APIGetParamDescription( &$module, &$desc ) {
 599                 if ( !$module instanceof ApiEditPage ) {
 600                         return true;
 601                 }
 602                 $desc['captchaid'] = 'CAPTCHA ID from previous request';
 603                 $desc['captchaword'] = 'Answer to the CAPTCHA';
 604
 605                 return true;
 606         }
 607
 608         /**
 609          * Given a required captcha run, test form input for correct
 610          * input on the open session.
 611          * @return bool if passed, false if failed or new session
 612          */
 613         function passCaptcha() {
 614                 $info = $this->retrieveCaptcha();
 615                 if ( $info ) {
 616                         global $wgRequest;
 617                         if ( $this->keyMatch( $wgRequest->getVal( 'wpCaptchaWord' ), $info ) ) {
 618                                 $this->log( "passed" );
 619                                 $this->clearCaptcha( $info );
 620                                 return true;
 621                         } else {
 622                                 $this->clearCaptcha( $info );
 623                                 $this->log( "bad form input" );
 624                                 return false;
 625                         }
 626                 } else {
 627                         $this->log( "new captcha session" );
 628                         return false;
 629                 }
 630         }
 631
 632         /**
 633          * Log the status and any triggering info for debugging or statistics
 634          * @param string $message
 635          */
 636         function log( $message ) {
 637                 wfDebugLog( 'captcha', 'ConfirmEdit: ' . $message . '; ' .  $this->trigger );
 638         }
 639
 640         /**
 641          * Generate a captcha session ID and save the info in PHP's session storage.
 642          * (Requires the user to have cookies enabled to get through the captcha.)
 643          *
 644          * A random ID is used so legit users can make edits in multiple tabs or
 645          * windows without being unnecessarily hobbled by a serial order requirement.
 646          * Pass the returned id value into the edit form as wpCaptchaId.
 647          *
 648          * @param array $info data to store
 649          * @return string captcha ID key
 650          */
 651         function storeCaptcha( $info ) {
 652                 if ( !isset( $info['index'] ) ) {
 653                         // Assign random index if we're not udpating
 654                         $info['index'] = strval( mt_rand() );
 655                 }
 656                 CaptchaStore::get()->store( $info['index'], $info );
 657                 return $info['index'];
 658         }
 659
 660         /**
 661          * Fetch this session's captcha info.
 662          * @return mixed array of info, or false if missing
 663          */
 664         function retrieveCaptcha() {
 665                 global $wgRequest;
 666                 $index = $wgRequest->getVal( 'wpCaptchaId' );
 667                 return CaptchaStore::get()->retrieve( $index );
 668         }
 669
 670         /**
 671          * Clear out existing captcha info from the session, to ensure
 672          * it can't be reused.
 673          */
 674         function clearCaptcha( $info ) {
 675                 CaptchaStore::get()->clear( $info['index'] );
 676         }
 677
 678         /**
 679          * Retrieve the current version of the page or section being edited...
 680          * @param EditPage $editPage
 681          * @param string $section
 682          * @return string
 683          * @access private
 684          */
 685         function loadText( $editPage, $section ) {
 686                 $rev = Revision::newFromTitle( $editPage->mTitle, false, Revision::READ_LATEST );
 687                 if ( is_null( $rev ) ) {
 688                         return "";
 689                 } else {
 690                         $text = $rev->getText();
 691                         if ( $section != '' ) {
 692                                 global $wgParser;
 693                                 return $wgParser->getSection( $text, $section );
 694                         } else {
 695                                 return $text;
 696                         }
 697                 }
 698         }
 699
 700         /**
 701          * Extract a list of all recognized HTTP links in the text.
 702          * @param $editpage EditPage
 703          * @param $text string
 704          * @return array of strings
 705          */
 706         function findLinks( &$editpage, $text ) {
 707                 global $wgParser, $wgUser;
 708
 709                 $options = new ParserOptions();
 710                 $text = $wgParser->preSaveTransform( $text, $editpage->mTitle, $wgUser, $options );
 711                 $out = $wgParser->parse( $text, $editpage->mTitle, $options );
 712
 713                 return array_keys( $out->getExternalLinks() );
 714         }
 715
 716         /**
 717          * Show a page explaining what this wacky thing is.
 718          */
 719         function showHelp() {
 720                 global $wgOut;
 721                 $wgOut->setPageTitle( wfMessage( 'captchahelp-title' )->text() );
 722                 $wgOut->addWikiMsg( 'captchahelp-text' );
 723                 if ( CaptchaStore::get()->cookiesNeeded() ) {
 724                         $wgOut->addWikiMsg( 'captchahelp-cookies-needed' );
 725                 }
 726         }
 727 }