class.ilWACToken.php

Go to the documentation of this file.

<?php
// declare(strict_types=1);
 
require_once('class.ilWACSignedPath.php');
 
class ilWACToken
{
    const SALT_FILE_PATH = './data/wacsalt.php';
    protected static $SALT = '';
    protected $session_id = '';
    protected $timestamp = 0;
    protected $ip = '';
    protected $token = '';
    protected $raw_token = '';
    protected $path = '';
    protected $id = '';
    protected $client = '';
    protected $ttl = 0;
 
 
    public function __construct($path, $client, $timestamp = 0, $ttl = 0)
    {
        assert(is_string($path));
        assert(is_string($client));
        assert(is_int($timestamp));
        assert(is_int($ttl));
        $this->setClient($client);
        $this->setPath($path);
        $session_id = session_id();
        $this->setSessionId($session_id ? $session_id : '-');
        if (isset($_SERVER['REMOTE_ADDR'])) {
            $this->setIp($_SERVER['REMOTE_ADDR']);
        }
        $this->setTimestamp($timestamp !== 0 ? $timestamp : time());
        $ttl = $ttl !== 0 ? $ttl : ilWACSignedPath::getTokenMaxLifetimeInSeconds();
        $this->setTTL($ttl); //  since we do not know the type at this poit we choose the shorter duration for security reasons
        $this->generateToken();
        $this->setId($this->getPath());
    }
 
 
    public function generateToken()
    {
        $this->initSalt();
        $token = implode('-', array(
            self::getSALT(),
            $this->getClient(),
            $this->getTimestamp(),
            $this->getTTL(),
        ));
        $this->setRawToken($token);
        $token = sha1($token);
        $this->setToken($token);
    }
 
 
    protected function initSalt()
    {
        if (self::getSALT()) {
            return;
        }
        $salt = '';
        if (is_file(self::SALT_FILE_PATH)) {
            require self::SALT_FILE_PATH;
            self::setSALT($salt);
        }
 
        if (strcmp($salt, '') === 0) {
            $this->generateSaltFile();
            $this->initSalt();
        }
    }
 
 
    protected function generateSaltFile()
    {
        if (is_file(self::SALT_FILE_PATH)) {
            unlink(self::SALT_FILE_PATH);
        }
        $template = file_get_contents('./Services/WebAccessChecker/wacsalt.php.template');
        $random = new \ilRandom();
        $salt = md5(time() * $random->int(1000, 9999) . self::SALT_FILE_PATH);
        self::setSALT($salt);
        $template = str_replace('INSERT_SALT', $salt, $template);
        if (is_writable(dirname(self::SALT_FILE_PATH))) {
            file_put_contents(self::SALT_FILE_PATH, $template);
        } else {
            throw new ilWACException(ilWACException::DATA_DIR_NON_WRITEABLE, self::SALT_FILE_PATH);
        }
    }
 
 
    public function getSessionId()
    {
        return (string) $this->session_id;
    }
 
 
    public function setSessionId($session_id)
    {
        assert(is_string($session_id));
        $this->session_id = $session_id;
    }
 
 
    public function getTimestamp()
    {
        return (int) $this->timestamp;
    }
 
 
    public function setTimestamp($timestamp)
    {
        assert(is_int($timestamp));
        $this->timestamp = $timestamp;
    }
 
 
    public function getIp()
    {
        return (string) $this->ip;
    }
 
 
    public function setIp($ip)
    {
        assert(is_string($ip));
        $this->ip = $ip;
    }
 
 
    public function getToken()
    {
        return (string) $this->token;
    }
 
 
    public function setToken($token)
    {
        assert(is_string($token));
        $this->token = $token;
    }
 
 
    public function getPath()
    {
        return (string) $this->path;
    }
 
 
    public function setPath($path)
    {
        assert(is_string($path));
        $this->path = $path;
    }
 
 
    public function getId()
    {
        return (string) $this->id;
    }
 
 
    public function getHashedId()
    {
        return (string) md5($this->id);
    }
 
 
    public function setId($id)
    {
        assert(is_string($id));
        $this->id = $id;
    }
 
 
    public static function getSALT()
    {
        return (string) self::$SALT;
    }
 
 
    public static function setSALT($salt)
    {
        assert(is_string($salt));
        self::$SALT = $salt;
    }
 
 
    public function getClient()
    {
        return (string) $this->client;
    }
 
 
    public function setClient($client)
    {
        assert(is_string($client));
        $this->client = $client;
    }
 
 
    public function getTTL()
    {
        return (int) $this->ttl;
    }
 
 
    public function setTTL($ttl)
    {
        assert(is_int($ttl));
        $this->ttl = $ttl;
    }
 
 
    public function getRawToken()
    {
        return (string) $this->raw_token;
    }
 
 
    public function setRawToken($raw_token)
    {
        assert(is_string($raw_token));
        $this->raw_token = $raw_token;
    }
}