libraries/classes/TwoFactor.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Two authentication factor handling
   5  *
   6  * @package PhpMyAdmin
   7  */
   8 declare(strict_types=1);
   9
  10 namespace PhpMyAdmin;
  11
  12 use PhpMyAdmin\Message;
  13 use PhpMyAdmin\Plugins\TwoFactor\Application;
  14 use PhpMyAdmin\Plugins\TwoFactor\Invalid;
  15 use PhpMyAdmin\Plugins\TwoFactor\Key;
  16 use PhpMyAdmin\Plugins\TwoFactorPlugin;
  17 use PhpMyAdmin\UserPreferences;
  18 use PragmaRX\Google2FAQRCode\Google2FA;
  19 use Samyoul\U2F\U2FServer\U2FServer;
  20
  21 /**
  22  * Two factor authentication wrapper class
  23  *
  24  * @package PhpMyAdmin
  25  */
  26 class TwoFactor
  27 {
  28     /**
  29      * @var string
  30      */
  31     public $user;
  32
  33     /**
  34      * @var array
  35      */
  36     public $config;
  37
  38     /**
  39      * @var boolean
  40      */
  41     protected $_writable;
  42
  43     /**
  44      * @var TwoFactorPlugin
  45      */
  46     protected $_backend;
  47
  48     /**
  49      * @var array
  50      */
  51     protected $_available;
  52
  53     /**
  54      * @var UserPreferences
  55      */
  56     private $userPreferences;
  57
  58     /**
  59      * Creates new TwoFactor object
  60      *
  61      * @param string $user User name
  62      */
  63     public function __construct($user)
  64     {
  65         $this->userPreferences = new UserPreferences();
  66         $this->user = $user;
  67         $this->_available = $this->getAvailable();
  68         $this->config = $this->readConfig();
  69         $this->_writable = ($this->config['type'] == 'db');
  70         $this->_backend = $this->getBackend();
  71     }
  72
  73     /**
  74      * Reads the configuration
  75      *
  76      * @return array
  77      */
  78     public function readConfig()
  79     {
  80         $result = [];
  81         $config = $this->userPreferences->load();
  82         if (isset($config['config_data']['2fa'])) {
  83             $result = $config['config_data']['2fa'];
  84         }
  85         $result['type'] = $config['type'];
  86         if (! isset($result['backend'])) {
  87             $result['backend'] = '';
  88         }
  89         if (! isset($result['settings'])) {
  90             $result['settings'] = [];
  91         }
  92         return $result;
  93     }
  94
  95     /**
  96      * Get any property of this class
  97      *
  98      * @param string $property name of the property
  99      *
 100      * @return mixed|void if property exist, value of the relevant property
 101      */
 102     public function __get($property)
 103     {
 104         switch ($property) {
 105             case 'backend':
 106                 return $this->_backend;
 107             case 'available':
 108                 return $this->_available;
 109             case 'writable':
 110                 return $this->_writable;
 111             case 'showSubmit':
 112                 $backend = $this->_backend;
 113                 return $backend::$showSubmit;
 114         }
 115     }
 116
 117     /**
 118      * Returns list of available backends
 119      *
 120      * @return array
 121      */
 122     public function getAvailable()
 123     {
 124         $result = [];
 125         if ($GLOBALS['cfg']['DBG']['simple2fa']) {
 126             $result[] = 'simple';
 127         }
 128         if (class_exists(Google2FA::class)) {
 129             $result[] = 'application';
 130         }
 131         if (class_exists(U2FServer::class)) {
 132             $result[] = 'key';
 133         }
 134         return $result;
 135     }
 136
 137     /**
 138      * Returns list of missing dependencies
 139      *
 140      * @return array
 141      */
 142     public function getMissingDeps()
 143     {
 144         $result = [];
 145         if (! class_exists(Google2FA::class)) {
 146             $result[] = [
 147                 'class' => Application::getName(),
 148                 'dep' => 'pragmarx/google2fa-qrcode',
 149             ];
 150         }
 151         if (! class_exists('BaconQrCode\Renderer\Image\Png')) {
 152             $result[] = [
 153                 'class' => Application::getName(),
 154                 'dep' => 'bacon/bacon-qr-code',
 155             ];
 156         }
 157         if (! class_exists(U2FServer::class)) {
 158             $result[] = [
 159                 'class' => Key::getName(),
 160                 'dep' => 'samyoul/u2f-php-server',
 161             ];
 162         }
 163         return $result;
 164     }
 165
 166     /**
 167      * Returns class name for given name
 168      *
 169      * @param string $name Backend name
 170      *
 171      * @return string
 172      */
 173     public function getBackendClass($name)
 174     {
 175         $result = TwoFactorPlugin::class;
 176         if (in_array($name, $this->_available)) {
 177             $result = 'PhpMyAdmin\\Plugins\\TwoFactor\\' . ucfirst($name);
 178         } elseif (! empty($name)) {
 179             $result = Invalid::class;
 180         }
 181         return $result;
 182     }
 183
 184     /**
 185      * Returns backend for current user
 186      *
 187      * @return TwoFactorPlugin
 188      */
 189     public function getBackend()
 190     {
 191         $name = $this->getBackendClass($this->config['backend']);
 192         return new $name($this);
 193     }
 194
 195     /**
 196      * Checks authentication, returns true on success
 197      *
 198      * @param boolean $skip_session Skip session cache
 199      *
 200      * @return boolean
 201      */
 202     public function check($skip_session = false)
 203     {
 204         if ($skip_session) {
 205             return $this->_backend->check();
 206         }
 207         if (empty($_SESSION['two_factor_check'])) {
 208             $_SESSION['two_factor_check'] = $this->_backend->check();
 209         }
 210         return $_SESSION['two_factor_check'];
 211     }
 212
 213     /**
 214      * Renders user interface to enter two-factor authentication
 215      *
 216      * @return string HTML code
 217      */
 218     public function render()
 219     {
 220         return $this->_backend->getError() . $this->_backend->render();
 221     }
 222
 223     /**
 224      * Renders user interface to configure two-factor authentication
 225      *
 226      * @return string HTML code
 227      */
 228     public function setup()
 229     {
 230         return $this->_backend->getError() . $this->_backend->setup();
 231     }
 232
 233     /**
 234      * Saves current configuration.
 235      *
 236      * @return true|Message
 237      */
 238     public function save()
 239     {
 240         return $this->userPreferences->persistOption('2fa', $this->config, null);
 241     }
 242
 243     /**
 244      * Changes two-factor authentication settings
 245      *
 246      * The object might stay in partialy changed setup
 247      * if configuration fails.
 248      *
 249      * @param string $name Backend name
 250      *
 251      * @return boolean
 252      */
 253     public function configure($name)
 254     {
 255         $this->config = [
 256             'backend' => $name,
 257         ];
 258         if ($name === '') {
 259             $cls = $this->getBackendClass($name);
 260             $this->config['settings'] = [];
 261             $this->_backend = new $cls($this);
 262         } else {
 263             if (! in_array($name, $this->_available)) {
 264                 return false;
 265             }
 266             $cls = $this->getBackendClass($name);
 267             $this->config['settings'] = [];
 268             $this->_backend = new $cls($this);
 269             if (! $this->_backend->configure()) {
 270                 return false;
 271             }
 272         }
 273         $result = $this->save();
 274         if ($result !== true) {
 275             $result->display();
 276         }
 277         return true;
 278     }
 279
 280     /**
 281      * Returns array with all available backends
 282      *
 283      * @return array
 284      */
 285     public function getAllBackends()
 286     {
 287         $all = array_merge([''], $this->available);
 288         $backends = [];
 289         foreach ($all as $name) {
 290             $cls = $this->getBackendClass($name);
 291             $backends[] = [
 292                 'id' => $cls::$id,
 293                 'name' => $cls::getName(),
 294                 'description' => $cls::getDescription(),
 295             ];
 296         }
 297         return $backends;
 298     }
 299 }