includes/actions/RawAction.php

   1 <?php
   2 /**
   3  * Raw page text accessor
   4  *
   5  * Copyright © 2004 Gabriel Wicke <wicke@wikidev.net>
   6  * http://wikidev.net/
   7  *
   8  * Based on HistoryAction and SpecialExport
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; if not, write to the Free Software Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  23  * http://www.gnu.org/copyleft/gpl.html
  24  *
  25  * @author Gabriel Wicke <wicke@wikidev.net>
  26  * @file
  27  */
  28
  29 use MediaWiki\Logger\LoggerFactory;
  30
  31 /**
  32  * A simple method to retrieve the plain source of an article,
  33  * using "action=raw" in the GET request string.
  34  *
  35  * @ingroup Actions
  36  */
  37 class RawAction extends FormlessAction {
  38         public function getName() {
  39                 return 'raw';
  40         }
  41
  42         public function requiresWrite() {
  43                 return false;
  44         }
  45
  46         public function requiresUnblock() {
  47                 return false;
  48         }
  49
  50         function onView() {
  51                 $this->getOutput()->disable();
  52                 $request = $this->getRequest();
  53                 $response = $request->response();
  54                 $config = $this->context->getConfig();
  55
  56                 if ( !$request->checkUrlExtension() ) {
  57                         return;
  58                 }
  59
  60                 if ( $this->getOutput()->checkLastModified( $this->page->getTouched() ) ) {
  61                         return; // Client cache fresh and headers sent, nothing more to do.
  62                 }
  63
  64                 $contentType = $this->getContentType();
  65
  66                 $maxage = $request->getInt( 'maxage', $config->get( 'SquidMaxage' ) );
  67                 $smaxage = $request->getIntOrNull( 'smaxage' );
  68                 if ( $smaxage === null ) {
  69                         if (
  70                                 $contentType == 'text/css' ||
  71                                 $contentType == 'application/json' ||
  72                                 $contentType == 'text/javascript'
  73                         ) {
  74                                 // CSS/JSON/JS raw content has its own CDN max age configuration.
  75                                 // Note: Title::getCdnUrls() includes action=raw for css/json/js
  76                                 // pages, so if using the canonical url, this will get HTCP purges.
  77                                 $smaxage = intval( $config->get( 'ForcedRawSMaxage' ) );
  78                         } else {
  79                                 // No CDN cache for anything else
  80                                 $smaxage = 0;
  81                         }
  82                 }
  83
  84                 // Set standard Vary headers so cache varies on cookies and such (T125283)
  85                 $response->header( $this->getOutput()->getVaryHeader() );
  86                 if ( $config->get( 'UseKeyHeader' ) ) {
  87                         $response->header( $this->getOutput()->getKeyHeader() );
  88                 }
  89
  90                 // Output may contain user-specific data;
  91                 // vary generated content for open sessions on private wikis
  92                 $privateCache = !User::isEveryoneAllowed( 'read' ) &&
  93                         ( $smaxage == 0 || MediaWiki\Session\SessionManager::getGlobalSession()->isPersistent() );
  94                 // Don't accidentally cache cookies if user is logged in (T55032)
  95                 $privateCache = $privateCache || $this->getUser()->isLoggedIn();
  96                 $mode = $privateCache ? 'private' : 'public';
  97                 $response->header(
  98                         'Cache-Control: ' . $mode . ', s-maxage=' . $smaxage . ', max-age=' . $maxage
  99                 );
 100
 101                 // In the event of user JS, don't allow loading a user JS/CSS/Json
 102                 // subpage that has no registered user associated with, as
 103                 // someone could register the account and take control of the
 104                 // JS/CSS/Json page.
 105                 $title = $this->getTitle();
 106                 if ( $title->isUserConfigPage() && $contentType !== 'text/x-wiki' ) {
 107                         // not using getRootText() as we want this to work
 108                         // even if subpages are disabled.
 109                         $rootPage = strtok( $title->getText(), '/' );
 110                         $userFromTitle = User::newFromName( $rootPage, 'usable' );
 111                         if ( !$userFromTitle || $userFromTitle->getId() === 0 ) {
 112                                 $log = LoggerFactory::getInstance( "security" );
 113                                 $log->warning(
 114                                         "Unsafe JS/CSS/Json load - {user} loaded {title} with {ctype}",
 115                                         [
 116                                                 'user' => $this->getUser()->getName(),
 117                                                 'title' => $title->getPrefixedDBKey(),
 118                                                 'ctype' => $contentType,
 119                                         ]
 120                                 );
 121                                 $msg = wfMessage( 'unregistered-user-config' );
 122                                 throw new HttpError( 403, $msg );
 123                         }
 124                 }
 125
 126                 $response->header( 'Content-type: ' . $contentType . '; charset=UTF-8' );
 127
 128                 $text = $this->getRawText();
 129
 130                 // Don't return a 404 response for CSS or JavaScript;
 131                 // 404s aren't generally cached and it would create
 132                 // extra hits when user CSS/JS are on and the user doesn't
 133                 // have the pages.
 134                 if ( $text === false && $contentType == 'text/x-wiki' ) {
 135                         $response->statusHeader( 404 );
 136                 }
 137
 138                 // Avoid PHP 7.1 warning of passing $this by reference
 139                 $rawAction = $this;
 140                 if ( !Hooks::run( 'RawPageViewBeforeOutput', [ &$rawAction, &$text ] ) ) {
 141                         wfDebug( __METHOD__ . ": RawPageViewBeforeOutput hook broke raw page output.\n" );
 142                 }
 143
 144                 echo $text;
 145         }
 146
 147         /**
 148          * Get the text that should be returned, or false if the page or revision
 149          * was not found.
 150          *
 151          * @return string|bool
 152          */
 153         public function getRawText() {
 154                 global $wgParser;
 155
 156                 $text = false;
 157                 $title = $this->getTitle();
 158                 $request = $this->getRequest();
 159
 160                 // If it's a MediaWiki message we can just hit the message cache
 161                 if ( $request->getBool( 'usemsgcache' ) && $title->getNamespace() == NS_MEDIAWIKI ) {
 162                         // The first "true" is to use the database, the second is to use
 163                         // the content langue and the last one is to specify the message
 164                         // key already contains the language in it ("/de", etc.).
 165                         $text = MessageCache::singleton()->get( $title->getDBkey(), true, true, true );
 166                         // If the message doesn't exist, return a blank
 167                         if ( $text === false ) {
 168                                 $text = '';
 169                         }
 170                 } else {
 171                         // Get it from the DB
 172                         $rev = Revision::newFromTitle( $title, $this->getOldId() );
 173                         if ( $rev ) {
 174                                 $lastmod = wfTimestamp( TS_RFC2822, $rev->getTimestamp() );
 175                                 $request->response()->header( "Last-modified: $lastmod" );
 176
 177                                 // Public-only due to cache headers
 178                                 $content = $rev->getContent();
 179
 180                                 if ( $content === null ) {
 181                                         // revision not found (or suppressed)
 182                                         $text = false;
 183                                 } elseif ( !$content instanceof TextContent ) {
 184                                         // non-text content
 185                                         wfHttpError( 415, "Unsupported Media Type", "The requested page uses the content model `"
 186                                                 . $content->getModel() . "` which is not supported via this interface." );
 187                                         die();
 188                                 } else {
 189                                         // want a section?
 190                                         $section = $request->getIntOrNull( 'section' );
 191                                         if ( $section !== null ) {
 192                                                 $content = $content->getSection( $section );
 193                                         }
 194
 195                                         if ( $content === null || $content === false ) {
 196                                                 // section not found (or section not supported, e.g. for JS, JSON, and CSS)
 197                                                 $text = false;
 198                                         } else {
 199                                                 $text = $content->getNativeData();
 200                                         }
 201                                 }
 202                         }
 203                 }
 204
 205                 if ( $text !== false && $text !== '' && $request->getRawVal( 'templates' ) === 'expand' ) {
 206                         $text = $wgParser->preprocess(
 207                                 $text,
 208                                 $title,
 209                                 ParserOptions::newFromContext( $this->getContext() )
 210                         );
 211                 }
 212
 213                 return $text;
 214         }
 215
 216         /**
 217          * Get the ID of the revision that should used to get the text.
 218          *
 219          * @return int
 220          */
 221         public function getOldId() {
 222                 $oldid = $this->getRequest()->getInt( 'oldid' );
 223                 switch ( $this->getRequest()->getText( 'direction' ) ) {
 224                         case 'next':
 225                                 # output next revision, or nothing if there isn't one
 226                                 $nextid = 0;
 227                                 if ( $oldid ) {
 228                                         $nextid = $this->getTitle()->getNextRevisionID( $oldid );
 229                                 }
 230                                 $oldid = $nextid ?: -1;
 231                                 break;
 232                         case 'prev':
 233                                 # output previous revision, or nothing if there isn't one
 234                                 if ( !$oldid ) {
 235                                         # get the current revision so we can get the penultimate one
 236                                         $oldid = $this->page->getLatest();
 237                                 }
 238                                 $previd = $this->getTitle()->getPreviousRevisionID( $oldid );
 239                                 $oldid = $previd ?: -1;
 240                                 break;
 241                         case 'cur':
 242                                 $oldid = 0;
 243                                 break;
 244                 }
 245
 246                 return $oldid;
 247         }
 248
 249         /**
 250          * Get the content type to use for the response
 251          *
 252          * @return string
 253          */
 254         public function getContentType() {
 255                 // Use getRawVal instead of getVal because we only
 256                 // need to match against known strings, there is no
 257                 // storing of localised content or other user input.
 258                 $ctype = $this->getRequest()->getRawVal( 'ctype' );
 259
 260                 if ( $ctype == '' ) {
 261                         // Legacy compatibilty
 262                         $gen = $this->getRequest()->getRawVal( 'gen' );
 263                         if ( $gen == 'js' ) {
 264                                 $ctype = 'text/javascript';
 265                         } elseif ( $gen == 'css' ) {
 266                                 $ctype = 'text/css';
 267                         }
 268                 }
 269
 270                 $allowedCTypes = [
 271                         'text/x-wiki',
 272                         'text/javascript',
 273                         'text/css',
 274                         // FIXME: Should we still allow Zope editing? External editing feature was dropped
 275                         'application/x-zope-edit',
 276                         'application/json'
 277                 ];
 278                 if ( $ctype == '' || !in_array( $ctype, $allowedCTypes ) ) {
 279                         $ctype = 'text/x-wiki';
 280                 }
 281
 282                 return $ctype;
 283         }
 284 }