Licit

                $salt = \CO\SYSTEM\CONFIG_TABLE\ITEM\TEXT::get('salt');
            } catch (\Exception $exc) {
                $salt = GENERATOR::random(10, false, GENERATOR\CHARSET::STRONG);
                throw new \Exception("CRYPT: nincs beállítva salt");
            }
        }
        $key = hash('SHA256', $salt . $password, true);
        $cipher = 'aes-256-cbc';
        if (!in_array($cipher, openssl_get_cipher_methods())) {
            throw new \Exception("COCRYPT: $cipher chiper nem elérhető");
        }
        $c = base64_decode($encrypted);
        $ivlen = openssl_cipher_iv_length($cipher);
        $iv = substr($c, 0, $ivlen);
        $hmac = substr($c, $ivlen, $sha2len = 32);
        $ciphertext_raw = substr($c, $ivlen + $sha2len);
        if ($ciphertext_raw === false) {
            throw new \Exception();
        }
        $original_plaintext = openssl_decrypt($ciphertext_raw, $cipher, $key, OPENSSL_RAW_DATA, $iv);
        $calcmac = hash_hmac('sha256', $ciphertext_raw, $key, $as_binary = true);


        if (hash_equals($hmac, $calcmac)) {//PHP 5.6+ timing attack safe comparison
            return unserialize($original_plaintext);
        } else {
            throw new \Exception();
        }
    }

}

            $t = $this->getException()
                      ->getTrace()
            ;
            if (isset($t[0]) and isset($t[0]['args']) and isset($t[0]['args'][4])) {
                $this->addDataTable('registered variables', $t[0]['args'][4]);
            }
            $dd = array();
            foreach ($_REQUEST as $k => $v) {
                if (\CO\SYSTEM\DB::getInstance() == NULL) {
                    break;
                }
                try {
                    $decrypted = \CO\SYSTEM\CRYPT::decryptLocal($v);
                    $dd[$k] = array('encrypted' => $v, 'descrypted' => $decrypted);
                } catch (\Exception $e) {
//                    var_dump($e->getMessage());
//                    die;
                }
                try {
                    $decrypted = \CO\SYSTEM\CRYPT::decrypt($v);
                    $dd[$k] = array('encrypted' => $v, 'descrypted' => $decrypted);
                } catch (\Exception $e) {
//                    var_dump($e->getMessage());
                }
            }
            if (count($dd)) {
                $this->addDataTable('encrypted variables', $dd);
            }
//            foreach ($t[0]['args'][4] as $k => $v) {
//                $this->addDataTable('registered variables', $t[0]['args'][4]);
//            }
        }
        if (gettype($_POST) == 'object') {
            $_POST = json_decode(json_encode($_POST), true);
        }
//        var_dump(gettype($_POST)); die;
        parent::handle();
        $output = ob_get_clean();
        if (\CO\SYSTEM\DEV::getShowError() == false and \CO\SYSTEM\ERROR::showErrorAnyway() == false) {
            if (\CO\SYSTEM\DB::getInstance()) {

        // Capture output produced while handling the exception,
        // we might want to send it straight away to the client,
        // or return it silently.
        $this->system->startOutputBuffering();
        
        // Just in case there are no handlers:
        $handlerResponse = null;
        $handlerContentType = null;
 
        try {
            foreach ($this->handlerQueue as $handler) {
                $handler->setRun($this);
                $handler->setInspector($inspector);
                $handler->setException($exception);
 
                // The HandlerInterface does not require an Exception passed to handle()
                // and neither of our bundled handlers use it.
                // However, 3rd party handlers may have already relied on this parameter,
                // and removing it would be possibly breaking for users.
                $handlerResponse = $handler->handle($exception);
 
                // Collect the content type for possible sending in the headers.
                $handlerContentType = method_exists($handler, 'contentType') ? $handler->contentType() : null;
 
                if (in_array($handlerResponse, [Handler::LAST_HANDLER, Handler::QUIT])) {
                    // The Handler has handled the exception in some way, and
                    // wishes to quit execution (Handler::QUIT), or skip any
                    // other handlers (Handler::LAST_HANDLER). If $this->allowQuit
                    // is false, Handler::QUIT behaves like Handler::LAST_HANDLER
                    break;
                }
            }
 
            $willQuit = $handlerResponse == Handler::QUIT && $this->allowQuit();
        } finally {
            $output = $this->system->cleanOutputBuffer();
        }
 
        // If we're allowed to, send output generated by handlers directly
        // to the output, otherwise, and if the script doesn't quit, return

    public function handleError($level, $message, $file = null, $line = null)
    {
        if ($level & $this->system->getErrorReportingLevel()) {
            foreach ($this->silencedPatterns as $entry) {
                $pathMatches = (bool) preg_match($entry["pattern"], $file);
                $levelMatches = $level & $entry["levels"];
                if ($pathMatches && $levelMatches) {
                    // Ignore the error, abort handling
                    // See https://github.com/filp/whoops/issues/418
                    return true;
                }
            }
 
            // XXX we pass $level for the "code" param only for BC reasons.
            // see https://github.com/filp/whoops/issues/267
            $exception = new ErrorException($message, /*code*/ $level, /*severity*/ $level, $file, $line);
            if ($this->canThrowExceptions) {
                throw $exception;
            } else {
                $this->handleException($exception);
            }
            // Do not propagate errors which were already handled by Whoops.
            return true;
        }
 
        // Propagate error to the next handler, allows error_get_last() to
        // work on silenced errors.
        return false;
    }
 
    /**
     * Special case to deal with Fatal errors and the like.
     */
    public function handleShutdown()
    {
        // If we reached this step, we are in shutdown handler.
        // An exception thrown in a shutdown handler will not be propagated
        // to the exception handler. Pass that information along.
        $this->canThrowExceptions = false;
 

        // work on silenced errors.
        return false;
    }
 
    /**
     * Special case to deal with Fatal errors and the like.
     */
    public function handleShutdown()
    {
        // If we reached this step, we are in shutdown handler.
        // An exception thrown in a shutdown handler will not be propagated
        // to the exception handler. Pass that information along.
        $this->canThrowExceptions = false;
 
        $error = $this->system->getLastError();
        if ($error && Misc::isLevelFatal($error['type'])) {
            // If there was a fatal error,
            // it was not handled in handleError yet.
            $this->allowQuit = false;
            $this->handleError(
                $error['type'],
                $error['message'],
                $error['file'],
                $error['line']
            );
        }
    }
 
    /**
     * In certain scenarios, like in shutdown handler, we can not throw exceptions
     * @var bool
     */
    private $canThrowExceptions = true;
 
    /**
     * Echo something to the browser
     * @param  string $output
     * @return $this
     */
    private function writeToOutputNow($output)