/lib/Cake/Controller/Component/SecurityComponent.php - pictcode - Redmine

pictcode / lib / Cake / Controller / Component / SecurityComponent.php @ master

       <?php
       /**
        * Security Component
+       *
        * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
        * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
+       *
        * Licensed under The MIT License
        * For full copyright and license information, please see the LICENSE.txt
        * Redistributions of files must retain the above copyright notice.
+       *
        * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
        * @link          http://cakephp.org CakePHP(tm) Project
        * @package       Cake.Controller.Component
        * @since         CakePHP(tm) v 0.10.8.2156
        * @license       http://www.opensource.org/licenses/mit-license.php MIT License
        */
       App::uses('Component', 'Controller');
       App::uses('CakeText', 'Utility');
       App::uses('Hash', 'Utility');
       App::uses('Security', 'Utility');
       /**
        * The Security Component creates an easy way to integrate tighter security in
        * your application. It provides methods for various tasks like:
+       *
        * - Restricting which HTTP methods your application accepts.
        * - CSRF protection.
        * - Form tampering protection
        * - Requiring that SSL be used.
        * - Limiting cross controller communication.
+       *
        * @package       Cake.Controller.Component
        * @link http://book.cakephp.org/2.0/en/core-libraries/components/security-component.html
        */
       class SecurityComponent extends Component {
       /**
        * The controller method that will be called if this request is black-hole'd
+       *
        * @var string
        */
               public $blackHoleCallback = null;
       /**
        * List of controller actions for which a POST request is required
+       *
        * @var array
        * @deprecated 3.0.0 Use CakeRequest::allowMethod() instead.
        * @see SecurityComponent::requirePost()
        */
               public $requirePost = array();
       /**
        * List of controller actions for which a GET request is required
+       *
        * @var array
        * @deprecated 3.0.0 Use CakeRequest::allowMethod() instead.
        * @see SecurityComponent::requireGet()
        */
               public $requireGet = array();
       /**
        * List of controller actions for which a PUT request is required
+       *
        * @var array
        * @deprecated 3.0.0 Use CakeRequest::allowMethod() instead.
        * @see SecurityComponent::requirePut()
        */
               public $requirePut = array();
       /**
        * List of controller actions for which a DELETE request is required
+       *
        * @var array
        * @deprecated 3.0.0 Use CakeRequest::allowMethod() instead.
        * @see SecurityComponent::requireDelete()
        */
               public $requireDelete = array();
       /**
        * List of actions that require an SSL-secured connection
+       *
        * @var array
        * @see SecurityComponent::requireSecure()
        */
               public $requireSecure = array();
       /**
        * List of actions that require a valid authentication key
+       *
        * @var array
        * @see SecurityComponent::requireAuth()
        */
               public $requireAuth = array();
       /**
        * Controllers from which actions of the current controller are allowed to receive
        * requests.
+       *
        * @var array
        * @see SecurityComponent::requireAuth()
        */
               public $allowedControllers = array();
       /**
        * Actions from which actions of the current controller are allowed to receive
        * requests.
+       *
        * @var array
        * @see SecurityComponent::requireAuth()
        */
               public $allowedActions = array();
       /**
        * Deprecated property, superseded by unlockedFields.
+       *
        * @var array
        * @deprecated 3.0.0 Superseded by unlockedFields.
        * @see SecurityComponent::$unlockedFields
        */
               public $disabledFields = array();
       /**
        * Form fields to exclude from POST validation. Fields can be unlocked
        * either in the Component, or with FormHelper::unlockField().
        * Fields that have been unlocked are not required to be part of the POST
        * and hidden unlocked fields do not have their values checked.
+       *
        * @var array
        */
               public $unlockedFields = array();
       /**
        * Actions to exclude from CSRF and POST validation checks.
        * Other checks like requireAuth(), requireSecure(),
        * requirePost(), requireGet() etc. will still be applied.
+       *
        * @var array
        */
               public $unlockedActions = array();
       /**
        * Whether to validate POST data. Set to false to disable for data coming from 3rd party
        * services, etc.
+       *
        * @var bool
        */
               public $validatePost = true;
       /**
        * Whether to use CSRF protected forms. Set to false to disable CSRF protection on forms.
+       *
        * @var bool
        * @see http://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF)
        * @see SecurityComponent::$csrfExpires
        */
               public $csrfCheck = true;
       /**
        * The duration from when a CSRF token is created that it will expire on.
        * Each form/page request will generate a new token that can only be submitted once unless
        * it expires. Can be any value compatible with strtotime()
+       *
        * @var string
        */
               public $csrfExpires = '+30 minutes';
       /**
        * Controls whether or not CSRF tokens are use and burn. Set to false to not generate
        * new tokens on each request. One token will be reused until it expires. This reduces
        * the chances of users getting invalid requests because of token consumption.
        * It has the side effect of making CSRF less secure, as tokens are reusable.
+       *
        * @var bool
        */
               public $csrfUseOnce = true;
       /**
        * Control the number of tokens a user can keep open.
        * This is most useful with one-time use tokens. Since new tokens
        * are created on each request, having a hard limit on the number of open tokens
        * can be useful in controlling the size of the session file.
+       *
        * When tokens are evicted, the oldest ones will be removed, as they are the most likely
        * to be dead/expired.
+       *
        * @var int
        */
               public $csrfLimit = 100;
       /**
        * Other components used by the Security component
+       *
        * @var array
        */
               public $components = array('Session');
       /**
        * Holds the current action of the controller
+       *
        * @var string
        */
               protected $_action = null;
       /**
        * Request object
+       *
        * @var CakeRequest
        */
               public $request;
       /**
        * Component startup. All security checking happens here.
+       *
        * @param Controller $controller Instantiating controller
        * @return void
        */
               public function startup(Controller $controller) {
                       $this->request = $controller->request;
                       $this->_action = $this->request->params['action'];
                       $this->_methodsRequired($controller);
                       $this->_secureRequired($controller);
                       $this->_authRequired($controller);
                       $hasData = !empty($this->request->data);
                       $isNotRequestAction = (
                               !isset($controller->request->params['requested']) ||
                               $controller->request->params['requested'] != 1
                       );
                       if ($this->_action === $this->blackHoleCallback) {
                               return $this->blackHole($controller, 'auth');
+                      }
                       if (!in_array($this->_action, (array)$this->unlockedActions) && $hasData && $isNotRequestAction) {
                               if ($this->validatePost && $this->_validatePost($controller) === false) {
                                       return $this->blackHole($controller, 'auth');
+                              }
                               if ($this->csrfCheck && $this->_validateCsrf($controller) === false) {
                                       return $this->blackHole($controller, 'csrf');
+                              }
+                      }
                       $this->generateToken($controller->request);
                       if ($hasData && is_array($controller->request->data)) {
                               unset($controller->request->data['_Token']);
+                      }
+              }
       /**
        * Sets the actions that require a POST request, or empty for all actions
+       *
        * @return void
        * @deprecated 3.0.0 Use CakeRequest::onlyAllow() instead.
        * @link http://book.cakephp.org/2.0/en/core-libraries/components/security-component.html#SecurityComponent::requirePost
        */
               public function requirePost() {
                       $args = func_get_args();
                       $this->_requireMethod('Post', $args);
+              }
       /**
        * Sets the actions that require a GET request, or empty for all actions
+       *
        * @deprecated 3.0.0 Use CakeRequest::onlyAllow() instead.
        * @return void
        */
               public function requireGet() {
                       $args = func_get_args();
                       $this->_requireMethod('Get', $args);
+              }
       /**
        * Sets the actions that require a PUT request, or empty for all actions
+       *
        * @deprecated 3.0.0 Use CakeRequest::onlyAllow() instead.
        * @return void
        */
               public function requirePut() {
                       $args = func_get_args();
                       $this->_requireMethod('Put', $args);
+              }
       /**
        * Sets the actions that require a DELETE request, or empty for all actions
+       *
        * @deprecated 3.0.0 Use CakeRequest::onlyAllow() instead.
        * @return void
        */
               public function requireDelete() {
                       $args = func_get_args();
                       $this->_requireMethod('Delete', $args);
+              }
       /**
        * Sets the actions that require a request that is SSL-secured, or empty for all actions
+       *
        * @return void
        * @link http://book.cakephp.org/2.0/en/core-libraries/components/security-component.html#SecurityComponent::requireSecure
        */
               public function requireSecure() {
                       $args = func_get_args();
                       $this->_requireMethod('Secure', $args);
+              }
       /**
        * Sets the actions that require whitelisted form submissions.
+       *
        * Adding actions with this method will enforce the restrictions
        * set in SecurityComponent::$allowedControllers and
        * SecurityComponent::$allowedActions.
+       *
        * @return void
        * @link http://book.cakephp.org/2.0/en/core-libraries/components/security-component.html#SecurityComponent::requireAuth
        */
               public function requireAuth() {
                       $args = func_get_args();
                       $this->_requireMethod('Auth', $args);
+              }
       /**
        * Black-hole an invalid request with a 400 error or custom callback. If SecurityComponent::$blackHoleCallback
        * is specified, it will use this callback by executing the method indicated in $error
+       *
        * @param Controller $controller Instantiating controller
        * @param string $error Error method
        * @return mixed If specified, controller blackHoleCallback's response, or no return otherwise
        * @see SecurityComponent::$blackHoleCallback
        * @link http://book.cakephp.org/2.0/en/core-libraries/components/security-component.html#handling-blackhole-callbacks
        * @throws BadRequestException
        */
               public function blackHole(Controller $controller, $error = '') {
                       if (!$this->blackHoleCallback) {
                               throw new BadRequestException(__d('cake_dev', 'The request has been black-holed'));
+                      }
                       return $this->_callback($controller, $this->blackHoleCallback, array($error));
+              }
       /**
        * Sets the actions that require a $method HTTP request, or empty for all actions
+       *
        * @param string $method The HTTP method to assign controller actions to
        * @param array $actions Controller actions to set the required HTTP method to.
        * @return void
        */
               protected function _requireMethod($method, $actions = array()) {
                       if (isset($actions[0]) && is_array($actions[0])) {
                               $actions = $actions[0];
+                      }
                       $this->{'require' . $method} = (empty($actions)) ? array('*') : $actions;
+              }
       /**
        * Check if HTTP methods are required
+       *
        * @param Controller $controller Instantiating controller
        * @return bool True if $method is required
        */
               protected function _methodsRequired(Controller $controller) {
                       foreach (array('Post', 'Get', 'Put', 'Delete') as $method) {
                               $property = 'require' . $method;
                               if (is_array($this->$property) && !empty($this->$property)) {
                                       $require = $this->$property;
                                       if (in_array($this->_action, $require) || $this->$property === array('*')) {
                                               if (!$this->request->is($method)) {
                                                       if (!$this->blackHole($controller, $method)) {
                                                               return false;
+                                                      }
+                                              }
+                                      }
+                              }
+                      }
                       return true;
+              }
       /**
        * Check if access requires secure connection
+       *
        * @param Controller $controller Instantiating controller
        * @return bool True if secure connection required
        */
               protected function _secureRequired(Controller $controller) {
                       if (is_array($this->requireSecure) && !empty($this->requireSecure)) {
                               $requireSecure = $this->requireSecure;
                               if (in_array($this->_action, $requireSecure) || $this->requireSecure === array('*')) {
                                       if (!$this->request->is('ssl')) {
                                               if (!$this->blackHole($controller, 'secure')) {
                                                       return false;
+                                              }
+                                      }
+                              }
+                      }
                       return true;
+              }
       /**
        * Check if authentication is required
+       *
        * @param Controller $controller Instantiating controller
        * @return bool|null True if authentication required
        */
               protected function _authRequired(Controller $controller) {
                       if (is_array($this->requireAuth) && !empty($this->requireAuth) && !empty($this->request->data)) {
                               $requireAuth = $this->requireAuth;
                               if (in_array($this->request->params['action'], $requireAuth) || $this->requireAuth === array('*')) {
                                       if (!isset($controller->request->data['_Token'])) {
                                               if (!$this->blackHole($controller, 'auth')) {
                                                       return null;
+                                              }
+                                      }
                                       if ($this->Session->check('_Token')) {
                                               $tData = $this->Session->read('_Token');
                                               if (!empty($tData['allowedControllers']) &&
                                                       !in_array($this->request->params['controller'], $tData['allowedControllers']) ||
                                                       !empty($tData['allowedActions']) &&
                                                       !in_array($this->request->params['action'], $tData['allowedActions'])
                                               ) {
                                                       if (!$this->blackHole($controller, 'auth')) {
                                                               return null;
+                                                      }
+                                              }
                                       } else {
                                               if (!$this->blackHole($controller, 'auth')) {
                                                       return null;
+                                              }
+                                      }
+                              }
+                      }
                       return true;
+              }
       /**
        * Validate submitted form
+       *
        * @param Controller $controller Instantiating controller
        * @return bool true if submitted form is valid
        */
               protected function _validatePost(Controller $controller) {
                       if (empty($controller->request->data)) {
                               return true;
+                      }
                       $data = $controller->request->data;
                       if (!isset($data['_Token']) || !isset($data['_Token']['fields']) || !isset($data['_Token']['unlocked'])) {
                               return false;
+                      }
                       $locked = '';
                       $check = $controller->request->data;
                       $token = urldecode($check['_Token']['fields']);
                       $unlocked = urldecode($check['_Token']['unlocked']);
                       if (strpos($token, ':')) {
                               list($token, $locked) = explode(':', $token, 2);
+                      }
                       unset($check['_Token']);
                       $locked = explode('|', $locked);
                       $unlocked = explode('|', $unlocked);
                       $lockedFields = array();
                       $fields = Hash::flatten($check);
                       $fieldList = array_keys($fields);
                       $multi = array();
                       foreach ($fieldList as $i => $key) {
                               if (preg_match('/(\.\d+){1,10}$/', $key)) {
                                       $multi[$i] = preg_replace('/(\.\d+){1,10}$/', '', $key);
                                       unset($fieldList[$i]);
+                              }
+                      }
                       if (!empty($multi)) {
                               $fieldList += array_unique($multi);
+                      }
                       $unlockedFields = array_unique(
                               array_merge((array)$this->disabledFields, (array)$this->unlockedFields, $unlocked)
                       );
                       foreach ($fieldList as $i => $key) {
                               $isLocked = (is_array($locked) && in_array($key, $locked));
                               if (!empty($unlockedFields)) {
                                       foreach ($unlockedFields as $off) {
                                               $off = explode('.', $off);
                                               $field = array_values(array_intersect(explode('.', $key), $off));
                                               $isUnlocked = ($field === $off);
                                               if ($isUnlocked) {
                                                       break;
+                                              }
+                                      }
+                              }
                               if ($isUnlocked || $isLocked) {
                                       unset($fieldList[$i]);
                                       if ($isLocked) {
                                               $lockedFields[$key] = $fields[$key];
+                                      }
+                              }
+                      }
                       sort($unlocked, SORT_STRING);
                       sort($fieldList, SORT_STRING);
                       ksort($lockedFields, SORT_STRING);
                       $fieldList += $lockedFields;
                       $unlocked = implode('|', $unlocked);
                       $hashParts = array(
                               $this->request->here(),
                               serialize($fieldList),
                               $unlocked,
                               Configure::read('Security.salt')
                       );
                       $check = Security::hash(implode('', $hashParts), 'sha1');
                       return ($token === $check);
+              }
       /**
        * Manually add CSRF token information into the provided request object.
+       *
        * @param CakeRequest $request The request object to add into.
        * @return bool
        */
               public function generateToken(CakeRequest $request) {
                       if (isset($request->params['requested']) && $request->params['requested'] === 1) {
                               if ($this->Session->check('_Token')) {
                                       $request->params['_Token'] = $this->Session->read('_Token');
+                              }
                               return false;
+                      }
                       $authKey = Security::generateAuthKey();
                       $token = array(
                               'key' => $authKey,
                               'allowedControllers' => $this->allowedControllers,
                               'allowedActions' => $this->allowedActions,
                               'unlockedFields' => array_merge($this->disabledFields, $this->unlockedFields),
                               'csrfTokens' => array()
                       );
                       $tokenData = array();
                       if ($this->Session->check('_Token')) {
                               $tokenData = $this->Session->read('_Token');
                               if (!empty($tokenData['csrfTokens']) && is_array($tokenData['csrfTokens'])) {
                                       $token['csrfTokens'] = $this->_expireTokens($tokenData['csrfTokens']);
+                              }
+                      }
                       if ($this->csrfUseOnce || empty($token['csrfTokens'])) {
                               $token['csrfTokens'][$authKey] = strtotime($this->csrfExpires);
+                      }
                       if (!$this->csrfUseOnce) {
                               $csrfTokens = array_keys($token['csrfTokens']);
                               $authKey = $csrfTokens[0];
                               $token['key'] = $authKey;
                               $token['csrfTokens'][$authKey] = strtotime($this->csrfExpires);
+                      }
                       $this->Session->write('_Token', $token);
                       $request->params['_Token'] = array(
                               'key' => $token['key'],
                               'unlockedFields' => $token['unlockedFields']
                       );
                       return true;
+              }
       /**
        * Validate that the controller has a CSRF token in the POST data
        * and that the token is legit/not expired. If the token is valid
        * it will be removed from the list of valid tokens.
+       *
        * @param Controller $controller A controller to check
        * @return bool Valid csrf token.
        */
               protected function _validateCsrf(Controller $controller) {
                       $token = $this->Session->read('_Token');
                       $requestToken = $controller->request->data('_Token.key');
                       if (isset($token['csrfTokens'][$requestToken]) && $token['csrfTokens'][$requestToken] >= time()) {
                               if ($this->csrfUseOnce) {
                                       $this->Session->delete('_Token.csrfTokens.' . $requestToken);
+                              }
                               return true;
+                      }
                       return false;
+              }
       /**
        * Expire CSRF nonces and remove them from the valid tokens.
        * Uses a simple timeout to expire the tokens.
+       *
        * @param array $tokens An array of nonce => expires.
        * @return array An array of nonce => expires.
        */
               protected function _expireTokens($tokens) {
                       $now = time();
                       foreach ($tokens as $nonce => $expires) {
                               if ($expires < $now) {
                                       unset($tokens[$nonce]);
+                              }
+                      }
                       $overflow = count($tokens) - $this->csrfLimit;
                       if ($overflow > 0) {
                               $tokens = array_slice($tokens, $overflow + 1, null, true);
+                      }
                       return $tokens;
+              }
       /**
        * Calls a controller callback method
+       *
        * @param Controller $controller Controller to run callback on
        * @param string $method Method to execute
        * @param array $params Parameters to send to method
        * @return mixed Controller callback method's response
        * @throws BadRequestException When a the blackholeCallback is not callable.
        */
               protected function _callback(Controller $controller, $method, $params = array()) {
                       if (!is_callable(array($controller, $method))) {
                               throw new BadRequestException(__d('cake_dev', 'The request has been black-holed'));
+                      }
                       return call_user_func_array(array(&$controller, $method), empty($params) ? null : $params);
+              }
+      }