├── .github
    ├── FUNDING.yml
    ├── dependabot.yml
    └── workflows
    │   └── publish-to-redaxo-org.yml
├── .gitignore
├── .php_cs.dist
├── .travis.yml
├── LICENSE
├── README.md
├── assets
    ├── clipboard-copy-element.js
    ├── qrious.min.js
    └── qrious.min.js.map
├── boot.php
├── composer.json
├── composer.lock
├── fragments
    ├── 2fa.login.php
    ├── 2fa.setup-email.php
    └── 2fa.setup-totp.php
├── install.php
├── lang
    └── de_de.lang
├── lib
    ├── console
    │   └── 2factor_auth
    │   │   ├── enforce.php
    │   │   ├── status.php
    │   │   └── user.php
    ├── exception.php
    ├── method_email.php
    ├── method_interface.php
    ├── method_totp.php
    ├── one_time_password.php
    ├── one_time_password_config.php
    └── setup.php
├── package.yml
├── pages
    ├── index.php
    ├── settings.php
    ├── setup.php
    ├── users.php
    └── verify.php
├── uninstall.php
├── update.php
└── vendor
    ├── autoload.php
    ├── composer
        ├── ClassLoader.php
        ├── InstalledVersions.php
        ├── LICENSE
        ├── autoload_classmap.php
        ├── autoload_files.php
        ├── autoload_namespaces.php
        ├── autoload_psr4.php
        ├── autoload_real.php
        ├── autoload_static.php
        ├── installed.json
        ├── installed.php
        └── platform_check.php
    ├── paragonie
        └── constant_time_encoding
        │   ├── LICENSE.txt
        │   ├── README.md
        │   ├── composer.json
        │   └── src
        │       ├── Base32.php
        │       ├── Base32Hex.php
        │       ├── Base64.php
        │       ├── Base64DotSlash.php
        │       ├── Base64DotSlashOrdered.php
        │       ├── Base64UrlSafe.php
        │       ├── Binary.php
        │       ├── EncoderInterface.php
        │       ├── Encoding.php
        │       ├── Hex.php
        │       └── RFC4648.php
    ├── psr
        └── clock
        │   ├── CHANGELOG.md
        │   ├── LICENSE
        │   ├── README.md
        │   ├── composer.json
        │   └── src
        │       └── ClockInterface.php
    ├── spomky-labs
        └── otphp
        │   ├── LICENSE
        │   ├── README.md
        │   ├── SECURITY.md
        │   ├── composer.json
        │   └── src
        │       ├── Factory.php
        │       ├── FactoryInterface.php
        │       ├── HOTP.php
        │       ├── HOTPInterface.php
        │       ├── InternalClock.php
        │       ├── OTP.php
        │       ├── OTPInterface.php
        │       ├── ParameterTrait.php
        │       ├── TOTP.php
        │       ├── TOTPInterface.php
        │       └── Url.php
    └── symfony
        └── deprecation-contracts
            ├── CHANGELOG.md
            ├── LICENSE
            ├── README.md
            ├── composer.json
            └── function.php


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: [staabm]
2 | 


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | updates:
 3 | - package-ecosystem: composer
 4 |   directory: "/"
 5 |   schedule:
 6 |     interval: daily
 7 |   open-pull-requests-limit: 10
 8 |   ignore:
 9 |   - dependency-name: spomky-labs/otphp
10 |     versions:
11 |     - ">= 10.a, < 11"
12 | 


--------------------------------------------------------------------------------
/.github/workflows/publish-to-redaxo-org.yml:
--------------------------------------------------------------------------------
 1 | # Instructions: https://github.com/FriendsOfREDAXO/installer-action/
 2 | 
 3 | name: Publish to REDAXO.org
 4 | on:
 5 |   release:
 6 |     types:
 7 |       - published
 8 | 
 9 | jobs:
10 |   redaxo_publish:
11 |     runs-on: ubuntu-latest
12 |     steps:
13 |     - uses: actions/checkout@v3
14 |     - uses: FriendsOfREDAXO/installer-action@v1
15 |       with:
16 |         myredaxo-username: ${{ secrets.MYREDAXO_USERNAME }}
17 |         myredaxo-api-key: ${{ secrets.MYREDAXO_API_KEY }}
18 |         description: ${{ github.event.release.body }}
19 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | .php_cs.cache
3 | vendor/.DS_Store
4 | 


--------------------------------------------------------------------------------
/.php_cs.dist:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return PhpCsFixer\Config::create()
 4 |     ->setFinder(
 5 |         PhpCsFixer\Finder::create()
 6 |             ->in(__DIR__)
 7 |     )
 8 |     ->setUsingCache(true)
 9 |     ->setRiskyAllowed(true)
10 |     ->setRules([
11 |         '@Symfony' => true,
12 |         '@Symfony:risky' => true,
13 |         'array_indentation' => true,
14 |         'array_syntax' => ['syntax' => 'short'],
15 |         'blank_line_before_statement' => false,
16 |         'braces' => ['allow_single_line_closure' => false],
17 |         'concat_space' => false,
18 |         'function_to_constant' => ['functions' => ['get_class', 'get_called_class', 'php_sapi_name', 'phpversion', 'pi']],
19 |         'heredoc_to_nowdoc' => true,
20 |         'logical_operators' => true,
21 |         'native_constant_invocation' => false,
22 |         'no_blank_lines_after_phpdoc' => false,
23 |         'no_php4_constructor' => true,
24 |         'no_superfluous_elseif' => true,
25 |         'no_unneeded_final_method' => false,
26 |         'no_unreachable_default_argument_value' => true,
27 |         'no_useless_else' => true,
28 |         'no_useless_return' => true,
29 |         'phpdoc_annotation_without_dot' => false,
30 |         'phpdoc_no_package' => false,
31 |         'phpdoc_to_comment' => false,
32 |         'phpdoc_trim_consecutive_blank_line_separation' => true,
33 |         'phpdoc_var_without_name' => false,
34 |         'psr4' => false,
35 |         'semicolon_after_instruction' => false,
36 |         'space_after_semicolon' => true,
37 |         'string_line_ending' => true,
38 |         'yoda_style' => false,
39 |     ])
40 | ;
41 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |     - '7.1'
 5 | 
 6 | cache:
 7 |   directories:
 8 |   - $HOME/.composer/cache
 9 |   
10 | before_install:
11 |     - phpenv config-rm xdebug.ini || echo "xdebug not available"
12 |     
13 | script:
14 |     - composer require --dev friendsofredaxo/linter
15 |     - vendor/bin/rexlint
16 | 
17 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Friends Of REDAXO
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 2-Faktor-Authentifizierung
 2 | 
 3 | 2-Faktor-Authentifizierung mittels one-time-password (OTP).
 4 | Mit diesem Addon wird der Login in das REDAXO CMS durch einen zweiten Authentifizierungsweg abgesichert.
 5 | 
 6 | ![2-Faktor-Authentifizierung Weboberfläche](https://github.com/FriendsOfREDAXO/2factor_auth/blob/assets/screen.png?raw=true)
 7 | 
 8 | ## Einstellungen
 9 | 
10 | Der Administrator hat die Möglichkeit unter `Einstellungen` innerhalb des AddOns die 2-Faktor-Authentifizierung für die Benutzer zu erzwingen.
11 | Alternativ kann die 2-Faktor-Authentifizierung als Optional gehandhabt werden. Die Authentifizierungsoptionen können eingeschränkt werden, z.B. Ausschließlich E-Mail-Authentifizierung zu erlauben
12 | 
13 | ## Einrichtung Endbenutzer
14 | 
15 | Als Authentifikator-Apps stehen alle Apps zur Verfügung, die den OTP-Standard einhalten, zum Beispiel:
16 | 
17 | Umgebung                  | App                       | Hilfe
18 | ------------------------- |---------------------------| -----
19 | MacOS/Windows/Android/iOS | 1Password                 | Kurzanleitung: <https://support.1password.com/one-time-passwords/>
20 | MacOS native              | Native (ab Sequoia)       | Kurzanleitung weiter unten – "2-Faktor-Authentifizierung mit MacOS Bordmitteln"
21 | iOS                       | FreeOTP                   | App: <https://apps.apple.com/de/app/freeotp-authenticator/id872559395>, Kurzanleitung: <https://support.1password.com/one-time-passwords/>
22 | Android                   | FreeOTP                   | App: <https://play.google.com/store/apps/details?id=org.fedorahosted.freeotp>
23 | Android                   | Microsoft Authentificator | App: <https://play.google.com/store/apps/details?id=com.azure.authenticator&hl=de>
24 | iOS                       | Microsoft Authentificator | App: <https://apps.apple.com/de/app/microsoft-authenticator/id983156458>
25 | iOS                       | Google Authentificator    | App: <https://apps.apple.com/de/app/google-authenticator/id388497605>
26 | Android                   | Google Authentificator    | App: <https://play.google.com/store/apps/details?id=com.google.android.apps.authenticator2>
27 | Android                   | 2FAS Authenticator        | App: <https://play.google.com/store/apps/details?id=com.twofasapp>
28 | iOS                       | 2FAS Authenticator        | App: <https://apps.apple.com/us/app/2fas-auth/id1217793794>
29 | 
30 | Zunächst muss eine der Apps installiert sein, um die Einrichtung abzuschließen. Anschließend:
31 | 
32 | 1. Im REDAXO-Backend > `2-Faktor-Login` öffnen.
33 | 2. Die 2-Faktor-Einrichtung aktivieren. Es wird ein QR-Code dargestellt.
34 | 3. Den QR-Code in der Authentifikator-App einlesen. 
35 | 
36 | > Hinweis: Manche OTP-Apps benötigen den manuellen Modus. Hierbei gilt: Name = `Name der Website`; Benutzer = `REDAXO-Benutzername`; Secret = `Secret-Schlüssel`
37 | 
38 | Damit ist die Einrichtung abgeschlossen.
39 | 
40 | ## Verwendung
41 | 
42 | Nach der erfolgreichen Einrichtung wird jeder neue Login in das REDAXO-Backend durch ein zusätzliches, einmalig generiertes Passwort geschützt.
43 | 
44 | 1. Den REDAXO-Backend-Login aufrufen.
45 | 2. Mit den üblichen Zugangsdaten einloggen. Es wird nach dem einmaligen Zugangscode gefragt.
46 | 3. Die Authentifikator-App öffnen und den Zugangscode generieren lassen.
47 | 4. Diesen Code eingeben und fortfahren.
48 | 
49 | Anschließend ist man, wie gewohnt, im REDAXO-Backend eingeloggt.
50 | 
51 | ## 2-Faktor-Authentifizierung mit MacOS Bordmitteln
52 | 
53 | Seit macOS Sequoia lässt sich die 2-Faktor-Authentifizierung auch ohne Dritt-App einrichten.
54 | 
55 | 1. In Redaxo startet man die TOTP-Einrichtung mittels Button "TOTP Einrichtung starten (erfordert App; empfohlen)". Das zeigt einem dann einen QR-Code sowie darunter eine Textzeile an, die mit "otpauth://" beginnt.
56 | 3. Diese Zeile kopiert man in die Zwischenablage und wechselt zur Passwords App in macOS
57 | 4. Dort sucht man das bestehende Login zu dieser Website (oder erstellt ein Neues, wenn noch nie gespeichert) und klickt auf "Edit" (Dt. wahrscheinlich "Bearbeiten") oben rechts.
58 | 5. Dann klickt man "Setup Code..."
59 | 6. und fügt die Zwischenablage in das Feld "Setup Key".
60 | 7. Dann klickt man "Use Setup Key" und bekommt eine 6-stellige Nummer, welche man auf der Website in das Feld "2. OTP-Code eingeben um die Einrichtung abzuschliessen" einfügt und durch Bestätigen aktiviert.
61 | 
62 | ## Hinweise
63 | 
64 | Bei E-Mail OTP kann man das Zeitinterval für die Gültigkeit des OTP-Codes einstellen. Sollte es bereits Benutzer geben, die ein OTP eingerichtet haben, so gilt das neue Zeitinterval für diese nicht.
65 | 
66 | ## 💌 Give back some love
67 | 
68 | [Consider supporting the project](https://github.com/sponsors/staabm), so we can make this tool even better even faster for everyone.
69 | 
70 | ## Credits
71 | 
72 | **Markus Staab**  
73 | https://github.com/staabm 
74 | 
75 | **Jan Kristinus**  
76 | https://github.com/dergel
77 | 


--------------------------------------------------------------------------------
/assets/clipboard-copy-element.js:
--------------------------------------------------------------------------------
  1 | (function (global, factory) {
  2 |     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  3 |         typeof define === 'function' && define.amd ? define(factory) :
  4 |             (global = global || self, global.ClipboardCopyElement = factory());
  5 | }(this, function () { 'use strict';
  6 | 
  7 |     function createNode(text) {
  8 |         const node = document.createElement('pre');
  9 |         node.style.width = '1px';
 10 |         node.style.height = '1px';
 11 |         node.style.position = 'fixed';
 12 |         node.style.top = '5px';
 13 |         node.textContent = text;
 14 |         return node;
 15 |     }
 16 | 
 17 |     function copyNode(node) {
 18 |         if ('clipboard' in navigator) {
 19 |             // eslint-disable-next-line flowtype/no-flow-fix-me-comments
 20 |             // $FlowFixMe Clipboard is not defined in Flow yet.
 21 |             return navigator.clipboard.writeText(node.textContent);
 22 |         }
 23 | 
 24 |         const selection = getSelection();
 25 | 
 26 |         if (selection == null) {
 27 |             return Promise.reject(new Error());
 28 |         }
 29 | 
 30 |         selection.removeAllRanges();
 31 |         const range = document.createRange();
 32 |         range.selectNodeContents(node);
 33 |         selection.addRange(range);
 34 |         document.execCommand('copy');
 35 |         selection.removeAllRanges();
 36 |         return Promise.resolve();
 37 |     }
 38 |     function copyText(text) {
 39 |         if ('clipboard' in navigator) {
 40 |             // eslint-disable-next-line flowtype/no-flow-fix-me-comments
 41 |             // $FlowFixMe Clipboard is not defined in Flow yet.
 42 |             return navigator.clipboard.writeText(text);
 43 |         }
 44 | 
 45 |         const body = document.body;
 46 | 
 47 |         if (!body) {
 48 |             return Promise.reject(new Error());
 49 |         }
 50 | 
 51 |         const node = createNode(text);
 52 |         body.appendChild(node);
 53 |         copyNode(node);
 54 |         body.removeChild(node);
 55 |         return Promise.resolve();
 56 |     }
 57 | 
 58 |     function copy(button) {
 59 |         const id = button.getAttribute('for');
 60 |         const text = button.getAttribute('value');
 61 | 
 62 |         function trigger() {
 63 |             button.dispatchEvent(new CustomEvent('clipboard-copy', {
 64 |                 bubbles: true
 65 |             }));
 66 |         }
 67 | 
 68 |         if (text) {
 69 |             copyText(text).then(trigger);
 70 |         } else if (id) {
 71 |             const root = 'getRootNode' in Element.prototype ? button.getRootNode() : button.ownerDocument;
 72 |             if (!(root instanceof Document || 'ShadowRoot' in window && root instanceof ShadowRoot)) return;
 73 |             const node = root.getElementById(id);
 74 |             if (node) copyTarget(node).then(trigger);
 75 |         }
 76 |     }
 77 | 
 78 |     function copyTarget(content) {
 79 |         if (content instanceof HTMLInputElement || content instanceof HTMLTextAreaElement) {
 80 |             return copyText(content.value);
 81 |         } else if (content instanceof HTMLAnchorElement && content.hasAttribute('href')) {
 82 |             return copyText(content.href);
 83 |         } else {
 84 |             return copyNode(content);
 85 |         }
 86 |     }
 87 | 
 88 |     function clicked(event) {
 89 |         const button = event.currentTarget;
 90 | 
 91 |         if (button instanceof HTMLElement) {
 92 |             copy(button);
 93 |         }
 94 |     }
 95 | 
 96 |     function keydown(event) {
 97 |         if (event.key === ' ' || event.key === 'Enter') {
 98 |             const button = event.currentTarget;
 99 | 
100 |             if (button instanceof HTMLElement) {
101 |                 event.preventDefault();
102 |                 copy(button);
103 |             }
104 |         }
105 |     }
106 | 
107 |     function focused(event) {
108 |         event.currentTarget.addEventListener('keydown', keydown);
109 |     }
110 | 
111 |     function blurred(event) {
112 |         event.currentTarget.removeEventListener('keydown', keydown);
113 |     }
114 | 
115 |     class ClipboardCopyElement extends HTMLElement {
116 |         constructor() {
117 |             super();
118 |             this.addEventListener('click', clicked);
119 |             this.addEventListener('focus', focused);
120 |             this.addEventListener('blur', blurred);
121 |         }
122 | 
123 |         connectedCallback() {
124 |             if (!this.hasAttribute('tabindex')) {
125 |                 this.setAttribute('tabindex', '0');
126 |             }
127 | 
128 |             if (!this.hasAttribute('role')) {
129 |                 this.setAttribute('role', 'button');
130 |             }
131 |         }
132 | 
133 |         get value() {
134 |             return this.getAttribute('value') || '';
135 |         }
136 | 
137 |         set value(text) {
138 |             this.setAttribute('value', text);
139 |         }
140 | 
141 |     }
142 | 
143 |     if (!window.customElements.get('clipboard-copy')) {
144 |         window.ClipboardCopyElement = ClipboardCopyElement;
145 |         window.customElements.define('clipboard-copy', ClipboardCopyElement);
146 |     }
147 | 
148 |     return ClipboardCopyElement;
149 | 
150 | }));
151 | 


--------------------------------------------------------------------------------
/boot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use FriendsOfREDAXO\TwoFactorAuth\one_time_password;
 4 | 
 5 | $addon = rex_addon::get('2factor_auth');
 6 | 
 7 | if (rex::isBackend() && null !== rex::getUser()) {
 8 |     if ('2factor_auth' === rex_be_controller::getCurrentPagePart(1)) {
 9 |         rex_view::addJsFile($addon->getAssetsUrl('qrious.min.js'));
10 |         rex_view::addJsFile($addon->getAssetsUrl('clipboard-copy-element.js'));
11 |     }
12 | 
13 |     $otp = one_time_password::getInstance();
14 | 
15 |     // den benutzer auf das setup leiten, weil erwzungen aber noch nicht durchgefuehrt
16 |     if (!$otp->isEnabled()) {
17 |         if (one_time_password::ENFORCED_ALL === $otp->isEnforced()
18 |             || one_time_password::ENFORCED_ADMINS === $otp->isEnforced() && rex::getUser()->isAdmin()) {
19 |             rex_be_controller::setCurrentPage('2factor_auth/setup');
20 |             return;
21 |         }
22 |     }
23 | 
24 |     // den benutzer zur einmal passwort eingabe leiten, weil one-time-passwort aktiv
25 |     // und bisher fuer die session noch nicht eingegeben
26 |     if ($otp->isEnabled()) {
27 |         if (!$otp->isVerified()) {
28 |             rex_extension::register('PAGES_PREPARED', static function (rex_extension_point $ep) {
29 |                 $profilePage = rex_be_controller::getCurrentPageObject('profile');
30 |                 if (!$profilePage) {
31 |                     return;
32 |                 }
33 |                 $profilePage->setPath(rex_path::addon('2factor_auth', 'pages/verify.php'));
34 |                 $profilePage->setHasNavigation(false);
35 |                 $profilePage->setPjax(false);
36 |                 rex_extension::register('PAGE_BODY_ATTR', static function (rex_extension_point $ep) {
37 |                     $attributes = $ep->getSubject();
38 |                     /** add rex-page-login id */
39 |                     $attributes['id'] = ['rex-page-login'];
40 |                     $ep->setSubject($attributes);
41 |                 });
42 |             });
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
1 | {
2 |     "require": {
3 |         "php": ">=8.1",
4 |         "spomky-labs/otphp": "^11.0"
5 |     }
6 | }
7 | 


--------------------------------------------------------------------------------
/composer.lock:
--------------------------------------------------------------------------------
  1 | {
  2 |     "_readme": [
  3 |         "This file locks the dependencies of your project to a known state",
  4 |         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
  5 |         "This file is @generated automatically"
  6 |     ],
  7 |     "content-hash": "f88e09db1372a5f4287d6302714eab2b",
  8 |     "packages": [
  9 |         {
 10 |             "name": "paragonie/constant_time_encoding",
 11 |             "version": "v3.0.0",
 12 |             "source": {
 13 |                 "type": "git",
 14 |                 "url": "https://github.com/paragonie/constant_time_encoding.git",
 15 |                 "reference": "df1e7fde177501eee2037dd159cf04f5f301a512"
 16 |             },
 17 |             "dist": {
 18 |                 "type": "zip",
 19 |                 "url": "https://api.github.com/repos/paragonie/constant_time_encoding/zipball/df1e7fde177501eee2037dd159cf04f5f301a512",
 20 |                 "reference": "df1e7fde177501eee2037dd159cf04f5f301a512",
 21 |                 "shasum": ""
 22 |             },
 23 |             "require": {
 24 |                 "php": "^8"
 25 |             },
 26 |             "require-dev": {
 27 |                 "phpunit/phpunit": "^9",
 28 |                 "vimeo/psalm": "^4|^5"
 29 |             },
 30 |             "type": "library",
 31 |             "autoload": {
 32 |                 "psr-4": {
 33 |                     "ParagonIE\\ConstantTime\\": "src/"
 34 |                 }
 35 |             },
 36 |             "notification-url": "https://packagist.org/downloads/",
 37 |             "license": [
 38 |                 "MIT"
 39 |             ],
 40 |             "authors": [
 41 |                 {
 42 |                     "name": "Paragon Initiative Enterprises",
 43 |                     "email": "security@paragonie.com",
 44 |                     "homepage": "https://paragonie.com",
 45 |                     "role": "Maintainer"
 46 |                 },
 47 |                 {
 48 |                     "name": "Steve 'Sc00bz' Thomas",
 49 |                     "email": "steve@tobtu.com",
 50 |                     "homepage": "https://www.tobtu.com",
 51 |                     "role": "Original Developer"
 52 |                 }
 53 |             ],
 54 |             "description": "Constant-time Implementations of RFC 4648 Encoding (Base-64, Base-32, Base-16)",
 55 |             "keywords": [
 56 |                 "base16",
 57 |                 "base32",
 58 |                 "base32_decode",
 59 |                 "base32_encode",
 60 |                 "base64",
 61 |                 "base64_decode",
 62 |                 "base64_encode",
 63 |                 "bin2hex",
 64 |                 "encoding",
 65 |                 "hex",
 66 |                 "hex2bin",
 67 |                 "rfc4648"
 68 |             ],
 69 |             "support": {
 70 |                 "email": "info@paragonie.com",
 71 |                 "issues": "https://github.com/paragonie/constant_time_encoding/issues",
 72 |                 "source": "https://github.com/paragonie/constant_time_encoding"
 73 |             },
 74 |             "time": "2024-05-08T12:36:18+00:00"
 75 |         },
 76 |         {
 77 |             "name": "psr/clock",
 78 |             "version": "1.0.0",
 79 |             "source": {
 80 |                 "type": "git",
 81 |                 "url": "https://github.com/php-fig/clock.git",
 82 |                 "reference": "e41a24703d4560fd0acb709162f73b8adfc3aa0d"
 83 |             },
 84 |             "dist": {
 85 |                 "type": "zip",
 86 |                 "url": "https://api.github.com/repos/php-fig/clock/zipball/e41a24703d4560fd0acb709162f73b8adfc3aa0d",
 87 |                 "reference": "e41a24703d4560fd0acb709162f73b8adfc3aa0d",
 88 |                 "shasum": ""
 89 |             },
 90 |             "require": {
 91 |                 "php": "^7.0 || ^8.0"
 92 |             },
 93 |             "type": "library",
 94 |             "autoload": {
 95 |                 "psr-4": {
 96 |                     "Psr\\Clock\\": "src/"
 97 |                 }
 98 |             },
 99 |             "notification-url": "https://packagist.org/downloads/",
100 |             "license": [
101 |                 "MIT"
102 |             ],
103 |             "authors": [
104 |                 {
105 |                     "name": "PHP-FIG",
106 |                     "homepage": "https://www.php-fig.org/"
107 |                 }
108 |             ],
109 |             "description": "Common interface for reading the clock.",
110 |             "homepage": "https://github.com/php-fig/clock",
111 |             "keywords": [
112 |                 "clock",
113 |                 "now",
114 |                 "psr",
115 |                 "psr-20",
116 |                 "time"
117 |             ],
118 |             "support": {
119 |                 "issues": "https://github.com/php-fig/clock/issues",
120 |                 "source": "https://github.com/php-fig/clock/tree/1.0.0"
121 |             },
122 |             "time": "2022-11-25T14:36:26+00:00"
123 |         },
124 |         {
125 |             "name": "spomky-labs/otphp",
126 |             "version": "11.3.0",
127 |             "source": {
128 |                 "type": "git",
129 |                 "url": "https://github.com/Spomky-Labs/otphp.git",
130 |                 "reference": "2d8ccb5fc992b9cc65ef321fa4f00fefdb3f4b33"
131 |             },
132 |             "dist": {
133 |                 "type": "zip",
134 |                 "url": "https://api.github.com/repos/Spomky-Labs/otphp/zipball/2d8ccb5fc992b9cc65ef321fa4f00fefdb3f4b33",
135 |                 "reference": "2d8ccb5fc992b9cc65ef321fa4f00fefdb3f4b33",
136 |                 "shasum": ""
137 |             },
138 |             "require": {
139 |                 "ext-mbstring": "*",
140 |                 "paragonie/constant_time_encoding": "^2.0 || ^3.0",
141 |                 "php": ">=8.1",
142 |                 "psr/clock": "^1.0",
143 |                 "symfony/deprecation-contracts": "^3.2"
144 |             },
145 |             "require-dev": {
146 |                 "ekino/phpstan-banned-code": "^1.0",
147 |                 "infection/infection": "^0.26|^0.27|^0.28|^0.29",
148 |                 "php-parallel-lint/php-parallel-lint": "^1.3",
149 |                 "phpstan/phpstan": "^1.0",
150 |                 "phpstan/phpstan-deprecation-rules": "^1.0",
151 |                 "phpstan/phpstan-phpunit": "^1.0",
152 |                 "phpstan/phpstan-strict-rules": "^1.0",
153 |                 "phpunit/phpunit": "^9.5.26|^10.0|^11.0",
154 |                 "qossmic/deptrac-shim": "^1.0",
155 |                 "rector/rector": "^1.0",
156 |                 "symfony/phpunit-bridge": "^6.1|^7.0",
157 |                 "symplify/easy-coding-standard": "^12.0"
158 |             },
159 |             "type": "library",
160 |             "autoload": {
161 |                 "psr-4": {
162 |                     "OTPHP\\": "src/"
163 |                 }
164 |             },
165 |             "notification-url": "https://packagist.org/downloads/",
166 |             "license": [
167 |                 "MIT"
168 |             ],
169 |             "authors": [
170 |                 {
171 |                     "name": "Florent Morselli",
172 |                     "homepage": "https://github.com/Spomky"
173 |                 },
174 |                 {
175 |                     "name": "All contributors",
176 |                     "homepage": "https://github.com/Spomky-Labs/otphp/contributors"
177 |                 }
178 |             ],
179 |             "description": "A PHP library for generating one time passwords according to RFC 4226 (HOTP Algorithm) and the RFC 6238 (TOTP Algorithm) and compatible with Google Authenticator",
180 |             "homepage": "https://github.com/Spomky-Labs/otphp",
181 |             "keywords": [
182 |                 "FreeOTP",
183 |                 "RFC 4226",
184 |                 "RFC 6238",
185 |                 "google authenticator",
186 |                 "hotp",
187 |                 "otp",
188 |                 "totp"
189 |             ],
190 |             "support": {
191 |                 "issues": "https://github.com/Spomky-Labs/otphp/issues",
192 |                 "source": "https://github.com/Spomky-Labs/otphp/tree/11.3.0"
193 |             },
194 |             "funding": [
195 |                 {
196 |                     "url": "https://github.com/Spomky",
197 |                     "type": "github"
198 |                 },
199 |                 {
200 |                     "url": "https://www.patreon.com/FlorentMorselli",
201 |                     "type": "patreon"
202 |                 }
203 |             ],
204 |             "time": "2024-06-12T11:22:32+00:00"
205 |         },
206 |         {
207 |             "name": "symfony/deprecation-contracts",
208 |             "version": "v3.5.0",
209 |             "source": {
210 |                 "type": "git",
211 |                 "url": "https://github.com/symfony/deprecation-contracts.git",
212 |                 "reference": "0e0d29ce1f20deffb4ab1b016a7257c4f1e789a1"
213 |             },
214 |             "dist": {
215 |                 "type": "zip",
216 |                 "url": "https://api.github.com/repos/symfony/deprecation-contracts/zipball/0e0d29ce1f20deffb4ab1b016a7257c4f1e789a1",
217 |                 "reference": "0e0d29ce1f20deffb4ab1b016a7257c4f1e789a1",
218 |                 "shasum": ""
219 |             },
220 |             "require": {
221 |                 "php": ">=8.1"
222 |             },
223 |             "type": "library",
224 |             "extra": {
225 |                 "branch-alias": {
226 |                     "dev-main": "3.5-dev"
227 |                 },
228 |                 "thanks": {
229 |                     "name": "symfony/contracts",
230 |                     "url": "https://github.com/symfony/contracts"
231 |                 }
232 |             },
233 |             "autoload": {
234 |                 "files": [
235 |                     "function.php"
236 |                 ]
237 |             },
238 |             "notification-url": "https://packagist.org/downloads/",
239 |             "license": [
240 |                 "MIT"
241 |             ],
242 |             "authors": [
243 |                 {
244 |                     "name": "Nicolas Grekas",
245 |                     "email": "p@tchwork.com"
246 |                 },
247 |                 {
248 |                     "name": "Symfony Community",
249 |                     "homepage": "https://symfony.com/contributors"
250 |                 }
251 |             ],
252 |             "description": "A generic function and convention to trigger deprecation notices",
253 |             "homepage": "https://symfony.com",
254 |             "support": {
255 |                 "source": "https://github.com/symfony/deprecation-contracts/tree/v3.5.0"
256 |             },
257 |             "funding": [
258 |                 {
259 |                     "url": "https://symfony.com/sponsor",
260 |                     "type": "custom"
261 |                 },
262 |                 {
263 |                     "url": "https://github.com/fabpot",
264 |                     "type": "github"
265 |                 },
266 |                 {
267 |                     "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
268 |                     "type": "tidelift"
269 |                 }
270 |             ],
271 |             "time": "2024-04-18T09:32:20+00:00"
272 |         }
273 |     ],
274 |     "packages-dev": [],
275 |     "aliases": [],
276 |     "minimum-stability": "stable",
277 |     "stability-flags": [],
278 |     "prefer-stable": false,
279 |     "prefer-lowest": false,
280 |     "platform": {
281 |         "php": ">=8.1"
282 |     },
283 |     "platform-dev": [],
284 |     "plugin-api-version": "2.6.0"
285 | }
286 | 


--------------------------------------------------------------------------------
/fragments/2fa.login.php:
--------------------------------------------------------------------------------
 1 | <form id="rex-form-login" method="post" autocomplete="off">
 2 |     <input type="hidden" name="page" value="profile"/>
 3 |     <?php echo $this->csrfToken->getHiddenField(); ?>
 4 |     <section class="rex-page-section">
 5 |         <div class="panel panel-default">
 6 |             <div class="panel-body">
 7 |                 <?php
 8 |                 $fragment = new rex_fragment();
 9 |                 echo $fragment->parse('core/login_branding.php');
10 |                 ?>
11 | 
12 |                 <?php if ('' !== $this->info_messages) : ?>
13 |                 <div class="rex-js-login-message">
14 |                         <div class="alert alert-info">
15 |                             <?= $this->info_messages?>
16 |                         </div>
17 |                 </div>
18 |                 <?php endif; ?><?php if ('' !== $this->error_messages) : ?>
19 |                     <div class="rex-js-login-message">
20 |                         <div class="alert alert-danger">
21 |                             <?= $this->error_messages?>
22 |                         </div>
23 |                     </div>
24 |                 <?php endif; ?>
25 | 
26 |                 <fieldset>
27 |                     <input type="hidden" name="javascript" value="1" id="javascript">
28 |                     <dl class="rex-form-group form-group rex-form-group-vertical">
29 |                         <dt><label for="rex_login_otp"><?= rex_i18n::msg('2factor_auth_2fa_one_time_password') ?></label></dt>
30 |                         <dd>
31 |                             <div class="input-group">
32 |                                 <span class="input-group-addon">
33 |                                     <i class="rex-icon rex-icon-user-secret"></i>
34 |                                 </span>
35 |                                 <input class="form-control" type="text" value="" id="rex_login_otp" name="rex_login_otp" autofocus>
36 |                             </div>
37 |                         </dd>
38 |                     </dl>
39 |                 </fieldset>
40 |             </div>
41 |             <footer class="panel-footer">
42 |                 <div class="rex-form-panel-footer">
43 |                     <div class="btn-toolbar">
44 |                         <button class="btn btn-primary" type="submit">
45 |                             <i class="rex-icon rex-icon-sign-in"></i>
46 |                             <?= rex_i18n::msg('login') ?>
47 |                         </button>
48 |                         <a class="btn btn-link"
49 |                            href="<?php echo rex_url::backendController(['rex_logout' => 1] + rex_csrf_token::factory('backend_logout')->getUrlParams()); ?>">
50 |                             <i class="rex-icon rex-icon-sign-out"></i> <?php echo rex_i18n::msg('logout'); ?>
51 |                         </a>
52 |                     </div>
53 |                 </div>
54 |             </footer>
55 |         </div>
56 |     </section>
57 | </form>
58 | 
59 | <style>
60 |     #rex-js-page-main .rex-global-footer {
61 |         display: none;
62 |     }
63 | </style>
64 | 
65 | <?php
66 | $fragment = new rex_fragment();
67 | echo $fragment->parse('core/login_background.php');
68 | ?>
69 | 


--------------------------------------------------------------------------------
/fragments/2fa.setup-email.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | ?>
 3 | 
 4 | <?php if ($this->message) : ?>
 5 |     <?= $this->message ?>
 6 | <?php endif; ?>
 7 | 
 8 | <?php if (!$this->success) : ?>
 9 | <div class="panel panel-default">
10 |     <div class="panel-heading">
11 |         <h3 class="panel-title">2. <?= $this->addon->i18n('2fa_verify_headline') ?></h3>
12 |     </div>
13 |     <div class="panel-body">
14 |         <form method="post" action="./<?= rex_url::currentBackendPage() ?>">
15 |             <?php echo $this->csrfToken->getHiddenField(); ?>
16 |             <input type="hidden" name="func" value="verify-email" />
17 | 
18 |             <div class="form-group">
19 |                 <div class="input-group">
20 |                     Passwort versand an E-Mail aus dem Userprofil: <?php echo rex_escape(rex::requireUser()->getEmail()); ?>
21 |                 </div>
22 |                 <br />
23 |                 <div class="input-group">
24 |                     <input type="text" class="form-control" name="rex_login_otp" id="rex_login_otp">
25 |                     <div class="input-group-btn">
26 |                         <button type="submit" name="nbla" class="btn btn-primary">
27 |                             <i class="rex-icon fa-save"></i> <?= $this->addon->i18n('2fa_verify_action') ?>
28 |                         </button>
29 |                     </div>
30 |                 </div>
31 |             </div>
32 |         </form>
33 |     </div>
34 | </div>
35 | <?php endif; ?>
36 | 


--------------------------------------------------------------------------------
/fragments/2fa.setup-totp.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | ?>
 3 | 
 4 | <?php if ($this->message) : ?>
 5 |     <?= $this->message ?>
 6 | <?php endif; ?>
 7 | 
 8 | <?php if (!$this->success) : ?>
 9 |     <div class="row">
10 |         <div class="col-lg-6">
11 |             <div class="panel panel-default">
12 |                 <div class="panel-heading">
13 |                     <h3 class="panel-title">1. <?= $this->addon->i18n('2fa_setup_scan') ?></h3>
14 |                 </div>
15 |                 <div class="panel-body">
16 |                     <div class="form-group">
17 |                         <canvas id="qr-code"></canvas>
18 |                     </div>
19 |                     <div class="form-group">
20 |                         <div class="input-group">
21 |                             <input type="text" class="form-control" value="<?php echo $this->uri; ?>" id="2fa-uri" readonly>
22 |                             <div class="input-group-btn">
23 |                                 <clipboard-copy for="2fa-uri" class="btn btn-primary">
24 |                                     <i class="rex-icon fa-copy"></i> <?= $this->addon->i18n('copy') ?>
25 |                                 </clipboard-copy>
26 |                             </div>
27 |                         </div>
28 |                     </div>
29 |                     <div id="notice" hidden class="alert alert-success">Copied to clipboard</div>
30 |                 </div>
31 |             </div>
32 |         </div>
33 |         <div class="col-lg-6">
34 |             <div class="panel panel-default">
35 |                 <div class="panel-heading">
36 |                     <h3 class="panel-title">2. <?= $this->addon->i18n('2fa_verify_headline') ?></h3>
37 |                 </div>
38 |                 <div class="panel-body">
39 |                     <form method="post" action="./<?= rex_url::currentBackendPage() ?>">
40 |                         <?php echo $this->csrfToken->getHiddenField(); ?>
41 |                         <input type="hidden" name="func" value="verify-totp" />
42 |                         <div class="form-group">
43 |                             <div class="input-group">
44 |                                 <input type="text" class="form-control" name="rex_login_otp" id="rex_login_otp">
45 |                                 <div class="input-group-btn">
46 |                                     <button type="submit" name="nbla" class="btn btn-primary">
47 |                                         <i class="rex-icon fa-save"></i> <?= $this->addon->i18n('2fa_verify_action') ?>
48 |                                     </button>
49 |                                 </div>
50 |                             </div>
51 |                         </div>
52 |                     </form>
53 |                 </div>
54 |             </div>
55 |         </div>
56 |     </div>
57 | <?php endif; ?>
58 | 
59 | <style nonce="<?php echo rex_response::getNonce() ?>">
60 |     clipboard-copy {
61 |         border: 2px solid black;
62 |         cursor: default;
63 |     }
64 | </style>
65 | 
66 | <script nonce="<?php echo rex_response::getNonce() ?>">
67 |     new QRious({
68 |         element: document.getElementById("qr-code"),
69 |         value: document.getElementById("2fa-uri").value,
70 |         size: 300
71 |     });
72 | 
73 |     document.addEventListener('copy', function () {
74 |         const notice = document.getElementById('notice')
75 |         notice.hidden = false
76 |         setTimeout(function () {
77 |             notice.hidden = true
78 |         }, 1000)
79 |     })
80 | </script>
81 | 


--------------------------------------------------------------------------------
/install.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use FriendsOfREDAXO\TwoFactorAuth\setup;
 4 | 
 5 | if (!class_exists('FriendsOfREDAXO\TwoFactorAuth\setup')) {
 6 |     include_once rex_addon::get('2factor_auth')->getPath('/lib/setup.php');
 7 | }
 8 | 
 9 | rex_sql_table::get(rex::getTable('user'))
10 |     ->ensureColumn(new rex_sql_column('one_time_password_config', 'text'), 'revision')
11 |     ->ensureColumn(new rex_sql_column('one_time_password_tries', 'tinyint'), 'one_time_password_config')
12 |     ->ensureColumn(new rex_sql_column('one_time_password_lasttry', 'int'), 'one_time_password_tries')
13 | ->ensure();
14 | 
15 | setup::install();
16 | 


--------------------------------------------------------------------------------
/lang/de_de.lang:
--------------------------------------------------------------------------------
 1 | 2factor_auth = 2-Faktor-Login
 2 | 2factor_auth_setup = Einstellungen
 3 | 2factor_auth_readme = ReadMe
 4 | 2factor_auth_OTP-Verifizierung = OTP-Verifizierung
 5 | 2factor_auth_page_setup = 2-Faktor-Authentifizierung einrichten
 6 | 2factor_auth_2fa_enforced = 2-Faktor-Authentifizierung
 7 | 
 8 | 2factor_auth_2fa_active = 2-Faktor-Authentifizierung ist aktiviert.
 9 | 2factor_auth_2fa_inactive = 2-Faktor-Authentifizierung ist deaktiviert.
10 | 2factor_auth_2fa_disable = 2-Faktor-Authentifizierung für `{0}`deaktivieren
11 | 2factor_auth_2fa_disable_instruction = 2-Faktor-Authentifizierung für den aktuell angemeldeten Benutzer deaktivieren.
12 | 2factor_auth_2fa_setup = Einrichtung
13 | 2factor_auth_2fa_verify_instruction = Geben Sie einen OTP-Code ein, um sich einzuloggen.
14 | 2factor_auth_2fa_page_instruction = 2-Faktor-Authentifizierung für den aktuell angemeldeten Benutzer einrichten.
15 | 2factor_auth_2fa_setup_start_totp = TOTP Einrichtung starten (erfordert App; empfohlen)
16 | 2factor_auth_2fa_otp_wrong = Falsches one-time-password, bitte erneut versuchen
17 | 2factor_auth_2fa_setup_start_email = E-Mail basierte Einrichtung starten
18 | 2factor_auth_2fa_setup_start_email_required = Zunächst muss im Benutzerprofil eine gültige E-Mail Adresse hinterlegt werden.
19 | 2factor_auth_2fa_setup_start_phpmailer_required = Für die E-Mail Einrichtung ist das PHPMailer-AddOn erforderlich.
20 | 2factor_auth_2fa_setup_start_email_open_profile = zum Benutzerprofil
21 | 2factor_auth_2fa_setup_verify = Einstellungen verifizieren
22 | 2factor_auth_2fa_setup_scan = QR-Code scannen oder Code kopieren
23 | 2factor_auth_2fa_setup_successfull = 2-Faktor-Authentifizierung erfolgreich eingerichtet
24 | 2factor_auth_2fa_wrong_opt = Falsches one-time-password, bitte erneut versuchen
25 | 2factor_auth_2fa_verify_headline = OTP-Code eingeben, um die Einrichtung abzuschließen
26 | 2factor_auth_2fa_verify_action = Bestätigen
27 | 2factor_auth_2fa_one_time_password = Einmal-Passwort
28 | 2factor_auth_copy = Kopieren
29 | 2factor_auth_2fa_status_email_info = Aktuell ist eine E-Mail-2-Faktor-Authentifizierung für `{0} [{1}]` aktiviert.
30 | 2factor_auth_2fa_status_otp_info = Aktuell ist eine OTP-2-Faktor-Authentifizierung für {0} aktiviert.
31 | 
32 | 2factor_auth_2fa_page_totp_instruction = Bei einer TOTP-Authentifizierung wird eine gesonderte Applikation benötigt, z.B. auf einem immer verfügbaren Mobilgerät. Diese muss initial eingerichtet werden. Nach einem Login in REDAXO wird ein Code abgefragt, welcher dann in dieser Applikation eingesehen und eingetragen werden kann, um ins REDAXO Backend zu kommen.
33 | 2factor_auth_2fa_page_email_instruction = Bei einer E-Mail-Authentifizierung wird nach dem Login eine E-Mail an den entsprechenden User geschickt. Mit dem in der E-Mail mitgeschickten Code kommt man ins Backendsystem von REDAXO. Der User muss eine E-Mail im eigenen Profil eingetragen haben.
34 | 
35 | 2factor_auth_login = Authentifizierungs App starten und Code eingeben
36 | 2fa_setup_start_email_send = E-Mail wurde versendet
37 | 
38 | 2factor_auth_2fa_info_email_sent = Eine E-Mail mit dem Code wurde versendet
39 | 2factor_auth_2fa_info_email_enter_code = Bitte geben sie den Code aus der versendeten E-Mail ein.
40 | 2factor_auth_2fa_info_topt_enter_code = Bitte schauen sie in der Authenticator App nach dem passenden Code.
41 | 
42 | 2factor_auth_private_setup = Persönliches Setup
43 | 2factor_auth_config = Config
44 | 
45 | 2factor_auth_options = Optionen
46 | 2factor_auth_settings = Einstellungen
47 | 2factor_auth_enforce = Einschränkungen
48 | 
49 | 2factor_auth_enforce_all = Erzwungen für alle REDAXO-CMS Benutzer
50 | 2factor_auth_enforce_admins_only = Erzwungen nur für REDAXO-CMS Administratoren
51 | 2factor_auth_enforce_disabled = Keine Einschränkungen (Optional für jeden)
52 | 
53 | 2factor_auth_option_all = Alle Möglichkeiten erlauben
54 | 2factor_auth_option_totp_only = Nur Time-Based One-Time Passwort erlauben
55 | 2factor_auth_option_email_only = Nur One-Time Passwort über E-Mail erlauben
56 | 
57 | 2factor_auth_updated = Die Konfiguration wurde gespeichert
58 | 
59 | 2factor_auth_select_email_only = Nur 2-Faktor-Authentifizierung über E-Mail ist aktiviert
60 | 2factor_auth_select_email_only = Nur 2-Faktor-Authentifizierung über TOTP ist aktiviert
61 | 
62 | 2factor_auth_email_period = Zeitintervall bei E-Mail Authentifizierung
63 | minutes = Minuten
64 | 2factor_auth_users = Benutzer
65 | 
66 | 2factor_auth_totp_period = Zeitintervall bei Authentikatoren (nicht veränderbar)
67 | 2factor_auth_totp_period_info = {0} Sekunden
68 | 
69 | 2factor_auth_logintries = Anzahl der erlaubten Fehlversuche (nicht veränderbar)
70 | 2factor_auth_logintries_info = {0} Versuche
71 | 
72 | one_time_password_too_many_tries = Die maximale Anzahl von {1} Versuchen ist überschritten. Der Zugriff ist noch für <div id="otp_countdown">{0}</div> Sekunden geblockt. Jede erneute falsche Eingabe blockiert die Eingabe wieder für {2} Sekunden
73 | 
74 | 2factor_auth_mail_error = Bitte versuche es noch einmal oder kontaktiere den Administrator
75 | 2factor_auth_config_save = speichern
76 | 


--------------------------------------------------------------------------------
/lib/console/2factor_auth/enforce.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use FriendsOfREDAXO\TwoFactorAuth\one_time_password;
 4 | use Symfony\Component\Console\Input\InputInterface;
 5 | use Symfony\Component\Console\Input\InputOption;
 6 | use Symfony\Component\Console\Output\OutputInterface;
 7 | 
 8 | /**
 9 |  * @package redaxo\2factor_auth
10 |  *
11 |  * @internal
12 |  */
13 | class rex_command_2factor_auth_enforce extends rex_console_command
14 | {
15 |     protected function configure(): void
16 |     {
17 |         $this
18 |             ->setDescription('Enforce/Disable a 2factor_auth for users/admins or admins')
19 |             ->addOption('all', null, InputOption::VALUE_NONE, 'All')
20 |             ->addOption('admins', null, InputOption::VALUE_NONE, 'Admins only')
21 |             ->addOption('disable', 'd', InputOption::VALUE_NONE, 'Disable')
22 |         ;
23 |     }
24 | 
25 |     protected function execute(InputInterface $input, OutputInterface $output)
26 |     {
27 |         $io = $this->getStyle($input, $output);
28 | 
29 |         $all = $input->getOption('all');
30 |         $admins = $input->getOption('admins');
31 |         $disable = $input->getOption('disable');
32 | 
33 |         $opt = one_time_password::getInstance();
34 |         $status = '';
35 |         switch ($opt->isEnforced()) {
36 |             case one_time_password::ENFORCED_ALL:
37 |                 $status = 'all';
38 |                 break;
39 |             case one_time_password::ENFORCED_ADMINS:
40 |                 $status = 'admins';
41 |                 break;
42 |             case one_time_password::ENFORCED_DISABLED:
43 |                 $status = 'disabled';
44 |                 break;
45 |         }
46 | 
47 |         if ((!$all && !$admins && !$disable) || ($disable && ($all || $admins)) || ($all && $admins)) {
48 |             $io->info('Please decide: (--all) for all, (--admins) for admins or (--disable) without admin or all for disabling 2factor_auth enforcement.
49 | Current Status: ' . $status);
50 |             return 0;
51 |         }
52 | 
53 |         if ($all) {
54 |             $value = one_time_password::ENFORCED_ALL;
55 |             $io->success('2factor_auth is now enforced for all users');
56 |         } elseif ($admins) {
57 |             $value = one_time_password::ENFORCED_ADMINS;
58 |             $io->success('2factor_auth is now enforced for admins only');
59 |         } else {
60 |             $value = one_time_password::ENFORCED_DISABLED;
61 |             $io->success('Enforcement of 2factor_auth for all has been disabled');
62 |         }
63 |         $opt->enforce($value);
64 | 
65 |         return 0;
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/lib/console/2factor_auth/status.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use FriendsOfREDAXO\TwoFactorAuth\one_time_password;
 4 | use FriendsOfREDAXO\TwoFactorAuth\one_time_password_config;
 5 | use Symfony\Component\Console\Input\InputInterface;
 6 | use Symfony\Component\Console\Output\OutputInterface;
 7 | 
 8 | /**
 9 |  * @package redaxo\2factor_auth
10 |  *
11 |  * @internal
12 |  */
13 | class rex_command_2factor_auth_status extends rex_console_command
14 | {
15 |     protected function configure(): void
16 |     {
17 |         $this
18 |             ->setDescription('List of users with status info')
19 |         ;
20 |     }
21 | 
22 |     protected function execute(InputInterface $input, OutputInterface $output)
23 |     {
24 |         $io = $this->getStyle($input, $output);
25 | 
26 |         $opt = one_time_password::getInstance();
27 |         $status = '-';
28 |         switch ($opt->isEnforced()) {
29 |             case one_time_password::ENFORCED_ALL:
30 |                 $status = 'all';
31 |                 break;
32 |             case one_time_password::ENFORCED_ADMINS:
33 |                 $status = 'admins';
34 |                 break;
35 |             case one_time_password::ENFORCED_DISABLED:
36 |                 $status = 'nobody';
37 |                 break;
38 |         }
39 | 
40 |         $io->text('2Factor-Auth is mandatory for: <comment>' . $status . '</comment>');
41 |         $io->text('');
42 | 
43 |         $users = rex_sql::factory();
44 |         $users
45 |             ->setTable(rex::getTable('user'))
46 |             ->select();
47 | 
48 |         $userRows = [];
49 |         foreach ($users as $user) {
50 |             $user = rex_user::fromSql($user);
51 |             $config = one_time_password_config::forUser($user);
52 |             $userRows[] = [
53 |                 $user->getId(),
54 |                 $user->getLogin(),
55 |                 $config->enabled ? 'on' : 'off',
56 |                 $config->method,
57 |             ];
58 |         }
59 | 
60 |         $io->table([
61 |             'id',
62 |             'login',
63 |             'status',
64 |             'method',
65 |         ], $userRows);
66 | 
67 |         return 0;
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/lib/console/2factor_auth/user.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use FriendsOfREDAXO\TwoFactorAuth\one_time_password_config;
 4 | use Symfony\Component\Console\Exception\InvalidArgumentException;
 5 | use Symfony\Component\Console\Input\InputArgument;
 6 | use Symfony\Component\Console\Input\InputInterface;
 7 | use Symfony\Component\Console\Input\InputOption;
 8 | use Symfony\Component\Console\Output\OutputInterface;
 9 | 
10 | /**
11 |  * @package redaxo\2factor_auth
12 |  *
13 |  * @internal
14 |  */
15 | class rex_command_2factor_auth_user extends rex_console_command
16 | {
17 |     protected function configure(): void
18 |     {
19 |         $this
20 |             ->setDescription('Deaktivates a 2factor_auth for a user')
21 |             ->addArgument('user', InputArgument::REQUIRED, 'Username')
22 |             ->addOption('disable', 'd', InputOption::VALUE_NONE, 'Disable')
23 |             ->addOption('enable', 'e', InputOption::VALUE_NONE, 'Enable')
24 |         ;
25 |     }
26 | 
27 |     protected function execute(InputInterface $input, OutputInterface $output)
28 |     {
29 |         $io = $this->getStyle($input, $output);
30 | 
31 |         $username = $input->getArgument('user');
32 | 
33 |         $user = rex_sql::factory();
34 |         $user
35 |             ->setTable(rex::getTable('user'))
36 |             ->setWhere(['login' => $username])
37 |             ->select();
38 | 
39 |         if (1 != $user->getRows()) {
40 |             throw new InvalidArgumentException(sprintf('User "%s" does not exist.', $username));
41 |         }
42 | 
43 |         $user = rex_user::fromSql($user);
44 |         $config = one_time_password_config::forUser($user);
45 | 
46 |         $io->info(
47 |             'User found: ' . $user->getLogin() .
48 |             "\n" . 'Method: ' . $config->method .
49 |             "\n" . 'Status: ' . ($config->enabled ? 'enabled' : 'disabled'));
50 | 
51 |         $enable = $input->getOption('enable');
52 |         $disable = $input->getOption('disable');
53 | 
54 |         if ($enable && $disable) {
55 |             $io->warning('Please decide: (--enable) or (--disable) for disabling 2factor_auth');
56 |             return 0;
57 |         }
58 | 
59 |         if ($enable) {
60 |             $config->enable();
61 |             $io->success('2factor_auth for User `' . $user->getLogin() . '` has been enabled');
62 |         }
63 | 
64 |         if ($disable) {
65 |             $config->disable();
66 |             $io->success('2factor_auth for User `' . $user->getLogin() . '` has been disabled');
67 |         }
68 | 
69 |         return 0;
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/lib/exception.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace FriendsOfREDAXO\TwoFactorAuth;
4 | 
5 | use rex_exception;
6 | 
7 | class exception extends rex_exception {}
8 | 


--------------------------------------------------------------------------------
/lib/method_email.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace FriendsOfREDAXO\TwoFactorAuth;
 4 | 
 5 | use OTPHP\Factory;
 6 | use OTPHP\TOTP;
 7 | use rex;
 8 | use rex_addon;
 9 | use rex_i18n;
10 | use rex_mailer;
11 | use rex_user;
12 | 
13 | /**
14 |  * @internal
15 |  */
16 | final class method_email implements method_interface
17 | {
18 |     public function challenge(string $provisioningUrl, rex_user $user): void
19 |     {
20 |         $mail = new rex_mailer();
21 | 
22 |         $otp = Factory::loadFromProvisioningUri($provisioningUrl);
23 |         $otpCode = $otp->at(time());
24 | 
25 |         $mail->addAddress($user->getEmail());
26 |         $mail->Subject = '2FA-Code: ' . rex::getServerName() . ' (' . $_SERVER['HTTP_HOST'] . ')';
27 |         $mail->isHTML();
28 |         $mail->Body = '<style>body { font-size: 1.2em; text-align: center;}</style><h2>' . rex::getServerName() . ' Login verification</h2><br><h3><strong>' . $otpCode . '</strong></h3><br> is your 2 factor authentication code.';
29 |         $mail->AltBody = rex::getServerName() . " Login verification \r\n ------------------ \r\n" . $otpCode . "\r\n ------------------ \r\nis your 2 factor authentication code.";
30 |         if (!$mail->send()) {
31 |             throw new exception(rex_i18n::msg('2factor_auth_mail_error'));
32 |         }
33 |     }
34 | 
35 |     public static function getPeriod(): int
36 |     {
37 |         return (int) rex_addon::get('2factor_auth')->getConfig('email_period', 300);
38 |     }
39 | 
40 |     public static function getloginTries(): int
41 |     {
42 |         return 10;
43 |     }
44 | 
45 |     public function verify(string $provisioningUrl, string $otp): bool
46 |     {
47 |         $TOTP = Factory::loadFromProvisioningUri($provisioningUrl);
48 | 
49 |         // re-create from an existant uri
50 |         if ($TOTP->verify($otp)) {
51 |             return true;
52 |         }
53 | 
54 |         $lastOTPCode = $TOTP->at(time() - self::getPeriod());
55 |         if ($lastOTPCode == $otp) {
56 |             return Factory::loadFromProvisioningUri($provisioningUrl)->verify($TOTP->at(time()));
57 |         }
58 | 
59 |         // TODO: Secureproblem
60 |         // Unendliche Codeversuche im Moment möglich
61 | 
62 |         // - was mache ich bei mehreren Fehleingaben? Im Moment ist das unsicher
63 |         // - wie mache ich es, wenn es Änderungen bei den Einstellungen gibt?
64 |         //   - solle alle E-Mail provisionalURLs neu generiert werden
65 | 
66 |         //  gitlab - account wird gelockt nach 10 fehlversuchen
67 |         //  nach 10 minuten darf man dann wieder loslegen
68 | 
69 |         // rex_user
70 |         // lasttrydate
71 |         // lastlogin
72 |         //    backend_login_policy:
73 |         //      login_tries_until_blocked: 50
74 |         //      login_tries_until_delay: 3
75 |         //      relogin_delay: 5
76 | 
77 |         return false;
78 |     }
79 | 
80 |     public function getProvisioningUri(rex_user $user): string
81 |     {
82 |         // create a uri with a random secret
83 |         $otp = TOTP::create(null, self::getPeriod());
84 | 
85 |         // the label rendered in "Google Authenticator" or similar app
86 |         $label = $user->getLogin() . '@' . rex::getServerName() . ' (' . $_SERVER['HTTP_HOST'] . ')';
87 |         $label = str_replace(':', '_', $label); // colon is forbidden
88 |         $otp->setLabel($label);
89 |         $otp->setParameter('period', self::getPeriod());
90 |         $otp->setIssuer(str_replace(':', '_', $user->getLogin()));
91 | 
92 |         return $otp->getProvisioningUri();
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/lib/method_interface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace FriendsOfREDAXO\TwoFactorAuth;
 4 | 
 5 | use rex_user;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | interface method_interface
11 | {
12 |     /**
13 |      * @throws exception
14 |      */
15 |     public function challenge(string $provisioningUrl, rex_user $user): void;
16 | 
17 |     /**
18 |      * @throws exception
19 |      */
20 |     public function verify(string $provisioningUrl, string $otp): bool;
21 | 
22 |     public function getProvisioningUri(rex_user $user): string;
23 | 
24 |     public static function getPeriod(): int;
25 | 
26 |     public static function getloginTries();
27 | }
28 | 


--------------------------------------------------------------------------------
/lib/method_totp.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace FriendsOfREDAXO\TwoFactorAuth;
 4 | 
 5 | use OTPHP\Factory;
 6 | use OTPHP\TOTP;
 7 | use rex;
 8 | use rex_user;
 9 | 
10 | use function str_replace;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class method_totp implements method_interface
16 | {
17 |     public function challenge(string $provisioningUrl, rex_user $user): void
18 |     {
19 |         // nothing todo
20 |     }
21 | 
22 |     public function verify(string $provisioningUrl, string $otp): bool
23 |     {
24 |         // re-create from an existant uri
25 |         return Factory::loadFromProvisioningUri($provisioningUrl)->verify($otp);
26 |     }
27 | 
28 |     public static function getPeriod(): int
29 |     {
30 |         // default period is 30s and digest is sha1. Google Authenticator is restricted to this settings
31 |         return 30;
32 |     }
33 | 
34 |     public static function getloginTries(): int
35 |     {
36 |         return 10;
37 |     }
38 | 
39 |     public function getProvisioningUri(rex_user $user): string
40 |     {
41 |         // create a uri with a random secret
42 |         $otp = TOTP::create(null, self::getPeriod());
43 | 
44 |         // the label rendered in "Google Authenticator" or similar app
45 |         $label = $user->getLogin() . '@' . rex::getServerName() . ' (' . $_SERVER['HTTP_HOST'] . ')';
46 |         $label = str_replace(':', '_', $label); // colon is forbidden
47 |         $otp->setLabel($label);
48 |         $otp->setIssuer(str_replace(':', '_', $user->getLogin()));
49 | 
50 |         return $otp->getProvisioningUri();
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/lib/one_time_password.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace FriendsOfREDAXO\TwoFactorAuth;
  4 | 
  5 | use InvalidArgumentException;
  6 | use rex;
  7 | use rex_config;
  8 | use rex_singleton_trait;
  9 | 
 10 | /**
 11 |  * @internal
 12 |  */
 13 | final class one_time_password
 14 | {
 15 |     use rex_singleton_trait;
 16 | 
 17 |     public const ENFORCED_ALL = 'all';
 18 |     public const ENFORCED_ADMINS = 'admins_only';
 19 |     public const ENFORCED_DISABLED = 'disabled';
 20 | 
 21 |     public const OPTION_ALL = 'all';
 22 |     public const OPTION_TOTP = 'totp_only';
 23 |     public const OPTION_EMAIL = 'email_only';
 24 | 
 25 |     /** @var method_interface|null */
 26 |     private $method;
 27 | 
 28 |     /**
 29 |      * @return void
 30 |      */
 31 |     public function challenge()
 32 |     {
 33 |         $user = rex::getImpersonator() ?? rex::requireUser();
 34 | 
 35 |         $uri = str_replace('&amp;', '&', (string) one_time_password_config::forCurrentUser()->provisioningUri);
 36 | 
 37 |         $this->getMethod()->challenge($uri, $user);
 38 |     }
 39 | 
 40 |     /**
 41 |      * @param string $otp
 42 |      * @return bool
 43 |      */
 44 |     public function verify($otp)
 45 |     {
 46 |         $uri = str_replace('&amp;', '&', (string) one_time_password_config::forCurrentUser()->provisioningUri);
 47 | 
 48 |         $verified = $this->getMethod()->verify($uri, $otp);
 49 | 
 50 |         if ($verified) {
 51 |             rex_set_session('otp_verified', true);
 52 |         }
 53 | 
 54 |         return $verified;
 55 |     }
 56 | 
 57 |     /**
 58 |      * @return bool
 59 |      */
 60 |     public function isVerified()
 61 |     {
 62 |         return rex_session('otp_verified', 'boolean', false);
 63 |     }
 64 | 
 65 |     /**
 66 |      * @return bool
 67 |      */
 68 |     public function isEnabled()
 69 |     {
 70 |         return one_time_password_config::forCurrentUser()->enabled;
 71 |     }
 72 | 
 73 |     /**
 74 |      * @param self::ENFORCE* $enforce
 75 |      *
 76 |      * @return void
 77 |      */
 78 |     public function enforce($enforce)
 79 |     {
 80 |         rex_config::set('2factor_auth', 'enforce', $enforce);
 81 |     }
 82 | 
 83 |     /**
 84 |      * @return self::ENFORCE*
 85 |      */
 86 |     public function isEnforced()
 87 |     {
 88 |         return rex_config::get('2factor_auth', 'enforce', self::ENFORCED_DISABLED);
 89 |     }
 90 | 
 91 |     /**
 92 |      * @return self::OPTION*
 93 |      */
 94 |     public function getAuthOption()
 95 |     {
 96 |         return rex_config::get('2factor_auth', 'option', self::OPTION_ALL);
 97 |     }
 98 | 
 99 |     public function setAuthOption(string $option): void
100 |     {
101 |         rex_config::set('2factor_auth', 'option', $option);
102 |     }
103 | 
104 |     /**
105 |      * @return method_interface
106 |      */
107 |     public function getMethod()
108 |     {
109 |         if (null === $this->method) {
110 |             $methodType = one_time_password_config::forCurrentUser()->method;
111 | 
112 |             if ('totp' === $methodType) {
113 |                 $this->method = new method_totp();
114 |             } elseif ('email' === $methodType) {
115 |                 $this->method = new method_email();
116 |             } else {
117 |                 throw new InvalidArgumentException("Unknown method: $methodType");
118 |             }
119 |         }
120 | 
121 |         return $this->method;
122 |     }
123 | }
124 | 


--------------------------------------------------------------------------------
/lib/one_time_password_config.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace FriendsOfREDAXO\TwoFactorAuth;
  4 | 
  5 | use rex;
  6 | use rex_sql;
  7 | use rex_user;
  8 | 
  9 | use function array_key_exists;
 10 | use function is_array;
 11 | use function is_string;
 12 | 
 13 | /**
 14 |  * @internal
 15 |  */
 16 | final class one_time_password_config
 17 | {
 18 |     /** @var string|null */
 19 |     public $provisioningUri;
 20 |     /** @var bool */
 21 |     public $enabled = false;
 22 |     /** @var 'totp'|'email'|null */
 23 |     public $method;
 24 |     /** @var rex_user */
 25 |     public $user;
 26 | 
 27 |     public function __construct(rex_user $user)
 28 |     {
 29 |         $this->user = $user;
 30 |     }
 31 | 
 32 |     /**
 33 |      * @return self
 34 |      */
 35 |     public static function forCurrentUser()
 36 |     {
 37 |         return self::forUser(rex::getImpersonator() ?? rex::requireUser());
 38 |     }
 39 | 
 40 |     /**
 41 |      * @return self
 42 |      */
 43 |     public static function forUser(rex_user $user)
 44 |     {
 45 |         return self::fromJson($user->getValue('one_time_password_config'), $user);
 46 |     }
 47 | 
 48 |     public static function loadFromDb(method_interface $method, rex_user $user): self
 49 |     {
 50 |         // get non-cached values
 51 |         $userSql = rex_sql::factory();
 52 |         $userSql->setTable(rex::getTablePrefix() . 'user');
 53 |         $userSql->setWhere(['id' => $user->getId()]);
 54 |         $userSql->select();
 55 | 
 56 |         $json = (string) $userSql->getValue('one_time_password_config');
 57 |         $config = self::fromJson($json, $user);
 58 |         $config->init($method);
 59 |         return $config;
 60 |     }
 61 | 
 62 |     /**
 63 |      * @param string|null $json
 64 |      * @return self
 65 |      */
 66 |     private static function fromJson($json, rex_user $user)
 67 |     {
 68 |         if (is_string($json)) {
 69 |             $configArr = json_decode($json, true);
 70 | 
 71 |             if (is_array($configArr)) {
 72 |                 // compat with older versions, which did not yet define a method
 73 |                 if (!array_key_exists('method', $configArr)) {
 74 |                     $configArr['method'] = 'totp';
 75 |                 }
 76 | 
 77 |                 $config = new self($user);
 78 |                 $config->provisioningUri = $configArr['provisioningUri'];
 79 |                 $config->enabled = $configArr['enabled'];
 80 |                 $config->method = $configArr['method'];
 81 |                 return $config;
 82 |             }
 83 |         }
 84 | 
 85 |         $default = new self($user);
 86 |         $default->init(new method_totp());
 87 |         return $default;
 88 |     }
 89 | 
 90 |     /**
 91 |      * @return void
 92 |      */
 93 |     private function init(method_interface $method)
 94 |     {
 95 |         $this->method = $method instanceof method_email ? 'email' : 'totp';
 96 |         if (null === $this->provisioningUri) {
 97 |             $this->provisioningUri = $method->getProvisioningUri($this->user);
 98 |         }
 99 | 
100 |         $this->save();
101 |     }
102 | 
103 |     /**
104 |      * @return void
105 |      */
106 |     public function enable()
107 |     {
108 |         $this->enabled = true;
109 | 
110 |         if (null === $this->provisioningUri) {
111 |             throw new exception('Missing provisioning url');
112 |         }
113 |         if (null === $this->method) {
114 |             throw new exception('Missing method');
115 |         }
116 | 
117 |         $this->save();
118 |     }
119 | 
120 |     /**
121 |      * @return void
122 |      */
123 |     public function disable()
124 |     {
125 |         $this->enabled = false;
126 |         $this->provisioningUri = null;
127 | 
128 |         $this->save();
129 |     }
130 | 
131 |     /**
132 |      * @return void
133 |      */
134 |     public function updateMethod(method_interface $method)
135 |     {
136 |         $this->method = $method instanceof method_email ? 'email' : 'totp';
137 |         $this->provisioningUri = $method->getProvisioningUri($this->user);
138 |         $this->save();
139 |     }
140 | 
141 |     /**
142 |      * @return void
143 |      */
144 |     private function save()
145 |     {
146 |         $userSql = rex_sql::factory();
147 |         $userSql->setTable(rex::getTablePrefix() . 'user');
148 |         $userSql->setWhere(['id' => $this->user->getId()]);
149 |         $userSql->setValue('one_time_password_config', json_encode(
150 |             [
151 |                 'provisioningUri' => $this->provisioningUri,
152 |                 'method' => $this->method,
153 |                 'enabled' => $this->enabled,
154 |             ],
155 |         ));
156 |         $userSql->addGlobalUpdateFields();
157 |         $userSql->update();
158 |     }
159 | }
160 | 


--------------------------------------------------------------------------------
/lib/setup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace FriendsOfREDAXO\TwoFactorAuth;
 4 | 
 5 | use rex_file;
 6 | use rex_path;
 7 | use rex_string;
 8 | 
 9 | use function array_search;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | final class setup
15 | {
16 |     /**
17 |      * @return void
18 |      */
19 |     public static function install()
20 |     {
21 |         /** @var string $coreConfig */
22 |         $coreConfig = rex_file::get(rex_path::coreData('config.yml'));
23 |         $config = rex_string::yamlDecode($coreConfig);
24 | 
25 |         // add as setup_addon, to make sure 2factor runs in safe_mode.
26 |         // otherwise 2fa could be worked arround by a admin user.
27 |         $key = array_search('2factor_auth', $config['setup_addons'], true);
28 |         if (false === $key) {
29 |             $config['setup_addons'][] = '2factor_auth';
30 | 
31 |             rex_file::put(rex_path::coreData('config.yml'), rex_string::yamlEncode($config));
32 |         }
33 |     }
34 | 
35 |     /**
36 |      * @return void
37 |      */
38 |     public static function uninstall()
39 |     {
40 |         /** @var string $coreConfig */
41 |         $coreConfig = rex_file::get(rex_path::coreData('config.yml'));
42 |         $config = rex_string::yamlDecode($coreConfig);
43 | 
44 |         $key = array_search('2factor_auth', $config['setup_addons'], true);
45 |         if (false !== $key) {
46 |             unset($config['setup_addons'][$key]);
47 |             rex_file::put(rex_path::coreData('config.yml'), rex_string::yamlEncode($config));
48 |         }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/package.yml:
--------------------------------------------------------------------------------
 1 | package: 2factor_auth
 2 | version: '2.3'
 3 | author: Friends Of REDAXO
 4 | 
 5 | page:
 6 |     title: 'translate:2factor_auth'
 7 |     icon: rex-icon fa-lock
 8 |     subpages:
 9 |         setup:
10 |             title: 'translate:2factor_auth_private_setup'
11 |         docs:
12 |             title: translate:readme
13 |             subPath: README.md
14 |             icon: rex-icon fa-info-circle
15 |             itemClass: pull-right
16 |         users:
17 |             title: translate:users
18 |             perm: admin[]
19 |             itemClass: pull-right
20 |         settings:
21 |             title: 'translate:2factor_auth_settings'
22 |             perm: admin[]
23 |             itemClass: pull-right
24 | 
25 | pages:
26 |     2factor_auth_verify:
27 |         title: 'translate:OTP-Verifizierung'
28 |         hasNavigation: false
29 |         main: true
30 |         hidden: true
31 |         path: pages/verify.php
32 | 
33 | console_commands:
34 |     2factor_auth:enforce: rex_command_2factor_auth_enforce
35 |     2factor_auth:user: rex_command_2factor_auth_user
36 |     2factor_auth:status: rex_command_2factor_auth_status
37 | 
38 | requires:
39 |     php:
40 |         version: '>=8.1'
41 |     redaxo: ^5.14.0
42 | 
43 | load: early
44 | 


--------------------------------------------------------------------------------
/pages/index.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo rex_view::title(rex_i18n::msg('2factor_auth'));
4 | 
5 | rex_be_controller::includeCurrentPageSubPath();
6 | 


--------------------------------------------------------------------------------
/pages/settings.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use FriendsOfREDAXO\TwoFactorAuth\method_totp;
  4 | use FriendsOfREDAXO\TwoFactorAuth\one_time_password;
  5 | 
  6 | /** @var rex_addon $this */
  7 | 
  8 | if ('update' == rex_request('func', 'string')) {
  9 |     $this->setConfig('enforce', rex_request('2factor_auth_enforce', 'string'));
 10 |     $this->setConfig('option', rex_request('2factor_auth_option', 'string'));
 11 |     $this->setConfig('email_period', rex_request('2factor_auth_email_period', 'int', 300));
 12 |     echo rex_view::success($this->i18n('2factor_auth_updated'));
 13 | }
 14 | 
 15 | $selectEnforce = new rex_select();
 16 | $selectEnforce->setId('2factor_auth_enforce');
 17 | $selectEnforce->setName('2factor_auth_enforce');
 18 | $selectEnforce->setAttribute('class', 'form-control selectpicker');
 19 | $selectEnforce->setSelected($this->getConfig('enforce'));
 20 | 
 21 | $selectEnforce->addOption($this->i18n('2factor_auth_enforce_' . one_time_password::ENFORCED_ALL), one_time_password::ENFORCED_ALL);
 22 | $selectEnforce->addOption($this->i18n('2factor_auth_enforce_' . one_time_password::ENFORCED_ADMINS), one_time_password::ENFORCED_ADMINS);
 23 | $selectEnforce->addOption($this->i18n('2factor_auth_enforce_' . one_time_password::ENFORCED_DISABLED), one_time_password::ENFORCED_DISABLED);
 24 | 
 25 | $selectOption = new rex_select();
 26 | $selectOption->setId('2factor_auth_option');
 27 | $selectOption->setName('2factor_auth_option');
 28 | $selectOption->setAttribute('class', 'form-control selectpicker');
 29 | $selectOption->setSelected($this->getConfig('option'));
 30 | 
 31 | $selectOption->addOption($this->i18n('2factor_auth_option_' . one_time_password::OPTION_ALL), one_time_password::OPTION_ALL);
 32 | $selectOption->addOption($this->i18n('2factor_auth_option_' . one_time_password::OPTION_TOTP), one_time_password::OPTION_TOTP);
 33 | $selectOption->addOption($this->i18n('2factor_auth_option_' . one_time_password::OPTION_EMAIL), one_time_password::OPTION_EMAIL);
 34 | 
 35 | $selectEmailPeriod = new rex_select();
 36 | $selectEmailPeriod->setId('2factor_auth_email_period');
 37 | $selectEmailPeriod->setName('2factor_auth_email_period');
 38 | $selectEmailPeriod->setAttribute('class', 'form-control selectpicker');
 39 | $selectEmailPeriod->setSelected($this->getConfig('email_period'));
 40 | 
 41 | $selectEmailPeriod->addOption('5 ' . $this->i18n('minutes'), 300);
 42 | $selectEmailPeriod->addOption('10 ' . $this->i18n('minutes'), 600);
 43 | $selectEmailPeriod->addOption('15 ' . $this->i18n('minutes'), 900);
 44 | $selectEmailPeriod->addOption('30 ' . $this->i18n('minutes'), 1800);
 45 | 
 46 | $selectTOTPPeriod = new rex_select();
 47 | $selectTOTPPeriod->setAttribute('class', 'form-control selectpicker');
 48 | $selectTOTPPeriod->setDisabled(true);
 49 | $selectTOTPPeriod->addOption($this->i18n('2factor_auth_totp_period_info', method_totp::getPeriod()), 30);
 50 | 
 51 | $selectLoginTries = new rex_select();
 52 | $selectLoginTries->setAttribute('class', 'form-control selectpicker');
 53 | $selectLoginTries->setDisabled(true);
 54 | $selectLoginTries->addOption($this->i18n('2factor_auth_logintries_info', method_totp::getloginTries()), 30);
 55 | 
 56 | $content = '
 57 | <form action="index.php" method="post" id="ycom_auth_settings">
 58 |     <input type="hidden" name="page" value="2factor_auth/settings" />
 59 |     <input type="hidden" name="func" value="update" />
 60 | 
 61 |     <fieldset>
 62 |             <div class="row abstand">
 63 |                 <div class="col-xs-12 col-sm-6">
 64 |                     <label for="2factor_auth_enforce">' . $this->i18n('2factor_auth_enforce') . '</label>
 65 |                 </div>
 66 |                 <div class="col-xs-12 col-sm-6">
 67 |                 ' . $selectEnforce->get() . '
 68 |                 </div>
 69 |             </div>
 70 | 
 71 |             <div class="row abstand">
 72 |                 <div class="col-xs-12 col-sm-6">
 73 |                     <label for="2factor_auth_options">' . $this->i18n('2factor_auth_options') . '</label>
 74 |                 </div>
 75 |                 <div class="col-xs-12 col-sm-6">
 76 |                 ' . $selectOption->get() . '
 77 |                 </div>
 78 |             </div>
 79 | 
 80 |             <div class="row abstand">
 81 |                 <div class="col-xs-12 col-sm-6">
 82 |                     <label for="2factor_auth_email_period">' . $this->i18n('2factor_auth_email_period') . '</label>
 83 |                 </div>
 84 |                 <div class="col-xs-12 col-sm-6">
 85 |                 ' . $selectEmailPeriod->get() . '
 86 |                 </div>
 87 |             </div>
 88 | 
 89 |             <div class="row abstand">
 90 |                 <div class="col-xs-12 col-sm-6">
 91 |                     <label for="2factor_auth_email_period">' . $this->i18n('2factor_auth_totp_period') . '</label>
 92 |                 </div>
 93 |                 <div class="col-xs-12 col-sm-6">
 94 |                 ' . $selectTOTPPeriod->get() . '
 95 |                 </div>
 96 |             </div>
 97 | 
 98 |             <div class="row">
 99 |                 <div class="col-xs-12 col-sm-6">
100 |                     <label for="2factor_auth_email_period">' . $this->i18n('2factor_auth_logintries') . '</label>
101 |                 </div>
102 |                 <div class="col-xs-12 col-sm-6">
103 |                 ' . $selectLoginTries->get() . '
104 |                 </div>
105 |             </div>
106 | 
107 |     </fieldset>
108 | 
109 | 	<div class="row">
110 | 		<div class="col-xs-12 col-sm-6 col-sm-push-6">
111 | 			<button class="btn btn-save right" type="submit" name="config-submit" value="1" title="' . $this->i18n('2factor_auth_config_save') . '">' . $this->i18n('2factor_auth_config_save') . '</button>
112 | 		</div>
113 | 	</div>
114 | 
115 | 	</form>
116 | 
117 |   ';
118 | 
119 | $fragment = new rex_fragment();
120 | $fragment->setVar('class', 'edit');
121 | $fragment->setVar('title', $this->i18n('2factor_auth_settings'));
122 | $fragment->setVar('body', $content, false);
123 | echo $fragment->parse('core/page/section.php');
124 | 


--------------------------------------------------------------------------------
/pages/setup.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use FriendsOfREDAXO\TwoFactorAuth\method_email;
  4 | use FriendsOfREDAXO\TwoFactorAuth\method_totp;
  5 | use FriendsOfREDAXO\TwoFactorAuth\one_time_password;
  6 | use FriendsOfREDAXO\TwoFactorAuth\one_time_password_config;
  7 | 
  8 | /** @var rex_addon $this */
  9 | 
 10 | $fragment = new rex_fragment();
 11 | $message = '';
 12 | $title = $this->i18n('2fa_setup');
 13 | $buttons = '';
 14 | $content = '';
 15 | $uri = '';
 16 | $success = false;
 17 | 
 18 | $csrfToken = rex_csrf_token::factory('2factor_auth_setup');
 19 | $func = rex_request('func', 'string');
 20 | 
 21 | $otp = one_time_password::getInstance();
 22 | $otp_options = $otp->getAuthOption();
 23 | 
 24 | if (one_time_password::OPTION_EMAIL == $otp_options) {
 25 |     // email_only -> kein totp
 26 |     echo rex_view::info($this->i18n('2factor_auth_select_' . one_time_password::OPTION_EMAIL));
 27 |     if ('setup-totp' == $func) {
 28 |         $func = '';
 29 |     }
 30 | }
 31 | 
 32 | if (one_time_password::OPTION_TOTP == $otp_options) {
 33 |     // only email email_only
 34 |     echo rex_view::info($this->i18n('2factor_auth_select_' . one_time_password::OPTION_EMAIL));
 35 |     if ('setup-email' == $func) {
 36 |         $func = '';
 37 |     }
 38 | }
 39 | 
 40 | if ('setup-email' === $func || 'setup-totp' === $func) {
 41 |     switch ($func) {
 42 |         case 'setup-email':
 43 |             $otpMethod = new method_email();
 44 |             break;
 45 |         default:
 46 |             $otpMethod = new method_totp();
 47 |             break;
 48 |     }
 49 | 
 50 |     $config = one_time_password_config::loadFromDb($otpMethod, rex::requireUser());
 51 |     $config->updateMethod($otpMethod);
 52 |     $user_id = rex::requireUser()->getId();
 53 |     rex_user::clearInstance($user_id);
 54 |     rex::setProperty('user', rex_user::get($user_id));
 55 | }
 56 | 
 57 | $otpMethod = $otp->getMethod();
 58 | 
 59 | if ('' !== $func && !$csrfToken->isValid()) {
 60 |     $message = rex_view::error($this->i18n('csrf_token_invalid'));
 61 |     $func = '';
 62 | }
 63 | 
 64 | if ('disable' === $func) {
 65 |     $config = one_time_password_config::loadFromDb($otpMethod, rex::requireUser());
 66 |     $config->disable();
 67 |     $func = '';
 68 | }
 69 | 
 70 | if (one_time_password::ENFORCED_ALL === $otp->isEnforced()) {
 71 |     $message .= rex_view::info($this->i18n('2fa_enforced') . ': ' . $this->i18n('2factor_auth_enforce_' . one_time_password::ENFORCED_ALL));
 72 | }
 73 | if (one_time_password::ENFORCED_ADMINS === $otp->isEnforced()) {
 74 |     $message .= rex_view::info($this->i18n('2fa_enforced') . ': ' . $this->i18n('2factor_auth_enforce_' . one_time_password::ENFORCED_ADMINS));
 75 | }
 76 | 
 77 | $config = one_time_password_config::loadFromDb($otpMethod, rex::requireUser());
 78 | if ($otp->isEnabled() && $config->enabled) {
 79 |     $title = $this->i18n('status');
 80 |     switch ($config->method) {
 81 |         case 'email':
 82 |             $content = '<p>' . $this->i18n('2fa_status_email_info', rex::getUser()->getLogin(), rex::getUser()->getEmail()) . '</p>';
 83 |             break;
 84 |         default:
 85 |             $content = '<p>' . $this->i18n('2fa_status_otp_info', rex::getUser()->getLogin()) . '</p>';
 86 |             break;
 87 |     }
 88 |     $this->i18n('2fa_status_otp_instruction');
 89 |     $content .= '<p><a class="btn btn-delete" href="' . rex_url::currentBackendPage(['func' => 'disable'] + $csrfToken->getUrlParams()) . '">' . $this->i18n('2fa_disable', rex::getUser()->getLogin()) . '</a></p>';
 90 | } else {
 91 |     if ('' === $func) {
 92 |         if (one_time_password::OPTION_ALL == $otp_options || one_time_password::OPTION_TOTP == $otp_options) {
 93 |             $content .= '<p>' . $this->i18n('2factor_auth_2fa_page_totp_instruction') . '</p>';
 94 |             $content .= '<p><a class="btn btn-setup" href="' . rex_url::currentBackendPage(['func' => 'setup-totp'] + $csrfToken->getUrlParams()) . '">' . $this->i18n('2fa_setup_start_totp') . '</a></p>';
 95 |         }
 96 |         if (one_time_password::OPTION_ALL == $otp_options || one_time_password::OPTION_EMAIL == $otp_options) {
 97 |             $content .= '<p>' . $this->i18n('2factor_auth_2fa_page_email_instruction') . '</p>';
 98 |             $content .= '<p><a class="btn btn-setup" href="' . rex_url::currentBackendPage(['func' => 'setup-email'] + $csrfToken->getUrlParams()) . '">' . $this->i18n('2fa_setup_start_email') . '</a></p>';
 99 |         }
100 |     } elseif ('setup-totp' === $func) {
101 |         // nothing todo
102 |     } elseif ('setup-email' === $func) {
103 |         if (!rex_addon::get('phpmailer')->isAvailable()) {
104 |             $content = rex_view::error($this->i18n('2fa_setup_start_phpmailer_required'));
105 |             $func = '';
106 |         }
107 | 
108 |         $email = trim(rex::requireUser()->getEmail());
109 |         if ('' !== $func && ('' === $email || !str_contains($email, '@'))) {
110 |             $content = rex_view::error($this->i18n('2fa_setup_start_email_required'));
111 |             $buttons = '<a class="btn btn-setup" href="' . rex_url::backendPage('profile') . '">' . $this->i18n('2fa_setup_start_email_open_profile') . '</a>';
112 | 
113 |             $func = '';
114 |         }
115 | 
116 |         if ('' !== $func) {
117 |             try {
118 |                 one_time_password::getInstance()->challenge();
119 |                 $message = rex_view::info($this->i18n('2fa_setup_start_email_send'));
120 |             } catch (Exception $e) {
121 |                 $message = rex_view::error($e->getMessage());
122 |                 $func = '';
123 |             }
124 |         }
125 |     } elseif ('verify-totp' === $func || 'verify-email' === $func) {
126 |         $otp = rex_post('rex_login_otp', 'string', '');
127 | 
128 |         if ('' !== $otp) {
129 |             if (one_time_password::getInstance()->verify($otp)) {
130 |                 $message = '<div class="alert alert-success">' . $this->i18n('2fa_setup_successfull') . '</div>';
131 |                 $config = one_time_password_config::loadFromDb($otpMethod, rex::requireUser());
132 |                 $config->enable();
133 |                 $content = '';
134 |                 $success = true;
135 |             }
136 |         }
137 | 
138 |         if (!$success) {
139 |             $message = '<div class="alert alert-warning">' . $this->i18n('2fa_wrong_opt') . '</div>';
140 |         }
141 |     } else {
142 |         throw new rex_exception('unknown state');
143 |     }
144 | }
145 | 
146 | if ('setup-email' === $func || 'verify-email' === $func || 'setup-totp' === $func || 'verify-totp' === $func) {
147 |     $config = one_time_password_config::loadFromDb($otpMethod, rex::requireUser());
148 |     $uri = $config->provisioningUri;
149 | 
150 |     $fragment->setVar('addon', $this, false);
151 |     $fragment->setVar('csrfToken', $csrfToken, false);
152 |     $fragment->setVar('message', $message, false);
153 |     $fragment->setVar('buttons', $buttons, false);
154 |     $fragment->setVar('uri', $uri, false);
155 |     $fragment->setVar('success', $success, false);
156 | 
157 |     if ('setup-totp' === $func || 'verify-totp' === $func) {
158 |         echo $fragment->parse('2fa.setup-totp.php');
159 |     } else {
160 |         echo $fragment->parse('2fa.setup-email.php');
161 |     }
162 | } else {
163 |     $fragment = new rex_fragment();
164 |     $fragment->setVar('before', $message, false);
165 |     $fragment->setVar('heading', $title, false);
166 |     $fragment->setVar('body', $content, false);
167 |     $fragment->setVar('buttons', $buttons, false);
168 |     echo $fragment->parse('core/page/section.php');
169 | }
170 | 


--------------------------------------------------------------------------------
/pages/users.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use FriendsOfREDAXO\TwoFactorAuth\one_time_password_config;
 4 | 
 5 | if ('deactivate' == rex_get('func', 'string') && $userid = rex_get('userid', 'int')) {
 6 |     try {
 7 |         $user = rex_user::get($userid);
 8 |         $config = one_time_password_config::forUser($user);
 9 |         $config->disable();
10 | 
11 |         echo rex_view::success('User ' . $user->getLogin() . ' deactivated');
12 |     } catch (Exception $e) {
13 |         echo rex_view::error($e->getMessage());
14 |     }
15 | }
16 | 
17 | $users = rex_sql::factory();
18 | $users
19 |     ->setTable(rex::getTable('user'))
20 |     ->select();
21 | 
22 | $content = '<table class="table">';
23 | 
24 | $content .= '<thead>';
25 | $content .= '<tr>';
26 | $content .= '<th>id</th>';
27 | $content .= '<th>login</th>';
28 | $content .= '<th>status</th>';
29 | $content .= '<th>method</th>';
30 | $content .= '<th>tries</th>';
31 | $content .= '<th>last_try</th>';
32 | $content .= '<th>actions</th>';
33 | $content .= '</tr>';
34 | $content .= '</thead>';
35 | 
36 | $content .= '<tbody>';
37 | 
38 | $trs = [];
39 | foreach ($users as $user) {
40 |     $user = rex_user::fromSql($user);
41 |     $config = one_time_password_config::forUser($user);
42 |     $trs[] = '<tr>
43 |                 <td data-title="id">' . rex_escape($user->getId()) . '</td>
44 |                 <td data-title="login">' . rex_escape($user->getLogin()) . '</td>
45 |                 <td data-title="enabled">' . rex_escape($config->enabled ? 'on' : 'off') . '</td>
46 |                 <td data-title="method">' . rex_escape($config->method) . '</td>
47 |                 <td data-title="tries">' . rex_escape($user->getValue('one_time_password_tries')) . '</td>
48 |                 <td data-title="last try">' . rex_escape($user->getValue('one_time_password_lasttry')) . '</td>
49 |                 <td data-title="action"><a href="' . rex_url::currentBackendPage(['func' => 'deactivate', 'userid' => $user->getId()]) . '">deactivate</a></td>
50 |                 </tr>';
51 | }
52 | 
53 | $content .= implode('', $trs);
54 | 
55 | $content .= '</tbody>';
56 | $content .= '</table>';
57 | 
58 | $fragment = new rex_fragment();
59 | $fragment->setVar('title', $this->i18n('users'), false);
60 | $fragment->setVar('content', $content, false);
61 | echo $fragment->parse('core/page/section.php');
62 | 


--------------------------------------------------------------------------------
/pages/verify.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use FriendsOfREDAXO\TwoFactorAuth\method_email;
  4 | use FriendsOfREDAXO\TwoFactorAuth\method_totp;
  5 | use FriendsOfREDAXO\TwoFactorAuth\one_time_password;
  6 | 
  7 | /** @var rex_addon $this */
  8 | 
  9 | $error = false;
 10 | $info_messages = [];
 11 | $error_messages = [];
 12 | $csrfToken = rex_csrf_token::factory('2factor_auth_verify');
 13 | $otp = rex_post('rex_login_otp', 'string', null);
 14 | $OTPInstance = one_time_password::getInstance();
 15 | $Method = $OTPInstance->getMethod();
 16 | 
 17 | if (!isset($otp)) {
 18 |     try {
 19 |         one_time_password::getInstance()->challenge();
 20 |     } catch (Exception $e) {
 21 |         $error = true;
 22 |         $error_messages[] = $e->getMessage();
 23 |     }
 24 | }
 25 | 
 26 | switch (get_class($Method)) {
 27 |     case 'FriendsOfREDAXO\TwoFactorAuth\method_email':
 28 |         if (!isset($otp)) {
 29 |             $info_messages[] = rex_i18n::msg('2factor_auth_2fa_info_email_sent');
 30 |         }
 31 |         $info_messages[] = rex_i18n::msg('2factor_auth_2fa_info_email_enter_code');
 32 |         $blockTime = method_email::getPeriod();
 33 |         $loginTriesAllowed = method_email::getloginTries();
 34 |         break;
 35 |     default:
 36 |     case 'FriendsOfREDAXO\TwoFactorAuth\method_totp':
 37 |         $info_messages[] = rex_i18n::msg('2factor_auth_2fa_info_topt_enter_code');
 38 |         $blockTime = method_totp::getPeriod();
 39 |         $loginTriesAllowed = method_totp::getloginTries();
 40 |         break;
 41 | }
 42 | 
 43 | /** @var rex_user $user */
 44 | $user = rex::getUser();
 45 | $loginTries = (int) $user->getValue('one_time_password_tries');
 46 | $loginLastTry = (int) $user->getValue('one_time_password_lasttry');
 47 | 
 48 | $SQLUser = rex_sql::factory();
 49 | $SQLUser->setTable(rex::getTable('user'));
 50 | $SQLUser->setWhere('id = :id', ['id' => $user->getId()]);
 51 | 
 52 | if (isset($otp) && !$csrfToken->isValid()) {
 53 |     $error_messages[] = rex_i18n::msg('csrf_token_invalid');
 54 | } elseif ($loginTries >= $loginTriesAllowed && ($loginLastTry > time() - $blockTime)) {
 55 |     $countdownTime = $loginLastTry - time() + $blockTime;
 56 |     $error_messages[] = rex_i18n::rawMsg('one_time_password_too_many_tries', $countdownTime, $loginTriesAllowed, $blockTime);
 57 | 
 58 |     $script = '
 59 |     <script nonce="' . rex_response::getNonce() . '">
 60 | 
 61 |     let countdown = ' . $countdownTime . ';
 62 |     let countdownElement = document.getElementById("otp_countdown");
 63 | 
 64 |     let interval = setInterval(() => {
 65 |        countdown--;
 66 |        countdownElement.innerHTML = countdown;
 67 |        if (countdown <= 0) {
 68 |            clearInterval(interval);
 69 |        }
 70 |     }, 1000);
 71 | 
 72 | </script>
 73 |     ';
 74 | } elseif (isset($otp) && '' == $otp) {
 75 |     // $error_messages[] = rex_i18n::msg('2fa_otp_empty');
 76 | } elseif (isset($otp)) {
 77 | 
 78 | 
 79 |     if ($OTPInstance->verify($otp)) {
 80 |         $SQLUser->setValue('one_time_password_tries', 0);
 81 |         $SQLUser->setValue('one_time_password_lasttry', time());
 82 |         $SQLUser->update();
 83 | 
 84 |         $message = rex_view::success('Passt');
 85 |         // symbolischer parameter, der nirgends ausgewertet werden sollte/darf.
 86 |         rex_response::sendRedirect('?ok');
 87 |     } else {
 88 |         $SQLUser->setValue('one_time_password_tries', $loginTries + 1);
 89 |         $SQLUser->setValue('one_time_password_lasttry', time());
 90 |         $SQLUser->update();
 91 | 
 92 |         $error_messages[] = $this->i18n('2fa_otp_wrong');
 93 |     }
 94 | }
 95 | 
 96 | $fragment = new rex_fragment();
 97 | $fragment->setVar('csrfToken', $csrfToken, false);
 98 | $fragment->setVar('info_messages', implode('<br />', $info_messages), false);
 99 | $fragment->setVar('error_messages', implode('<br />', $error_messages), false);
100 | echo $fragment->parse('2fa.login.php');
101 | echo $script ?? '';
102 | 
103 | ?>
104 | 
105 | 
106 | 


--------------------------------------------------------------------------------
/uninstall.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | rex_sql_table::get(rex::getTable('user'))
4 |     ->removeColumn('one_time_password_config')
5 |     ->removeColumn('one_time_password_tries')
6 |     ->removeColumn('one_time_password_lasttry')
7 | ->ensure();
8 | 


--------------------------------------------------------------------------------
/update.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $this->includeFile(__DIR__.'/install.php');
4 | 


--------------------------------------------------------------------------------
/vendor/autoload.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload.php @generated by Composer
 4 | 
 5 | if (PHP_VERSION_ID < 50600) {
 6 |     if (!headers_sent()) {
 7 |         header('HTTP/1.1 500 Internal Server Error');
 8 |     }
 9 |     $err = 'Composer 2.3.0 dropped support for autoloading on PHP <5.6 and you are running '.PHP_VERSION.', please upgrade PHP or use Composer 2.2 LTS via "composer self-update --2.2". Aborting.'.PHP_EOL;
10 |     if (!ini_get('display_errors')) {
11 |         if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
12 |             fwrite(STDERR, $err);
13 |         } elseif (!headers_sent()) {
14 |             echo $err;
15 |         }
16 |     }
17 |     trigger_error(
18 |         $err,
19 |         E_USER_ERROR
20 |     );
21 | }
22 | 
23 | require_once __DIR__ . '/composer/autoload_real.php';
24 | 
25 | return ComposerAutoloaderInitd487eb39062b37336c507c1263b844e3::getLoader();
26 | 


--------------------------------------------------------------------------------
/vendor/composer/LICENSE:
--------------------------------------------------------------------------------
 1 | 
 2 | Copyright (c) Nils Adermann, Jordi Boggiano
 3 | 
 4 | Permission is hereby granted, free of charge, to any person obtaining a copy
 5 | of this software and associated documentation files (the "Software"), to deal
 6 | in the Software without restriction, including without limitation the rights
 7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 8 | copies of the Software, and to permit persons to whom the Software is furnished
 9 | to do so, subject to the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be included in all
12 | copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 | THE SOFTWARE.
21 | 
22 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_classmap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_classmap.php @generated by Composer
 4 | 
 5 | $vendorDir = dirname(__DIR__);
 6 | $baseDir = dirname($vendorDir);
 7 | 
 8 | return array(
 9 |     'Composer\\InstalledVersions' => $vendorDir . '/composer/InstalledVersions.php',
10 | );
11 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_files.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_files.php @generated by Composer
 4 | 
 5 | $vendorDir = dirname(__DIR__);
 6 | $baseDir = dirname($vendorDir);
 7 | 
 8 | return array(
 9 |     '6e3fae29631ef280660b3cdad06f25a8' => $vendorDir . '/symfony/deprecation-contracts/function.php',
10 | );
11 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_namespaces.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_namespaces.php @generated by Composer
 4 | 
 5 | $vendorDir = dirname(__DIR__);
 6 | $baseDir = dirname($vendorDir);
 7 | 
 8 | return array(
 9 | );
10 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_psr4.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_psr4.php @generated by Composer
 4 | 
 5 | $vendorDir = dirname(__DIR__);
 6 | $baseDir = dirname($vendorDir);
 7 | 
 8 | return array(
 9 |     'Psr\\Clock\\' => array($vendorDir . '/psr/clock/src'),
10 |     'ParagonIE\\ConstantTime\\' => array($vendorDir . '/paragonie/constant_time_encoding/src'),
11 |     'OTPHP\\' => array($vendorDir . '/spomky-labs/otphp/src'),
12 | );
13 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_real.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_real.php @generated by Composer
 4 | 
 5 | class ComposerAutoloaderInitd487eb39062b37336c507c1263b844e3
 6 | {
 7 |     private static $loader;
 8 | 
 9 |     public static function loadClassLoader($class)
10 |     {
11 |         if ('Composer\Autoload\ClassLoader' === $class) {
12 |             require __DIR__ . '/ClassLoader.php';
13 |         }
14 |     }
15 | 
16 |     /**
17 |      * @return \Composer\Autoload\ClassLoader
18 |      */
19 |     public static function getLoader()
20 |     {
21 |         if (null !== self::$loader) {
22 |             return self::$loader;
23 |         }
24 | 
25 |         require __DIR__ . '/platform_check.php';
26 | 
27 |         spl_autoload_register(array('ComposerAutoloaderInitd487eb39062b37336c507c1263b844e3', 'loadClassLoader'), true, true);
28 |         self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(__DIR__));
29 |         spl_autoload_unregister(array('ComposerAutoloaderInitd487eb39062b37336c507c1263b844e3', 'loadClassLoader'));
30 | 
31 |         require __DIR__ . '/autoload_static.php';
32 |         call_user_func(\Composer\Autoload\ComposerStaticInitd487eb39062b37336c507c1263b844e3::getInitializer($loader));
33 | 
34 |         $loader->register(true);
35 | 
36 |         $filesToLoad = \Composer\Autoload\ComposerStaticInitd487eb39062b37336c507c1263b844e3::$files;
37 |         $requireFile = \Closure::bind(static function ($fileIdentifier, $file) {
38 |             if (empty($GLOBALS['__composer_autoload_files'][$fileIdentifier])) {
39 |                 $GLOBALS['__composer_autoload_files'][$fileIdentifier] = true;
40 | 
41 |                 require $file;
42 |             }
43 |         }, null, null);
44 |         foreach ($filesToLoad as $fileIdentifier => $file) {
45 |             $requireFile($fileIdentifier, $file);
46 |         }
47 | 
48 |         return $loader;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_static.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_static.php @generated by Composer
 4 | 
 5 | namespace Composer\Autoload;
 6 | 
 7 | class ComposerStaticInitd487eb39062b37336c507c1263b844e3
 8 | {
 9 |     public static $files = array (
10 |         '6e3fae29631ef280660b3cdad06f25a8' => __DIR__ . '/..' . '/symfony/deprecation-contracts/function.php',
11 |     );
12 | 
13 |     public static $prefixLengthsPsr4 = array (
14 |         'P' => 
15 |         array (
16 |             'Psr\\Clock\\' => 10,
17 |             'ParagonIE\\ConstantTime\\' => 23,
18 |         ),
19 |         'O' => 
20 |         array (
21 |             'OTPHP\\' => 6,
22 |         ),
23 |     );
24 | 
25 |     public static $prefixDirsPsr4 = array (
26 |         'Psr\\Clock\\' => 
27 |         array (
28 |             0 => __DIR__ . '/..' . '/psr/clock/src',
29 |         ),
30 |         'ParagonIE\\ConstantTime\\' => 
31 |         array (
32 |             0 => __DIR__ . '/..' . '/paragonie/constant_time_encoding/src',
33 |         ),
34 |         'OTPHP\\' => 
35 |         array (
36 |             0 => __DIR__ . '/..' . '/spomky-labs/otphp/src',
37 |         ),
38 |     );
39 | 
40 |     public static $classMap = array (
41 |         'Composer\\InstalledVersions' => __DIR__ . '/..' . '/composer/InstalledVersions.php',
42 |     );
43 | 
44 |     public static function getInitializer(ClassLoader $loader)
45 |     {
46 |         return \Closure::bind(function () use ($loader) {
47 |             $loader->prefixLengthsPsr4 = ComposerStaticInitd487eb39062b37336c507c1263b844e3::$prefixLengthsPsr4;
48 |             $loader->prefixDirsPsr4 = ComposerStaticInitd487eb39062b37336c507c1263b844e3::$prefixDirsPsr4;
49 |             $loader->classMap = ComposerStaticInitd487eb39062b37336c507c1263b844e3::$classMap;
50 | 
51 |         }, null, ClassLoader::class);
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/vendor/composer/installed.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "packages": [
  3 |         {
  4 |             "name": "paragonie/constant_time_encoding",
  5 |             "version": "v3.0.0",
  6 |             "version_normalized": "3.0.0.0",
  7 |             "source": {
  8 |                 "type": "git",
  9 |                 "url": "https://github.com/paragonie/constant_time_encoding.git",
 10 |                 "reference": "df1e7fde177501eee2037dd159cf04f5f301a512"
 11 |             },
 12 |             "dist": {
 13 |                 "type": "zip",
 14 |                 "url": "https://api.github.com/repos/paragonie/constant_time_encoding/zipball/df1e7fde177501eee2037dd159cf04f5f301a512",
 15 |                 "reference": "df1e7fde177501eee2037dd159cf04f5f301a512",
 16 |                 "shasum": ""
 17 |             },
 18 |             "require": {
 19 |                 "php": "^8"
 20 |             },
 21 |             "require-dev": {
 22 |                 "phpunit/phpunit": "^9",
 23 |                 "vimeo/psalm": "^4|^5"
 24 |             },
 25 |             "time": "2024-05-08T12:36:18+00:00",
 26 |             "type": "library",
 27 |             "installation-source": "dist",
 28 |             "autoload": {
 29 |                 "psr-4": {
 30 |                     "ParagonIE\\ConstantTime\\": "src/"
 31 |                 }
 32 |             },
 33 |             "notification-url": "https://packagist.org/downloads/",
 34 |             "license": [
 35 |                 "MIT"
 36 |             ],
 37 |             "authors": [
 38 |                 {
 39 |                     "name": "Paragon Initiative Enterprises",
 40 |                     "email": "security@paragonie.com",
 41 |                     "homepage": "https://paragonie.com",
 42 |                     "role": "Maintainer"
 43 |                 },
 44 |                 {
 45 |                     "name": "Steve 'Sc00bz' Thomas",
 46 |                     "email": "steve@tobtu.com",
 47 |                     "homepage": "https://www.tobtu.com",
 48 |                     "role": "Original Developer"
 49 |                 }
 50 |             ],
 51 |             "description": "Constant-time Implementations of RFC 4648 Encoding (Base-64, Base-32, Base-16)",
 52 |             "keywords": [
 53 |                 "base16",
 54 |                 "base32",
 55 |                 "base32_decode",
 56 |                 "base32_encode",
 57 |                 "base64",
 58 |                 "base64_decode",
 59 |                 "base64_encode",
 60 |                 "bin2hex",
 61 |                 "encoding",
 62 |                 "hex",
 63 |                 "hex2bin",
 64 |                 "rfc4648"
 65 |             ],
 66 |             "support": {
 67 |                 "email": "info@paragonie.com",
 68 |                 "issues": "https://github.com/paragonie/constant_time_encoding/issues",
 69 |                 "source": "https://github.com/paragonie/constant_time_encoding"
 70 |             },
 71 |             "install-path": "../paragonie/constant_time_encoding"
 72 |         },
 73 |         {
 74 |             "name": "psr/clock",
 75 |             "version": "1.0.0",
 76 |             "version_normalized": "1.0.0.0",
 77 |             "source": {
 78 |                 "type": "git",
 79 |                 "url": "https://github.com/php-fig/clock.git",
 80 |                 "reference": "e41a24703d4560fd0acb709162f73b8adfc3aa0d"
 81 |             },
 82 |             "dist": {
 83 |                 "type": "zip",
 84 |                 "url": "https://api.github.com/repos/php-fig/clock/zipball/e41a24703d4560fd0acb709162f73b8adfc3aa0d",
 85 |                 "reference": "e41a24703d4560fd0acb709162f73b8adfc3aa0d",
 86 |                 "shasum": ""
 87 |             },
 88 |             "require": {
 89 |                 "php": "^7.0 || ^8.0"
 90 |             },
 91 |             "time": "2022-11-25T14:36:26+00:00",
 92 |             "type": "library",
 93 |             "installation-source": "dist",
 94 |             "autoload": {
 95 |                 "psr-4": {
 96 |                     "Psr\\Clock\\": "src/"
 97 |                 }
 98 |             },
 99 |             "notification-url": "https://packagist.org/downloads/",
100 |             "license": [
101 |                 "MIT"
102 |             ],
103 |             "authors": [
104 |                 {
105 |                     "name": "PHP-FIG",
106 |                     "homepage": "https://www.php-fig.org/"
107 |                 }
108 |             ],
109 |             "description": "Common interface for reading the clock.",
110 |             "homepage": "https://github.com/php-fig/clock",
111 |             "keywords": [
112 |                 "clock",
113 |                 "now",
114 |                 "psr",
115 |                 "psr-20",
116 |                 "time"
117 |             ],
118 |             "support": {
119 |                 "issues": "https://github.com/php-fig/clock/issues",
120 |                 "source": "https://github.com/php-fig/clock/tree/1.0.0"
121 |             },
122 |             "install-path": "../psr/clock"
123 |         },
124 |         {
125 |             "name": "spomky-labs/otphp",
126 |             "version": "11.3.0",
127 |             "version_normalized": "11.3.0.0",
128 |             "source": {
129 |                 "type": "git",
130 |                 "url": "https://github.com/Spomky-Labs/otphp.git",
131 |                 "reference": "2d8ccb5fc992b9cc65ef321fa4f00fefdb3f4b33"
132 |             },
133 |             "dist": {
134 |                 "type": "zip",
135 |                 "url": "https://api.github.com/repos/Spomky-Labs/otphp/zipball/2d8ccb5fc992b9cc65ef321fa4f00fefdb3f4b33",
136 |                 "reference": "2d8ccb5fc992b9cc65ef321fa4f00fefdb3f4b33",
137 |                 "shasum": ""
138 |             },
139 |             "require": {
140 |                 "ext-mbstring": "*",
141 |                 "paragonie/constant_time_encoding": "^2.0 || ^3.0",
142 |                 "php": ">=8.1",
143 |                 "psr/clock": "^1.0",
144 |                 "symfony/deprecation-contracts": "^3.2"
145 |             },
146 |             "require-dev": {
147 |                 "ekino/phpstan-banned-code": "^1.0",
148 |                 "infection/infection": "^0.26|^0.27|^0.28|^0.29",
149 |                 "php-parallel-lint/php-parallel-lint": "^1.3",
150 |                 "phpstan/phpstan": "^1.0",
151 |                 "phpstan/phpstan-deprecation-rules": "^1.0",
152 |                 "phpstan/phpstan-phpunit": "^1.0",
153 |                 "phpstan/phpstan-strict-rules": "^1.0",
154 |                 "phpunit/phpunit": "^9.5.26|^10.0|^11.0",
155 |                 "qossmic/deptrac-shim": "^1.0",
156 |                 "rector/rector": "^1.0",
157 |                 "symfony/phpunit-bridge": "^6.1|^7.0",
158 |                 "symplify/easy-coding-standard": "^12.0"
159 |             },
160 |             "time": "2024-06-12T11:22:32+00:00",
161 |             "type": "library",
162 |             "installation-source": "dist",
163 |             "autoload": {
164 |                 "psr-4": {
165 |                     "OTPHP\\": "src/"
166 |                 }
167 |             },
168 |             "notification-url": "https://packagist.org/downloads/",
169 |             "license": [
170 |                 "MIT"
171 |             ],
172 |             "authors": [
173 |                 {
174 |                     "name": "Florent Morselli",
175 |                     "homepage": "https://github.com/Spomky"
176 |                 },
177 |                 {
178 |                     "name": "All contributors",
179 |                     "homepage": "https://github.com/Spomky-Labs/otphp/contributors"
180 |                 }
181 |             ],
182 |             "description": "A PHP library for generating one time passwords according to RFC 4226 (HOTP Algorithm) and the RFC 6238 (TOTP Algorithm) and compatible with Google Authenticator",
183 |             "homepage": "https://github.com/Spomky-Labs/otphp",
184 |             "keywords": [
185 |                 "FreeOTP",
186 |                 "RFC 4226",
187 |                 "RFC 6238",
188 |                 "google authenticator",
189 |                 "hotp",
190 |                 "otp",
191 |                 "totp"
192 |             ],
193 |             "support": {
194 |                 "issues": "https://github.com/Spomky-Labs/otphp/issues",
195 |                 "source": "https://github.com/Spomky-Labs/otphp/tree/11.3.0"
196 |             },
197 |             "funding": [
198 |                 {
199 |                     "url": "https://github.com/Spomky",
200 |                     "type": "github"
201 |                 },
202 |                 {
203 |                     "url": "https://www.patreon.com/FlorentMorselli",
204 |                     "type": "patreon"
205 |                 }
206 |             ],
207 |             "install-path": "../spomky-labs/otphp"
208 |         },
209 |         {
210 |             "name": "symfony/deprecation-contracts",
211 |             "version": "v3.5.0",
212 |             "version_normalized": "3.5.0.0",
213 |             "source": {
214 |                 "type": "git",
215 |                 "url": "https://github.com/symfony/deprecation-contracts.git",
216 |                 "reference": "0e0d29ce1f20deffb4ab1b016a7257c4f1e789a1"
217 |             },
218 |             "dist": {
219 |                 "type": "zip",
220 |                 "url": "https://api.github.com/repos/symfony/deprecation-contracts/zipball/0e0d29ce1f20deffb4ab1b016a7257c4f1e789a1",
221 |                 "reference": "0e0d29ce1f20deffb4ab1b016a7257c4f1e789a1",
222 |                 "shasum": ""
223 |             },
224 |             "require": {
225 |                 "php": ">=8.1"
226 |             },
227 |             "time": "2024-04-18T09:32:20+00:00",
228 |             "type": "library",
229 |             "extra": {
230 |                 "branch-alias": {
231 |                     "dev-main": "3.5-dev"
232 |                 },
233 |                 "thanks": {
234 |                     "name": "symfony/contracts",
235 |                     "url": "https://github.com/symfony/contracts"
236 |                 }
237 |             },
238 |             "installation-source": "dist",
239 |             "autoload": {
240 |                 "files": [
241 |                     "function.php"
242 |                 ]
243 |             },
244 |             "notification-url": "https://packagist.org/downloads/",
245 |             "license": [
246 |                 "MIT"
247 |             ],
248 |             "authors": [
249 |                 {
250 |                     "name": "Nicolas Grekas",
251 |                     "email": "p@tchwork.com"
252 |                 },
253 |                 {
254 |                     "name": "Symfony Community",
255 |                     "homepage": "https://symfony.com/contributors"
256 |                 }
257 |             ],
258 |             "description": "A generic function and convention to trigger deprecation notices",
259 |             "homepage": "https://symfony.com",
260 |             "support": {
261 |                 "source": "https://github.com/symfony/deprecation-contracts/tree/v3.5.0"
262 |             },
263 |             "funding": [
264 |                 {
265 |                     "url": "https://symfony.com/sponsor",
266 |                     "type": "custom"
267 |                 },
268 |                 {
269 |                     "url": "https://github.com/fabpot",
270 |                     "type": "github"
271 |                 },
272 |                 {
273 |                     "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
274 |                     "type": "tidelift"
275 |                 }
276 |             ],
277 |             "install-path": "../symfony/deprecation-contracts"
278 |         }
279 |     ],
280 |     "dev": true,
281 |     "dev-package-names": []
282 | }
283 | 


--------------------------------------------------------------------------------
/vendor/composer/installed.php:
--------------------------------------------------------------------------------
 1 | <?php return array(
 2 |     'root' => array(
 3 |         'name' => '__root__',
 4 |         'pretty_version' => 'dev-master',
 5 |         'version' => 'dev-master',
 6 |         'reference' => 'dd3d84c5da821a2975df978ecc662191fee51fa1',
 7 |         'type' => 'library',
 8 |         'install_path' => __DIR__ . '/../../',
 9 |         'aliases' => array(),
10 |         'dev' => true,
11 |     ),
12 |     'versions' => array(
13 |         '__root__' => array(
14 |             'pretty_version' => 'dev-master',
15 |             'version' => 'dev-master',
16 |             'reference' => 'dd3d84c5da821a2975df978ecc662191fee51fa1',
17 |             'type' => 'library',
18 |             'install_path' => __DIR__ . '/../../',
19 |             'aliases' => array(),
20 |             'dev_requirement' => false,
21 |         ),
22 |         'paragonie/constant_time_encoding' => array(
23 |             'pretty_version' => 'v3.0.0',
24 |             'version' => '3.0.0.0',
25 |             'reference' => 'df1e7fde177501eee2037dd159cf04f5f301a512',
26 |             'type' => 'library',
27 |             'install_path' => __DIR__ . '/../paragonie/constant_time_encoding',
28 |             'aliases' => array(),
29 |             'dev_requirement' => false,
30 |         ),
31 |         'psr/clock' => array(
32 |             'pretty_version' => '1.0.0',
33 |             'version' => '1.0.0.0',
34 |             'reference' => 'e41a24703d4560fd0acb709162f73b8adfc3aa0d',
35 |             'type' => 'library',
36 |             'install_path' => __DIR__ . '/../psr/clock',
37 |             'aliases' => array(),
38 |             'dev_requirement' => false,
39 |         ),
40 |         'spomky-labs/otphp' => array(
41 |             'pretty_version' => '11.3.0',
42 |             'version' => '11.3.0.0',
43 |             'reference' => '2d8ccb5fc992b9cc65ef321fa4f00fefdb3f4b33',
44 |             'type' => 'library',
45 |             'install_path' => __DIR__ . '/../spomky-labs/otphp',
46 |             'aliases' => array(),
47 |             'dev_requirement' => false,
48 |         ),
49 |         'symfony/deprecation-contracts' => array(
50 |             'pretty_version' => 'v3.5.0',
51 |             'version' => '3.5.0.0',
52 |             'reference' => '0e0d29ce1f20deffb4ab1b016a7257c4f1e789a1',
53 |             'type' => 'library',
54 |             'install_path' => __DIR__ . '/../symfony/deprecation-contracts',
55 |             'aliases' => array(),
56 |             'dev_requirement' => false,
57 |         ),
58 |     ),
59 | );
60 | 


--------------------------------------------------------------------------------
/vendor/composer/platform_check.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // platform_check.php @generated by Composer
 4 | 
 5 | $issues = array();
 6 | 
 7 | if (!(PHP_VERSION_ID >= 80100)) {
 8 |     $issues[] = 'Your Composer dependencies require a PHP version ">= 8.1.0". You are running ' . PHP_VERSION . '.';
 9 | }
10 | 
11 | if ($issues) {
12 |     if (!headers_sent()) {
13 |         header('HTTP/1.1 500 Internal Server Error');
14 |     }
15 |     if (!ini_get('display_errors')) {
16 |         if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
17 |             fwrite(STDERR, 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . implode(PHP_EOL, $issues) . PHP_EOL.PHP_EOL);
18 |         } elseif (!headers_sent()) {
19 |             echo 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . str_replace('You are running '.PHP_VERSION.'.', '', implode(PHP_EOL, $issues)) . PHP_EOL.PHP_EOL;
20 |         }
21 |     }
22 |     trigger_error(
23 |         'Composer detected issues in your platform: ' . implode(' ', $issues),
24 |         E_USER_ERROR
25 |     );
26 | }
27 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 - 2022 Paragon Initiative Enterprises
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | ------------------------------------------------------------------------------
24 | This library was based on the work of Steve "Sc00bz" Thomas.
25 | ------------------------------------------------------------------------------
26 | 
27 | The MIT License (MIT)
28 | 
29 | Copyright (c) 2014 Steve Thomas
30 | 
31 | Permission is hereby granted, free of charge, to any person obtaining a copy
32 | of this software and associated documentation files (the "Software"), to deal
33 | in the Software without restriction, including without limitation the rights
34 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
35 | copies of the Software, and to permit persons to whom the Software is
36 | furnished to do so, subject to the following conditions:
37 | 
38 | The above copyright notice and this permission notice shall be included in all
39 | copies or substantial portions of the Software.
40 | 
41 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
42 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
43 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
44 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
45 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
46 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
47 | SOFTWARE.
48 | 
49 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/README.md:
--------------------------------------------------------------------------------
 1 | # Constant-Time Encoding
 2 | 
 3 | [![Build Status](https://github.com/paragonie/constant_time_encoding/actions/workflows/ci.yml/badge.svg)](https://github.com/paragonie/constant_time_encoding/actions)
 4 | [![Static Analysis](https://github.com/paragonie/constant_time_encoding/actions/workflows/psalm.yml/badge.svg)](https://github.com/paragonie/constant_time_encoding/actions)
 5 | [![Latest Stable Version](https://poser.pugx.org/paragonie/constant_time_encoding/v/stable)](https://packagist.org/packages/paragonie/constant_time_encoding)
 6 | [![Latest Unstable Version](https://poser.pugx.org/paragonie/constant_time_encoding/v/unstable)](https://packagist.org/packages/paragonie/constant_time_encoding)
 7 | [![License](https://poser.pugx.org/paragonie/constant_time_encoding/license)](https://packagist.org/packages/paragonie/constant_time_encoding)
 8 | [![Downloads](https://img.shields.io/packagist/dt/paragonie/constant_time_encoding.svg)](https://packagist.org/packages/paragonie/constant_time_encoding)
 9 | 
10 | Based on the [constant-time base64 implementation made by Steve "Sc00bz" Thomas](https://github.com/Sc00bz/ConstTimeEncoding),
11 | this library aims to offer character encoding functions that do not leak
12 | information about what you are encoding/decoding via processor cache 
13 | misses. Further reading on [cache-timing attacks](http://blog.ircmaxell.com/2014/11/its-all-about-time.html).
14 | 
15 | Our fork offers the following enhancements:
16 | 
17 | * `mbstring.func_overload` resistance
18 | * Unit tests
19 | * Composer- and Packagist-ready
20 | * Base16 encoding
21 | * Base32 encoding
22 | * Uses `pack()` and `unpack()` instead of `chr()` and `ord()`
23 | 
24 | ## PHP Version Requirements
25 | 
26 | Version 3 of this library should work on **PHP 8** or newer.
27 | 
28 | Version 2 of this library should work on **PHP 7** or newer. See [the v2.x branch](https://github.com/paragonie/constant_time_encoding/tree/v2.x).
29 | 
30 | For PHP 5 support, see [the v1.x branch](https://github.com/paragonie/constant_time_encoding/tree/v1.x).
31 | 
32 | If you are adding this as a dependency to a project intended to work on PHP 5 through 8.4, please set the required version to `^1|^2|^3`.
33 | 
34 | ## How to Install
35 | 
36 | ```sh
37 | composer require paragonie/constant_time_encoding
38 | ```
39 | 
40 | ## How to Use
41 | 
42 | ```php
43 | use ParagonIE\ConstantTime\Encoding;
44 | 
45 | // possibly (if applicable): 
46 | // require 'vendor/autoload.php';
47 | 
48 | $data = random_bytes(32);
49 | echo Encoding::base64Encode($data), "\n";
50 | echo Encoding::base32EncodeUpper($data), "\n";
51 | echo Encoding::base32Encode($data), "\n";
52 | echo Encoding::hexEncode($data), "\n";
53 | echo Encoding::hexEncodeUpper($data), "\n";
54 | ```
55 | 
56 | Example output:
57 |  
58 | ```
59 | 1VilPkeVqirlPifk5scbzcTTbMT2clp+Zkyv9VFFasE=
60 | 2VMKKPSHSWVCVZJ6E7SONRY3ZXCNG3GE6ZZFU7TGJSX7KUKFNLAQ====
61 | 2vmkkpshswvcvzj6e7sonry3zxcng3ge6zzfu7tgjsx7kukfnlaq====
62 | d558a53e4795aa2ae53e27e4e6c71bcdc4d36cc4f6725a7e664caff551456ac1
63 | D558A53E4795AA2AE53E27E4E6C71BDCC4D36CC4F6725A7E664CAFF551456AC1
64 | ```
65 | 
66 | If you only need a particular variant, you can just reference the 
67 | required class like so:
68 | 
69 | ```php
70 | use ParagonIE\ConstantTime\Base64;
71 | use ParagonIE\ConstantTime\Base32;
72 | 
73 | $data = random_bytes(32);
74 | echo Base64::encode($data), "\n";
75 | echo Base32::encode($data), "\n";
76 | ```
77 | 
78 | Example output:
79 | 
80 | ```
81 | 1VilPkeVqirlPifk5scbzcTTbMT2clp+Zkyv9VFFasE=
82 | 2vmkkpshswvcvzj6e7sonry3zxcng3ge6zzfu7tgjsx7kukfnlaq====
83 | ```
84 | 
85 | ## Support Contracts
86 | 
87 | If your company uses this library in their products or services, you may be
88 | interested in [purchasing a support contract from Paragon Initiative Enterprises](https://paragonie.com/enterprise).
89 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "paragonie/constant_time_encoding",
 3 |   "description": "Constant-time Implementations of RFC 4648 Encoding (Base-64, Base-32, Base-16)",
 4 |   "keywords": [
 5 |     "base64",
 6 |     "encoding",
 7 |     "rfc4648",
 8 |     "base32",
 9 |     "base16",
10 |     "hex",
11 |     "bin2hex",
12 |     "hex2bin",
13 |     "base64_encode",
14 |     "base64_decode",
15 |     "base32_encode",
16 |     "base32_decode"
17 |   ],
18 |   "license": "MIT",
19 |   "type": "library",
20 |   "authors": [
21 |       {
22 |         "name":     "Paragon Initiative Enterprises",
23 |         "email":    "security@paragonie.com",
24 |         "homepage": "https://paragonie.com",
25 |         "role":     "Maintainer"
26 |       },
27 |       {
28 |         "name":     "Steve 'Sc00bz' Thomas",
29 |         "email":    "steve@tobtu.com",
30 |         "homepage": "https://www.tobtu.com",
31 |         "role":     "Original Developer"
32 |       }
33 |   ],
34 |   "support": {
35 |     "issues":   "https://github.com/paragonie/constant_time_encoding/issues",
36 |     "email":    "info@paragonie.com",
37 |     "source":   "https://github.com/paragonie/constant_time_encoding"
38 |   },
39 |   "require": {
40 |     "php": "^8"
41 |   },
42 |   "require-dev": {
43 |     "phpunit/phpunit": "^9",
44 |     "vimeo/psalm": "^4|^5"
45 |   },
46 |   "autoload": {
47 |     "psr-4": {
48 |       "ParagonIE\\ConstantTime\\": "src/"
49 |     }
50 |   },
51 |   "autoload-dev": {
52 |     "psr-4": {
53 |       "ParagonIE\\ConstantTime\\Tests\\": "tests/"
54 |     }
55 |   }
56 | }
57 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/src/Base32Hex.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | namespace ParagonIE\ConstantTime;
  4 | 
  5 | /**
  6 |  *  Copyright (c) 2016 - 2022 Paragon Initiative Enterprises.
  7 |  *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
  8 |  *
  9 |  *  Permission is hereby granted, free of charge, to any person obtaining a copy
 10 |  *  of this software and associated documentation files (the "Software"), to deal
 11 |  *  in the Software without restriction, including without limitation the rights
 12 |  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 13 |  *  copies of the Software, and to permit persons to whom the Software is
 14 |  *  furnished to do so, subject to the following conditions:
 15 |  *
 16 |  *  The above copyright notice and this permission notice shall be included in all
 17 |  *  copies or substantial portions of the Software.
 18 |  *
 19 |  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 20 |  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 21 |  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 22 |  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 23 |  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 24 |  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 25 |  *  SOFTWARE.
 26 |  */
 27 | 
 28 | /**
 29 |  * Class Base32Hex
 30 |  * [0-9][A-V]
 31 |  *
 32 |  * @package ParagonIE\ConstantTime
 33 |  */
 34 | abstract class Base32Hex extends Base32
 35 | {
 36 |     /**
 37 |      * Uses bitwise operators instead of table-lookups to turn 5-bit integers
 38 |      * into 8-bit integers.
 39 |      *
 40 |      * @param int $src
 41 |      * @return int
 42 |      */
 43 |     protected static function decode5Bits(int $src): int
 44 |     {
 45 |         $ret = -1;
 46 | 
 47 |         // if ($src > 0x30 && $src < 0x3a) ret += $src - 0x2e + 1; // -47
 48 |         $ret += (((0x2f - $src) & ($src - 0x3a)) >> 8) & ($src - 47);
 49 | 
 50 |         // if ($src > 0x60 && $src < 0x77) ret += $src - 0x61 + 10 + 1; // -86
 51 |         $ret += (((0x60 - $src) & ($src - 0x77)) >> 8) & ($src - 86);
 52 | 
 53 |         return $ret;
 54 |     }
 55 | 
 56 |     /**
 57 |      * Uses bitwise operators instead of table-lookups to turn 5-bit integers
 58 |      * into 8-bit integers.
 59 |      *
 60 |      * @param int $src
 61 |      * @return int
 62 |      */
 63 |     protected static function decode5BitsUpper(int $src): int
 64 |     {
 65 |         $ret = -1;
 66 | 
 67 |         // if ($src > 0x30 && $src < 0x3a) ret += $src - 0x2e + 1; // -47
 68 |         $ret += (((0x2f - $src) & ($src - 0x3a)) >> 8) & ($src - 47);
 69 | 
 70 |         // if ($src > 0x40 && $src < 0x57) ret += $src - 0x41 + 10 + 1; // -54
 71 |         $ret += (((0x40 - $src) & ($src - 0x57)) >> 8) & ($src - 54);
 72 | 
 73 |         return $ret;
 74 |     }
 75 | 
 76 |     /**
 77 |      * Uses bitwise operators instead of table-lookups to turn 8-bit integers
 78 |      * into 5-bit integers.
 79 |      *
 80 |      * @param int $src
 81 |      * @return string
 82 |      */
 83 |     protected static function encode5Bits(int $src): string
 84 |     {
 85 |         $src += 0x30;
 86 | 
 87 |         // if ($src > 0x39) $src += 0x61 - 0x3a; // 39
 88 |         $src += ((0x39 - $src) >> 8) & 39;
 89 | 
 90 |         return \pack('C', $src);
 91 |     }
 92 | 
 93 |     /**
 94 |      * Uses bitwise operators instead of table-lookups to turn 8-bit integers
 95 |      * into 5-bit integers.
 96 |      *
 97 |      * Uppercase variant.
 98 |      *
 99 |      * @param int $src
100 |      * @return string
101 |      */
102 |     protected static function encode5BitsUpper(int $src): string
103 |     {
104 |         $src += 0x30;
105 | 
106 |         // if ($src > 0x39) $src += 0x41 - 0x3a; // 7
107 |         $src += ((0x39 - $src) >> 8) & 7;
108 | 
109 |         return \pack('C', $src);
110 |     }
111 | }


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/src/Base64.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | namespace ParagonIE\ConstantTime;
  4 | 
  5 | use InvalidArgumentException;
  6 | use RangeException;
  7 | use TypeError;
  8 | 
  9 | /**
 10 |  *  Copyright (c) 2016 - 2022 Paragon Initiative Enterprises.
 11 |  *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
 12 |  *
 13 |  *  Permission is hereby granted, free of charge, to any person obtaining a copy
 14 |  *  of this software and associated documentation files (the "Software"), to deal
 15 |  *  in the Software without restriction, including without limitation the rights
 16 |  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 17 |  *  copies of the Software, and to permit persons to whom the Software is
 18 |  *  furnished to do so, subject to the following conditions:
 19 |  *
 20 |  *  The above copyright notice and this permission notice shall be included in all
 21 |  *  copies or substantial portions of the Software.
 22 |  *
 23 |  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 24 |  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 25 |  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 26 |  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 27 |  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 28 |  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 29 |  *  SOFTWARE.
 30 |  */
 31 | 
 32 | /**
 33 |  * Class Base64
 34 |  * [A-Z][a-z][0-9]+/
 35 |  *
 36 |  * @package ParagonIE\ConstantTime
 37 |  */
 38 | abstract class Base64 implements EncoderInterface
 39 | {
 40 |     /**
 41 |      * Encode into Base64
 42 |      *
 43 |      * Base64 character set "[A-Z][a-z][0-9]+/"
 44 |      *
 45 |      * @param string $binString
 46 |      * @return string
 47 |      *
 48 |      * @throws TypeError
 49 |      */
 50 |     public static function encode(
 51 |         #[\SensitiveParameter]
 52 |         string $binString
 53 |     ): string {
 54 |         return static::doEncode($binString, true);
 55 |     }
 56 | 
 57 |     /**
 58 |      * Encode into Base64, no = padding
 59 |      *
 60 |      * Base64 character set "[A-Z][a-z][0-9]+/"
 61 |      *
 62 |      * @param string $src
 63 |      * @return string
 64 |      *
 65 |      * @throws TypeError
 66 |      */
 67 |     public static function encodeUnpadded(
 68 |         #[\SensitiveParameter]
 69 |         string $src
 70 |     ): string {
 71 |         return static::doEncode($src, false);
 72 |     }
 73 | 
 74 |     /**
 75 |      * @param string $src
 76 |      * @param bool $pad   Include = padding?
 77 |      * @return string
 78 |      *
 79 |      * @throws TypeError
 80 |      */
 81 |     protected static function doEncode(
 82 |         #[\SensitiveParameter]
 83 |         string $src,
 84 |         bool $pad = true
 85 |     ): string {
 86 |         $dest = '';
 87 |         $srcLen = Binary::safeStrlen($src);
 88 |         // Main loop (no padding):
 89 |         for ($i = 0; $i + 3 <= $srcLen; $i += 3) {
 90 |             /** @var array<int, int> $chunk */
 91 |             $chunk = \unpack('C*', Binary::safeSubstr($src, $i, 3));
 92 |             $b0 = $chunk[1];
 93 |             $b1 = $chunk[2];
 94 |             $b2 = $chunk[3];
 95 | 
 96 |             $dest .=
 97 |                 static::encode6Bits(               $b0 >> 2       ) .
 98 |                 static::encode6Bits((($b0 << 4) | ($b1 >> 4)) & 63) .
 99 |                 static::encode6Bits((($b1 << 2) | ($b2 >> 6)) & 63) .
100 |                 static::encode6Bits(  $b2                     & 63);
101 |         }
102 |         // The last chunk, which may have padding:
103 |         if ($i < $srcLen) {
104 |             /** @var array<int, int> $chunk */
105 |             $chunk = \unpack('C*', Binary::safeSubstr($src, $i, $srcLen - $i));
106 |             $b0 = $chunk[1];
107 |             if ($i + 1 < $srcLen) {
108 |                 $b1 = $chunk[2];
109 |                 $dest .=
110 |                     static::encode6Bits($b0 >> 2) .
111 |                     static::encode6Bits((($b0 << 4) | ($b1 >> 4)) & 63) .
112 |                     static::encode6Bits(($b1 << 2) & 63);
113 |                 if ($pad) {
114 |                     $dest .= '=';
115 |                 }
116 |             } else {
117 |                 $dest .=
118 |                     static::encode6Bits( $b0 >> 2) .
119 |                     static::encode6Bits(($b0 << 4) & 63);
120 |                 if ($pad) {
121 |                     $dest .= '==';
122 |                 }
123 |             }
124 |         }
125 |         return $dest;
126 |     }
127 | 
128 |     /**
129 |      * decode from base64 into binary
130 |      *
131 |      * Base64 character set "./[A-Z][a-z][0-9]"
132 |      *
133 |      * @param string $encodedString
134 |      * @param bool $strictPadding
135 |      * @return string
136 |      *
137 |      * @throws RangeException
138 |      * @throws TypeError
139 |      */
140 |     public static function decode(
141 |         #[\SensitiveParameter]
142 |         string $encodedString,
143 |         bool $strictPadding = false
144 |     ): string {
145 |         // Remove padding
146 |         $srcLen = Binary::safeStrlen($encodedString);
147 |         if ($srcLen === 0) {
148 |             return '';
149 |         }
150 | 
151 |         if ($strictPadding) {
152 |             if (($srcLen & 3) === 0) {
153 |                 if ($encodedString[$srcLen - 1] === '=') {
154 |                     $srcLen--;
155 |                     if ($encodedString[$srcLen - 1] === '=') {
156 |                         $srcLen--;
157 |                     }
158 |                 }
159 |             }
160 |             if (($srcLen & 3) === 1) {
161 |                 throw new RangeException(
162 |                     'Incorrect padding'
163 |                 );
164 |             }
165 |             if ($encodedString[$srcLen - 1] === '=') {
166 |                 throw new RangeException(
167 |                     'Incorrect padding'
168 |                 );
169 |             }
170 |         } else {
171 |             $encodedString = \rtrim($encodedString, '=');
172 |             $srcLen = Binary::safeStrlen($encodedString);
173 |         }
174 | 
175 |         $err = 0;
176 |         $dest = '';
177 |         // Main loop (no padding):
178 |         for ($i = 0; $i + 4 <= $srcLen; $i += 4) {
179 |             /** @var array<int, int> $chunk */
180 |             $chunk = \unpack('C*', Binary::safeSubstr($encodedString, $i, 4));
181 |             $c0 = static::decode6Bits($chunk[1]);
182 |             $c1 = static::decode6Bits($chunk[2]);
183 |             $c2 = static::decode6Bits($chunk[3]);
184 |             $c3 = static::decode6Bits($chunk[4]);
185 | 
186 |             $dest .= \pack(
187 |                 'CCC',
188 |                 ((($c0 << 2) | ($c1 >> 4)) & 0xff),
189 |                 ((($c1 << 4) | ($c2 >> 2)) & 0xff),
190 |                 ((($c2 << 6) |  $c3      ) & 0xff)
191 |             );
192 |             $err |= ($c0 | $c1 | $c2 | $c3) >> 8;
193 |         }
194 |         // The last chunk, which may have padding:
195 |         if ($i < $srcLen) {
196 |             /** @var array<int, int> $chunk */
197 |             $chunk = \unpack('C*', Binary::safeSubstr($encodedString, $i, $srcLen - $i));
198 |             $c0 = static::decode6Bits($chunk[1]);
199 | 
200 |             if ($i + 2 < $srcLen) {
201 |                 $c1 = static::decode6Bits($chunk[2]);
202 |                 $c2 = static::decode6Bits($chunk[3]);
203 |                 $dest .= \pack(
204 |                     'CC',
205 |                     ((($c0 << 2) | ($c1 >> 4)) & 0xff),
206 |                     ((($c1 << 4) | ($c2 >> 2)) & 0xff)
207 |                 );
208 |                 $err |= ($c0 | $c1 | $c2) >> 8;
209 |                 if ($strictPadding) {
210 |                     $err |= ($c2 << 6) & 0xff;
211 |                 }
212 |             } elseif ($i + 1 < $srcLen) {
213 |                 $c1 = static::decode6Bits($chunk[2]);
214 |                 $dest .= \pack(
215 |                     'C',
216 |                     ((($c0 << 2) | ($c1 >> 4)) & 0xff)
217 |                 );
218 |                 $err |= ($c0 | $c1) >> 8;
219 |                 if ($strictPadding) {
220 |                     $err |= ($c1 << 4) & 0xff;
221 |                 }
222 |             } elseif ($strictPadding) {
223 |                 $err |= 1;
224 |             }
225 |         }
226 |         $check = ($err === 0);
227 |         if (!$check) {
228 |             throw new RangeException(
229 |                 'Base64::decode() only expects characters in the correct base64 alphabet'
230 |             );
231 |         }
232 |         return $dest;
233 |     }
234 | 
235 |     /**
236 |      * @param string $encodedString
237 |      * @return string
238 |      */
239 |     public static function decodeNoPadding(
240 |         #[\SensitiveParameter]
241 |         string $encodedString
242 |     ): string {
243 |         $srcLen = Binary::safeStrlen($encodedString);
244 |         if ($srcLen === 0) {
245 |             return '';
246 |         }
247 |         if (($srcLen & 3) === 0) {
248 |             // If $strLen is not zero, and it is divisible by 4, then it's at least 4.
249 |             if ($encodedString[$srcLen - 1] === '=' || $encodedString[$srcLen - 2] === '=') {
250 |                 throw new InvalidArgumentException(
251 |                     "decodeNoPadding() doesn't tolerate padding"
252 |                 );
253 |             }
254 |         }
255 |         return static::decode(
256 |             $encodedString,
257 |             true
258 |         );
259 |     }
260 | 
261 |     /**
262 |      * Uses bitwise operators instead of table-lookups to turn 6-bit integers
263 |      * into 8-bit integers.
264 |      *
265 |      * Base64 character set:
266 |      * [A-Z]      [a-z]      [0-9]      +     /
267 |      * 0x41-0x5a, 0x61-0x7a, 0x30-0x39, 0x2b, 0x2f
268 |      *
269 |      * @param int $src
270 |      * @return int
271 |      */
272 |     protected static function decode6Bits(int $src): int
273 |     {
274 |         $ret = -1;
275 | 
276 |         // if ($src > 0x40 && $src < 0x5b) $ret += $src - 0x41 + 1; // -64
277 |         $ret += (((0x40 - $src) & ($src - 0x5b)) >> 8) & ($src - 64);
278 | 
279 |         // if ($src > 0x60 && $src < 0x7b) $ret += $src - 0x61 + 26 + 1; // -70
280 |         $ret += (((0x60 - $src) & ($src - 0x7b)) >> 8) & ($src - 70);
281 | 
282 |         // if ($src > 0x2f && $src < 0x3a) $ret += $src - 0x30 + 52 + 1; // 5
283 |         $ret += (((0x2f - $src) & ($src - 0x3a)) >> 8) & ($src + 5);
284 | 
285 |         // if ($src == 0x2b) $ret += 62 + 1;
286 |         $ret += (((0x2a - $src) & ($src - 0x2c)) >> 8) & 63;
287 | 
288 |         // if ($src == 0x2f) ret += 63 + 1;
289 |         $ret += (((0x2e - $src) & ($src - 0x30)) >> 8) & 64;
290 | 
291 |         return $ret;
292 |     }
293 | 
294 |     /**
295 |      * Uses bitwise operators instead of table-lookups to turn 8-bit integers
296 |      * into 6-bit integers.
297 |      *
298 |      * @param int $src
299 |      * @return string
300 |      */
301 |     protected static function encode6Bits(int $src): string
302 |     {
303 |         $diff = 0x41;
304 | 
305 |         // if ($src > 25) $diff += 0x61 - 0x41 - 26; // 6
306 |         $diff += ((25 - $src) >> 8) & 6;
307 | 
308 |         // if ($src > 51) $diff += 0x30 - 0x61 - 26; // -75
309 |         $diff -= ((51 - $src) >> 8) & 75;
310 | 
311 |         // if ($src > 61) $diff += 0x2b - 0x30 - 10; // -15
312 |         $diff -= ((61 - $src) >> 8) & 15;
313 | 
314 |         // if ($src > 62) $diff += 0x2f - 0x2b - 1; // 3
315 |         $diff += ((62 - $src) >> 8) & 3;
316 | 
317 |         return \pack('C', $src + $diff);
318 |     }
319 | }
320 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/src/Base64DotSlash.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | namespace ParagonIE\ConstantTime;
 4 | 
 5 | /**
 6 |  *  Copyright (c) 2016 - 2022 Paragon Initiative Enterprises.
 7 |  *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
 8 |  *
 9 |  *  Permission is hereby granted, free of charge, to any person obtaining a copy
10 |  *  of this software and associated documentation files (the "Software"), to deal
11 |  *  in the Software without restriction, including without limitation the rights
12 |  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 |  *  copies of the Software, and to permit persons to whom the Software is
14 |  *  furnished to do so, subject to the following conditions:
15 |  *
16 |  *  The above copyright notice and this permission notice shall be included in all
17 |  *  copies or substantial portions of the Software.
18 |  *
19 |  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 |  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 |  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 |  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 |  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 |  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 |  *  SOFTWARE.
26 |  */
27 | 
28 | /**
29 |  * Class Base64DotSlash
30 |  * ./[A-Z][a-z][0-9]
31 |  *
32 |  * @package ParagonIE\ConstantTime
33 |  */
34 | abstract class Base64DotSlash extends Base64
35 | {
36 |     /**
37 |      * Uses bitwise operators instead of table-lookups to turn 6-bit integers
38 |      * into 8-bit integers.
39 |      *
40 |      * Base64 character set:
41 |      * ./         [A-Z]      [a-z]     [0-9]
42 |      * 0x2e-0x2f, 0x41-0x5a, 0x61-0x7a, 0x30-0x39
43 |      *
44 |      * @param int $src
45 |      * @return int
46 |      */
47 |     protected static function decode6Bits(int $src): int
48 |     {
49 |         $ret = -1;
50 | 
51 |         // if ($src > 0x2d && $src < 0x30) ret += $src - 0x2e + 1; // -45
52 |         $ret += (((0x2d - $src) & ($src - 0x30)) >> 8) & ($src - 45);
53 | 
54 |         // if ($src > 0x40 && $src < 0x5b) ret += $src - 0x41 + 2 + 1; // -62
55 |         $ret += (((0x40 - $src) & ($src - 0x5b)) >> 8) & ($src - 62);
56 | 
57 |         // if ($src > 0x60 && $src < 0x7b) ret += $src - 0x61 + 28 + 1; // -68
58 |         $ret += (((0x60 - $src) & ($src - 0x7b)) >> 8) & ($src - 68);
59 | 
60 |         // if ($src > 0x2f && $src < 0x3a) ret += $src - 0x30 + 54 + 1; // 7
61 |         $ret += (((0x2f - $src) & ($src - 0x3a)) >> 8) & ($src + 7);
62 | 
63 |         return $ret;
64 |     }
65 | 
66 |     /**
67 |      * Uses bitwise operators instead of table-lookups to turn 8-bit integers
68 |      * into 6-bit integers.
69 |      *
70 |      * @param int $src
71 |      * @return string
72 |      */
73 |     protected static function encode6Bits(int $src): string
74 |     {
75 |         $src += 0x2e;
76 | 
77 |         // if ($src > 0x2f) $src += 0x41 - 0x30; // 17
78 |         $src += ((0x2f - $src) >> 8) & 17;
79 | 
80 |         // if ($src > 0x5a) $src += 0x61 - 0x5b; // 6
81 |         $src += ((0x5a - $src) >> 8) & 6;
82 | 
83 |         // if ($src > 0x7a) $src += 0x30 - 0x7b; // -75
84 |         $src -= ((0x7a - $src) >> 8) & 75;
85 | 
86 |         return \pack('C', $src);
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/src/Base64DotSlashOrdered.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | namespace ParagonIE\ConstantTime;
 4 | 
 5 | /**
 6 |  *  Copyright (c) 2016 - 2022 Paragon Initiative Enterprises.
 7 |  *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
 8 |  *
 9 |  *  Permission is hereby granted, free of charge, to any person obtaining a copy
10 |  *  of this software and associated documentation files (the "Software"), to deal
11 |  *  in the Software without restriction, including without limitation the rights
12 |  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 |  *  copies of the Software, and to permit persons to whom the Software is
14 |  *  furnished to do so, subject to the following conditions:
15 |  *
16 |  *  The above copyright notice and this permission notice shall be included in all
17 |  *  copies or substantial portions of the Software.
18 |  *
19 |  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 |  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 |  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 |  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 |  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 |  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 |  *  SOFTWARE.
26 |  */
27 | 
28 | /**
29 |  * Class Base64DotSlashOrdered
30 |  * ./[0-9][A-Z][a-z]
31 |  *
32 |  * @package ParagonIE\ConstantTime
33 |  */
34 | abstract class Base64DotSlashOrdered extends Base64
35 | {
36 |     /**
37 |      * Uses bitwise operators instead of table-lookups to turn 6-bit integers
38 |      * into 8-bit integers.
39 |      *
40 |      * Base64 character set:
41 |      * [.-9]      [A-Z]      [a-z]
42 |      * 0x2e-0x39, 0x41-0x5a, 0x61-0x7a
43 |      *
44 |      * @param int $src
45 |      * @return int
46 |      */
47 |     protected static function decode6Bits(int $src): int
48 |     {
49 |         $ret = -1;
50 | 
51 |         // if ($src > 0x2d && $src < 0x3a) ret += $src - 0x2e + 1; // -45
52 |         $ret += (((0x2d - $src) & ($src - 0x3a)) >> 8) & ($src - 45);
53 | 
54 |         // if ($src > 0x40 && $src < 0x5b) ret += $src - 0x41 + 12 + 1; // -52
55 |         $ret += (((0x40 - $src) & ($src - 0x5b)) >> 8) & ($src - 52);
56 | 
57 |         // if ($src > 0x60 && $src < 0x7b) ret += $src - 0x61 + 38 + 1; // -58
58 |         $ret += (((0x60 - $src) & ($src - 0x7b)) >> 8) & ($src - 58);
59 | 
60 |         return $ret;
61 |     }
62 | 
63 |     /**
64 |      * Uses bitwise operators instead of table-lookups to turn 8-bit integers
65 |      * into 6-bit integers.
66 |      *
67 |      * @param int $src
68 |      * @return string
69 |      */
70 |     protected static function encode6Bits(int $src): string
71 |     {
72 |         $src += 0x2e;
73 | 
74 |         // if ($src > 0x39) $src += 0x41 - 0x3a; // 7
75 |         $src += ((0x39 - $src) >> 8) & 7;
76 | 
77 |         // if ($src > 0x5a) $src += 0x61 - 0x5b; // 6
78 |         $src += ((0x5a - $src) >> 8) & 6;
79 | 
80 |         return \pack('C', $src);
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/src/Base64UrlSafe.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | namespace ParagonIE\ConstantTime;
 4 | 
 5 | /**
 6 |  *  Copyright (c) 2016 - 2022 Paragon Initiative Enterprises.
 7 |  *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
 8 |  *
 9 |  *  Permission is hereby granted, free of charge, to any person obtaining a copy
10 |  *  of this software and associated documentation files (the "Software"), to deal
11 |  *  in the Software without restriction, including without limitation the rights
12 |  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 |  *  copies of the Software, and to permit persons to whom the Software is
14 |  *  furnished to do so, subject to the following conditions:
15 |  *
16 |  *  The above copyright notice and this permission notice shall be included in all
17 |  *  copies or substantial portions of the Software.
18 |  *
19 |  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 |  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 |  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 |  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 |  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 |  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 |  *  SOFTWARE.
26 |  */
27 | 
28 | /**
29 |  * Class Base64UrlSafe
30 |  * [A-Z][a-z][0-9]\-_
31 |  *
32 |  * @package ParagonIE\ConstantTime
33 |  */
34 | abstract class Base64UrlSafe extends Base64
35 | {
36 | 
37 |     /**
38 |      * Uses bitwise operators instead of table-lookups to turn 6-bit integers
39 |      * into 8-bit integers.
40 |      *
41 |      * Base64 character set:
42 |      * [A-Z]      [a-z]      [0-9]      -     _
43 |      * 0x41-0x5a, 0x61-0x7a, 0x30-0x39, 0x2d, 0x5f
44 |      *
45 |      * @param int $src
46 |      * @return int
47 |      */
48 |     protected static function decode6Bits(int $src): int
49 |     {
50 |         $ret = -1;
51 | 
52 |         // if ($src > 0x40 && $src < 0x5b) $ret += $src - 0x41 + 1; // -64
53 |         $ret += (((0x40 - $src) & ($src - 0x5b)) >> 8) & ($src - 64);
54 | 
55 |         // if ($src > 0x60 && $src < 0x7b) $ret += $src - 0x61 + 26 + 1; // -70
56 |         $ret += (((0x60 - $src) & ($src - 0x7b)) >> 8) & ($src - 70);
57 | 
58 |         // if ($src > 0x2f && $src < 0x3a) $ret += $src - 0x30 + 52 + 1; // 5
59 |         $ret += (((0x2f - $src) & ($src - 0x3a)) >> 8) & ($src + 5);
60 | 
61 |         // if ($src == 0x2c) $ret += 62 + 1;
62 |         $ret += (((0x2c - $src) & ($src - 0x2e)) >> 8) & 63;
63 | 
64 |         // if ($src == 0x5f) ret += 63 + 1;
65 |         $ret += (((0x5e - $src) & ($src - 0x60)) >> 8) & 64;
66 | 
67 |         return $ret;
68 |     }
69 | 
70 |     /**
71 |      * Uses bitwise operators instead of table-lookups to turn 8-bit integers
72 |      * into 6-bit integers.
73 |      *
74 |      * @param int $src
75 |      * @return string
76 |      */
77 |     protected static function encode6Bits(int $src): string
78 |     {
79 |         $diff = 0x41;
80 | 
81 |         // if ($src > 25) $diff += 0x61 - 0x41 - 26; // 6
82 |         $diff += ((25 - $src) >> 8) & 6;
83 | 
84 |         // if ($src > 51) $diff += 0x30 - 0x61 - 26; // -75
85 |         $diff -= ((51 - $src) >> 8) & 75;
86 | 
87 |         // if ($src > 61) $diff += 0x2d - 0x30 - 10; // -13
88 |         $diff -= ((61 - $src) >> 8) & 13;
89 | 
90 |         // if ($src > 62) $diff += 0x5f - 0x2b - 1; // 3
91 |         $diff += ((62 - $src) >> 8) & 49;
92 | 
93 |         return \pack('C', $src + $diff);
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/src/Binary.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | namespace ParagonIE\ConstantTime;
 4 | 
 5 | use TypeError;
 6 | 
 7 | /**
 8 |  *  Copyright (c) 2016 - 2022 Paragon Initiative Enterprises.
 9 |  *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
10 |  *
11 |  *  Permission is hereby granted, free of charge, to any person obtaining a copy
12 |  *  of this software and associated documentation files (the "Software"), to deal
13 |  *  in the Software without restriction, including without limitation the rights
14 |  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 |  *  copies of the Software, and to permit persons to whom the Software is
16 |  *  furnished to do so, subject to the following conditions:
17 |  *
18 |  *  The above copyright notice and this permission notice shall be included in all
19 |  *  copies or substantial portions of the Software.
20 |  *
21 |  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 |  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 |  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24 |  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 |  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 |  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27 |  *  SOFTWARE.
28 |  */
29 | 
30 | /**
31 |  * Class Binary
32 |  *
33 |  * Binary string operators that don't choke on
34 |  * mbstring.func_overload
35 |  *
36 |  * @package ParagonIE\ConstantTime
37 |  */
38 | abstract class Binary
39 | {
40 |     /**
41 |      * Safe string length
42 |      *
43 |      * @ref mbstring.func_overload
44 |      *
45 |      * @param string $str
46 |      * @return int
47 |      */
48 |     public static function safeStrlen(
49 |         #[\SensitiveParameter]
50 |         string $str
51 |     ): int {
52 |         if (\function_exists('mb_strlen')) {
53 |             // mb_strlen in PHP 7.x can return false.
54 |             /** @psalm-suppress RedundantCast */
55 |             return (int) \mb_strlen($str, '8bit');
56 |         } else {
57 |             return \strlen($str);
58 |         }
59 |     }
60 | 
61 |     /**
62 |      * Safe substring
63 |      *
64 |      * @ref mbstring.func_overload
65 |      *
66 |      * @staticvar boolean $exists
67 |      * @param string $str
68 |      * @param int $start
69 |      * @param ?int $length
70 |      * @return string
71 |      *
72 |      * @throws TypeError
73 |      */
74 |     public static function safeSubstr(
75 |         #[\SensitiveParameter]
76 |         string $str,
77 |         int $start = 0,
78 |         ?int $length = null
79 |     ): string {
80 |         if ($length === 0) {
81 |             return '';
82 |         }
83 |         if (\function_exists('mb_substr')) {
84 |             return \mb_substr($str, $start, $length, '8bit');
85 |         }
86 |         // Unlike mb_substr(), substr() doesn't accept NULL for length
87 |         if ($length !== null) {
88 |             return \substr($str, $start, $length);
89 |         } else {
90 |             return \substr($str, $start);
91 |         }
92 |     }
93 | }
94 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/src/EncoderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | namespace ParagonIE\ConstantTime;
 4 | 
 5 | /**
 6 |  *  Copyright (c) 2016 - 2022 Paragon Initiative Enterprises.
 7 |  *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
 8 |  *
 9 |  *  Permission is hereby granted, free of charge, to any person obtaining a copy
10 |  *  of this software and associated documentation files (the "Software"), to deal
11 |  *  in the Software without restriction, including without limitation the rights
12 |  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 |  *  copies of the Software, and to permit persons to whom the Software is
14 |  *  furnished to do so, subject to the following conditions:
15 |  *
16 |  *  The above copyright notice and this permission notice shall be included in all
17 |  *  copies or substantial portions of the Software.
18 |  *
19 |  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 |  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 |  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 |  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 |  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 |  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 |  *  SOFTWARE.
26 |  */
27 | 
28 | /**
29 |  * Interface EncoderInterface
30 |  * @package ParagonIE\ConstantTime
31 |  */
32 | interface EncoderInterface
33 | {
34 |     /**
35 |      * Convert a binary string into a hexadecimal string without cache-timing
36 |      * leaks
37 |      *
38 |      * @param string $binString (raw binary)
39 |      * @return string
40 |      */
41 |     public static function encode(string $binString): string;
42 | 
43 |     /**
44 |      * Convert a binary string into a hexadecimal string without cache-timing
45 |      * leaks
46 |      *
47 |      * @param string $encodedString
48 |      * @param bool $strictPadding Error on invalid padding
49 |      * @return string (raw binary)
50 |      */
51 |     public static function decode(string $encodedString, bool $strictPadding = false): string;
52 | }
53 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/src/Encoding.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | namespace ParagonIE\ConstantTime;
  4 | 
  5 | use TypeError;
  6 | 
  7 | /**
  8 |  *  Copyright (c) 2016 - 2022 Paragon Initiative Enterprises.
  9 |  *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
 10 |  *
 11 |  *  Permission is hereby granted, free of charge, to any person obtaining a copy
 12 |  *  of this software and associated documentation files (the "Software"), to deal
 13 |  *  in the Software without restriction, including without limitation the rights
 14 |  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 15 |  *  copies of the Software, and to permit persons to whom the Software is
 16 |  *  furnished to do so, subject to the following conditions:
 17 |  *
 18 |  *  The above copyright notice and this permission notice shall be included in all
 19 |  *  copies or substantial portions of the Software.
 20 |  *
 21 |  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 22 |  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 23 |  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 24 |  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 25 |  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 26 |  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 27 |  *  SOFTWARE.
 28 |  */
 29 | 
 30 | /**
 31 |  * Class Encoding
 32 |  * @package ParagonIE\ConstantTime
 33 |  */
 34 | abstract class Encoding
 35 | {
 36 |     /**
 37 |      * RFC 4648 Base32 encoding
 38 |      *
 39 |      * @param string $str
 40 |      * @return string
 41 |      * @throws TypeError
 42 |      */
 43 |     public static function base32Encode(
 44 |         #[\SensitiveParameter]
 45 |         string $str
 46 |     ): string {
 47 |         return Base32::encode($str);
 48 |     }
 49 | 
 50 |     /**
 51 |      * RFC 4648 Base32 encoding
 52 |      *
 53 |      * @param string $str
 54 |      * @return string
 55 |      * @throws TypeError
 56 |      */
 57 |     public static function base32EncodeUpper(
 58 |         #[\SensitiveParameter]
 59 |         string $str
 60 |     ): string {
 61 |         return Base32::encodeUpper($str);
 62 |     }
 63 | 
 64 |     /**
 65 |      * RFC 4648 Base32 decoding
 66 |      *
 67 |      * @param string $str
 68 |      * @return string
 69 |      * @throws TypeError
 70 |      */
 71 |     public static function base32Decode(
 72 |         #[\SensitiveParameter]
 73 |         string $str
 74 |     ): string {
 75 |         return Base32::decode($str);
 76 |     }
 77 | 
 78 |     /**
 79 |      * RFC 4648 Base32 decoding
 80 |      *
 81 |      * @param string $str
 82 |      * @return string
 83 |      * @throws TypeError
 84 |      */
 85 |     public static function base32DecodeUpper(
 86 |         #[\SensitiveParameter]
 87 |         string $str
 88 |     ): string {
 89 |         return Base32::decodeUpper($str);
 90 |     }
 91 | 
 92 |     /**
 93 |      * RFC 4648 Base32 encoding
 94 |      *
 95 |      * @param string $str
 96 |      * @return string
 97 |      * @throws TypeError
 98 |      */
 99 |     public static function base32HexEncode(
100 |         #[\SensitiveParameter]
101 |         string $str
102 |     ): string {
103 |         return Base32Hex::encode($str);
104 |     }
105 | 
106 |     /**
107 |      * RFC 4648 Base32Hex encoding
108 |      *
109 |      * @param string $str
110 |      * @return string
111 |      * @throws TypeError
112 |      */
113 |     public static function base32HexEncodeUpper(
114 |         #[\SensitiveParameter]
115 |         string $str
116 |     ): string {
117 |         return Base32Hex::encodeUpper($str);
118 |     }
119 | 
120 |     /**
121 |      * RFC 4648 Base32Hex decoding
122 |      *
123 |      * @param string $str
124 |      * @return string
125 |      * @throws TypeError
126 |      */
127 |     public static function base32HexDecode(
128 |         #[\SensitiveParameter]
129 |         string $str
130 |     ): string {
131 |         return Base32Hex::decode($str);
132 |     }
133 | 
134 |     /**
135 |      * RFC 4648 Base32Hex decoding
136 |      *
137 |      * @param string $str
138 |      * @return string
139 |      * @throws TypeError
140 |      */
141 |     public static function base32HexDecodeUpper(
142 |         #[\SensitiveParameter]
143 |         string $str
144 |     ): string {
145 |         return Base32Hex::decodeUpper($str);
146 |     }
147 | 
148 |     /**
149 |      * RFC 4648 Base64 encoding
150 |      *
151 |      * @param string $str
152 |      * @return string
153 |      * @throws TypeError
154 |      */
155 |     public static function base64Encode(
156 |         #[\SensitiveParameter]
157 |         string $str
158 |     ): string {
159 |         return Base64::encode($str);
160 |     }
161 | 
162 |     /**
163 |      * RFC 4648 Base64 decoding
164 |      *
165 |      * @param string $str
166 |      * @return string
167 |      * @throws TypeError
168 |      */
169 |     public static function base64Decode(
170 |         #[\SensitiveParameter]
171 |         string $str
172 |     ): string {
173 |         return Base64::decode($str);
174 |     }
175 | 
176 |     /**
177 |      * Encode into Base64
178 |      *
179 |      * Base64 character set "./[A-Z][a-z][0-9]"
180 |      * @param string $str
181 |      * @return string
182 |      * @throws TypeError
183 |      */
184 |     public static function base64EncodeDotSlash(
185 |         #[\SensitiveParameter]
186 |         string $str
187 |     ): string {
188 |         return Base64DotSlash::encode($str);
189 |     }
190 | 
191 |     /**
192 |      * Decode from base64 to raw binary
193 |      *
194 |      * Base64 character set "./[A-Z][a-z][0-9]"
195 |      *
196 |      * @param string $str
197 |      * @return string
198 |      * @throws \RangeException
199 |      * @throws TypeError
200 |      */
201 |     public static function base64DecodeDotSlash(
202 |         #[\SensitiveParameter]
203 |         string $str
204 |     ): string {
205 |         return Base64DotSlash::decode($str);
206 |     }
207 | 
208 |     /**
209 |      * Encode into Base64
210 |      *
211 |      * Base64 character set "[.-9][A-Z][a-z]" or "./[0-9][A-Z][a-z]"
212 |      * @param string $str
213 |      * @return string
214 |      * @throws TypeError
215 |      */
216 |     public static function base64EncodeDotSlashOrdered(
217 |         #[\SensitiveParameter]
218 |         string $str
219 |     ): string {
220 |         return Base64DotSlashOrdered::encode($str);
221 |     }
222 | 
223 |     /**
224 |      * Decode from base64 to raw binary
225 |      *
226 |      * Base64 character set "[.-9][A-Z][a-z]" or "./[0-9][A-Z][a-z]"
227 |      *
228 |      * @param string $str
229 |      * @return string
230 |      * @throws \RangeException
231 |      * @throws TypeError
232 |      */
233 |     public static function base64DecodeDotSlashOrdered(
234 |         #[\SensitiveParameter]
235 |         string $str
236 |     ): string {
237 |         return Base64DotSlashOrdered::decode($str);
238 |     }
239 | 
240 |     /**
241 |      * Convert a binary string into a hexadecimal string without cache-timing
242 |      * leaks
243 |      *
244 |      * @param string $bin_string (raw binary)
245 |      * @return string
246 |      * @throws TypeError
247 |      */
248 |     public static function hexEncode(
249 |         #[\SensitiveParameter]
250 |         string $bin_string
251 |     ): string {
252 |         return Hex::encode($bin_string);
253 |     }
254 | 
255 |     /**
256 |      * Convert a hexadecimal string into a binary string without cache-timing
257 |      * leaks
258 |      *
259 |      * @param string $hex_string
260 |      * @return string (raw binary)
261 |      * @throws \RangeException
262 |      */
263 |     public static function hexDecode(
264 |         #[\SensitiveParameter]
265 |         string $hex_string
266 |     ): string {
267 |         return Hex::decode($hex_string);
268 |     }
269 | 
270 |     /**
271 |      * Convert a binary string into a hexadecimal string without cache-timing
272 |      * leaks
273 |      *
274 |      * @param string $bin_string (raw binary)
275 |      * @return string
276 |      * @throws TypeError
277 |      */
278 |     public static function hexEncodeUpper(
279 |         #[\SensitiveParameter]
280 |         string $bin_string
281 |     ): string {
282 |         return Hex::encodeUpper($bin_string);
283 |     }
284 | 
285 |     /**
286 |      * Convert a binary string into a hexadecimal string without cache-timing
287 |      * leaks
288 |      *
289 |      * @param string $bin_string (raw binary)
290 |      * @return string
291 |      */
292 |     public static function hexDecodeUpper(
293 |         #[\SensitiveParameter]
294 |         string $bin_string
295 |     ): string {
296 |         return Hex::decode($bin_string);
297 |     }
298 | }
299 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/src/Hex.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | namespace ParagonIE\ConstantTime;
  4 | 
  5 | use RangeException;
  6 | use TypeError;
  7 | 
  8 | /**
  9 |  *  Copyright (c) 2016 - 2022 Paragon Initiative Enterprises.
 10 |  *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
 11 |  *
 12 |  *  Permission is hereby granted, free of charge, to any person obtaining a copy
 13 |  *  of this software and associated documentation files (the "Software"), to deal
 14 |  *  in the Software without restriction, including without limitation the rights
 15 |  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 16 |  *  copies of the Software, and to permit persons to whom the Software is
 17 |  *  furnished to do so, subject to the following conditions:
 18 |  *
 19 |  *  The above copyright notice and this permission notice shall be included in all
 20 |  *  copies or substantial portions of the Software.
 21 |  *
 22 |  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 23 |  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 24 |  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 25 |  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 26 |  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 27 |  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 28 |  *  SOFTWARE.
 29 |  */
 30 | 
 31 | /**
 32 |  * Class Hex
 33 |  * @package ParagonIE\ConstantTime
 34 |  */
 35 | abstract class Hex implements EncoderInterface
 36 | {
 37 |     /**
 38 |      * Convert a binary string into a hexadecimal string without cache-timing
 39 |      * leaks
 40 |      *
 41 |      * @param string $binString (raw binary)
 42 |      * @return string
 43 |      * @throws TypeError
 44 |      */
 45 |     public static function encode(
 46 |         #[\SensitiveParameter]
 47 |         string $binString
 48 |     ): string {
 49 |         $hex = '';
 50 |         $len = Binary::safeStrlen($binString);
 51 |         for ($i = 0; $i < $len; ++$i) {
 52 |             /** @var array<int, int> $chunk */
 53 |             $chunk = \unpack('C', $binString[$i]);
 54 |             $c = $chunk[1] & 0xf;
 55 |             $b = $chunk[1] >> 4;
 56 | 
 57 |             $hex .= \pack(
 58 |                 'CC',
 59 |                 (87 + $b + ((($b - 10) >> 8) & ~38)),
 60 |                 (87 + $c + ((($c - 10) >> 8) & ~38))
 61 |             );
 62 |         }
 63 |         return $hex;
 64 |     }
 65 | 
 66 |     /**
 67 |      * Convert a binary string into a hexadecimal string without cache-timing
 68 |      * leaks, returning uppercase letters (as per RFC 4648)
 69 |      *
 70 |      * @param string $binString (raw binary)
 71 |      * @return string
 72 |      * @throws TypeError
 73 |      */
 74 |     public static function encodeUpper(
 75 |         #[\SensitiveParameter]
 76 |         string $binString
 77 |     ): string {
 78 |         $hex = '';
 79 |         $len = Binary::safeStrlen($binString);
 80 | 
 81 |         for ($i = 0; $i < $len; ++$i) {
 82 |             /** @var array<int, int> $chunk */
 83 |             $chunk = \unpack('C', $binString[$i]);
 84 |             $c = $chunk[1] & 0xf;
 85 |             $b = $chunk[1] >> 4;
 86 | 
 87 |             $hex .= \pack(
 88 |                 'CC',
 89 |                 (55 + $b + ((($b - 10) >> 8) & ~6)),
 90 |                 (55 + $c + ((($c - 10) >> 8) & ~6))
 91 |             );
 92 |         }
 93 |         return $hex;
 94 |     }
 95 | 
 96 |     /**
 97 |      * Convert a hexadecimal string into a binary string without cache-timing
 98 |      * leaks
 99 |      *
100 |      * @param string $encodedString
101 |      * @param bool $strictPadding
102 |      * @return string (raw binary)
103 |      * @throws RangeException
104 |      */
105 |     public static function decode(
106 |         #[\SensitiveParameter]
107 |         string $encodedString,
108 |         bool $strictPadding = false
109 |     ): string {
110 |         $hex_pos = 0;
111 |         $bin = '';
112 |         $c_acc = 0;
113 |         $hex_len = Binary::safeStrlen($encodedString);
114 |         $state = 0;
115 |         if (($hex_len & 1) !== 0) {
116 |             if ($strictPadding) {
117 |                 throw new RangeException(
118 |                     'Expected an even number of hexadecimal characters'
119 |                 );
120 |             } else {
121 |                 $encodedString = '0' . $encodedString;
122 |                 ++$hex_len;
123 |             }
124 |         }
125 | 
126 |         /** @var array<int, int> $chunk */
127 |         $chunk = \unpack('C*', $encodedString);
128 |         while ($hex_pos < $hex_len) {
129 |             ++$hex_pos;
130 |             $c = $chunk[$hex_pos];
131 |             $c_num = $c ^ 48;
132 |             $c_num0 = ($c_num - 10) >> 8;
133 |             $c_alpha = ($c & ~32) - 55;
134 |             $c_alpha0 = (($c_alpha - 10) ^ ($c_alpha - 16)) >> 8;
135 | 
136 |             if (($c_num0 | $c_alpha0) === 0) {
137 |                 throw new RangeException(
138 |                     'Expected hexadecimal character'
139 |                 );
140 |             }
141 |             $c_val = ($c_num0 & $c_num) | ($c_alpha & $c_alpha0);
142 |             if ($state === 0) {
143 |                 $c_acc = $c_val * 16;
144 |             } else {
145 |                 $bin .= \pack('C', $c_acc | $c_val);
146 |             }
147 |             $state ^= 1;
148 |         }
149 |         return $bin;
150 |     }
151 | }
152 | 


--------------------------------------------------------------------------------
/vendor/paragonie/constant_time_encoding/src/RFC4648.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | namespace ParagonIE\ConstantTime;
  4 | 
  5 | use TypeError;
  6 | 
  7 | /**
  8 |  *  Copyright (c) 2016 - 2022 Paragon Initiative Enterprises.
  9 |  *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
 10 |  *
 11 |  *  Permission is hereby granted, free of charge, to any person obtaining a copy
 12 |  *  of this software and associated documentation files (the "Software"), to deal
 13 |  *  in the Software without restriction, including without limitation the rights
 14 |  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 15 |  *  copies of the Software, and to permit persons to whom the Software is
 16 |  *  furnished to do so, subject to the following conditions:
 17 |  *
 18 |  *  The above copyright notice and this permission notice shall be included in all
 19 |  *  copies or substantial portions of the Software.
 20 |  *
 21 |  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 22 |  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 23 |  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 24 |  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 25 |  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 26 |  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 27 |  *  SOFTWARE.
 28 |  */
 29 | 
 30 | /**
 31 |  * Class RFC4648
 32 |  *
 33 |  * This class conforms strictly to the RFC
 34 |  *
 35 |  * @package ParagonIE\ConstantTime
 36 |  */
 37 | abstract class RFC4648
 38 | {
 39 |     /**
 40 |      * RFC 4648 Base64 encoding
 41 |      *
 42 |      * "foo" -> "Zm9v"
 43 |      *
 44 |      * @param string $str
 45 |      * @return string
 46 |      *
 47 |      * @throws TypeError
 48 |      */
 49 |     public static function base64Encode(
 50 |         #[\SensitiveParameter]
 51 |         string $str
 52 |     ): string {
 53 |         return Base64::encode($str);
 54 |     }
 55 | 
 56 |     /**
 57 |      * RFC 4648 Base64 decoding
 58 |      *
 59 |      * "Zm9v" -> "foo"
 60 |      *
 61 |      * @param string $str
 62 |      * @return string
 63 |      *
 64 |      * @throws TypeError
 65 |      */
 66 |     public static function base64Decode(
 67 |         #[\SensitiveParameter]
 68 |         string $str
 69 |     ): string {
 70 |         return Base64::decode($str, true);
 71 |     }
 72 | 
 73 |     /**
 74 |      * RFC 4648 Base64 (URL Safe) encoding
 75 |      *
 76 |      * "foo" -> "Zm9v"
 77 |      *
 78 |      * @param string $str
 79 |      * @return string
 80 |      *
 81 |      * @throws TypeError
 82 |      */
 83 |     public static function base64UrlSafeEncode(
 84 |         #[\SensitiveParameter]
 85 |         string $str
 86 |     ): string {
 87 |         return Base64UrlSafe::encode($str);
 88 |     }
 89 | 
 90 |     /**
 91 |      * RFC 4648 Base64 (URL Safe) decoding
 92 |      *
 93 |      * "Zm9v" -> "foo"
 94 |      *
 95 |      * @param string $str
 96 |      * @return string
 97 |      *
 98 |      * @throws TypeError
 99 |      */
100 |     public static function base64UrlSafeDecode(
101 |         #[\SensitiveParameter]
102 |         string $str
103 |     ): string {
104 |         return Base64UrlSafe::decode($str, true);
105 |     }
106 | 
107 |     /**
108 |      * RFC 4648 Base32 encoding
109 |      *
110 |      * "foo" -> "MZXW6==="
111 |      *
112 |      * @param string $str
113 |      * @return string
114 |      *
115 |      * @throws TypeError
116 |      */
117 |     public static function base32Encode(
118 |         #[\SensitiveParameter]
119 |         string $str
120 |     ): string {
121 |         return Base32::encodeUpper($str);
122 |     }
123 | 
124 |     /**
125 |      * RFC 4648 Base32 encoding
126 |      *
127 |      * "MZXW6===" -> "foo"
128 |      *
129 |      * @param string $str
130 |      * @return string
131 |      *
132 |      * @throws TypeError
133 |      */
134 |     public static function base32Decode(
135 |         #[\SensitiveParameter]
136 |         string $str
137 |     ): string {
138 |         return Base32::decodeUpper($str, true);
139 |     }
140 | 
141 |     /**
142 |      * RFC 4648 Base32-Hex encoding
143 |      *
144 |      * "foo" -> "CPNMU==="
145 |      *
146 |      * @param string $str
147 |      * @return string
148 |      *
149 |      * @throws TypeError
150 |      */
151 |     public static function base32HexEncode(
152 |         #[\SensitiveParameter]
153 |         string $str
154 |     ): string {
155 |         return Base32::encodeUpper($str);
156 |     }
157 | 
158 |     /**
159 |      * RFC 4648 Base32-Hex decoding
160 |      *
161 |      * "CPNMU===" -> "foo"
162 |      *
163 |      * @param string $str
164 |      * @return string
165 |      *
166 |      * @throws TypeError
167 |      */
168 |     public static function base32HexDecode(
169 |         #[\SensitiveParameter]
170 |         string $str
171 |     ): string {
172 |         return Base32::decodeUpper($str, true);
173 |     }
174 | 
175 |     /**
176 |      * RFC 4648 Base16 decoding
177 |      *
178 |      * "foo" -> "666F6F"
179 |      *
180 |      * @param string $str
181 |      * @return string
182 |      *
183 |      * @throws TypeError
184 |      */
185 |     public static function base16Encode(
186 |         #[\SensitiveParameter]
187 |         string $str
188 |     ): string {
189 |         return Hex::encodeUpper($str);
190 |     }
191 | 
192 |     /**
193 |      * RFC 4648 Base16 decoding
194 |      *
195 |      * "666F6F" -> "foo"
196 |      *
197 |      * @param string $str
198 |      * @return string
199 |      */
200 |     public static function base16Decode(
201 |         #[\SensitiveParameter]
202 |         string $str
203 |     ): string {
204 |         return Hex::decode($str, true);
205 |     }
206 | }
207 | 


--------------------------------------------------------------------------------
/vendor/psr/clock/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | All notable changes to this project will be documented in this file, in reverse chronological order by release.
 4 | 
 5 | ## 1.0.0
 6 | 
 7 | First stable release after PSR-20 acceptance
 8 | 
 9 | ## 0.1.0
10 | 
11 | First release
12 | 


--------------------------------------------------------------------------------
/vendor/psr/clock/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2017 PHP Framework Interoperability Group
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/vendor/psr/clock/README.md:
--------------------------------------------------------------------------------
 1 | # PSR Clock
 2 | 
 3 | This repository holds the interface for [PSR-20][psr-url].
 4 | 
 5 | Note that this is not a clock of its own. It is merely an interface that
 6 | describes a clock. See the specification for more details.
 7 | 
 8 | ## Installation
 9 | 
10 | ```bash
11 | composer require psr/clock
12 | ```
13 | 
14 | ## Usage
15 | 
16 | If you need a clock, you can use the interface like this:
17 | 
18 | ```php
19 | <?php
20 | 
21 | use Psr\Clock\ClockInterface;
22 | 
23 | class Foo
24 | {
25 |     private ClockInterface $clock;
26 | 
27 |     public function __construct(ClockInterface $clock)
28 |     {
29 |         $this->clock = $clock;
30 |     }
31 | 
32 |     public function doSomething()
33 |     {
34 |         /** @var DateTimeImmutable $currentDateAndTime */
35 |         $currentDateAndTime = $this->clock->now();
36 |         // do something useful with that information
37 |     }
38 | }
39 | ```
40 | 
41 | You can then pick one of the [implementations][implementation-url] of the interface to get a clock.
42 | 
43 | If you want to implement the interface, you can require this package and
44 | implement `Psr\Clock\ClockInterface` in your code. 
45 | 
46 | Don't forget to add `psr/clock-implementation` to your `composer.json`s `provides`-section like this:
47 | 
48 | ```json
49 | {
50 |   "provides": {
51 |     "psr/clock-implementation": "1.0"
52 |   }
53 | }
54 | ```
55 | 
56 | And please read the [specification text][specification-url] for details on the interface.
57 | 
58 | [psr-url]: https://www.php-fig.org/psr/psr-20
59 | [package-url]: https://packagist.org/packages/psr/clock
60 | [implementation-url]: https://packagist.org/providers/psr/clock-implementation
61 | [specification-url]: https://github.com/php-fig/fig-standards/blob/master/proposed/clock.md
62 | 


--------------------------------------------------------------------------------
/vendor/psr/clock/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "psr/clock",
 3 |   "description": "Common interface for reading the clock.",
 4 |   "keywords": ["psr", "psr-20", "time", "clock", "now"],
 5 |   "homepage": "https://github.com/php-fig/clock",
 6 |   "license": "MIT",
 7 |   "authors": [
 8 |     {
 9 |       "name": "PHP-FIG",
10 |       "homepage": "https://www.php-fig.org/"
11 |     }
12 |   ],
13 |   "require": {
14 |     "php": "^7.0 || ^8.0"
15 |   },
16 |   "autoload": {
17 |     "psr-4": {
18 |       "Psr\\Clock\\": "src/"
19 |     }
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/vendor/psr/clock/src/ClockInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Psr\Clock;
 4 | 
 5 | use DateTimeImmutable;
 6 | 
 7 | interface ClockInterface
 8 | {
 9 |     /**
10 |      * Returns the current time as a DateTimeImmutable Object
11 |      */
12 |     public function now(): DateTimeImmutable;
13 | }
14 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014-2016 Florent Morselli
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/README.md:
--------------------------------------------------------------------------------
 1 | TOTP / HOTP library in PHP
 2 | ==========================
 3 | 
 4 | ![Build Status](https://github.com/spomky-labs/otphp/workflows/Integrate/badge.svg)
 5 | ![Build Status](https://github.com/spomky-labs/otphp/workflows/Infection/badge.svg)
 6 | 
 7 | [![Latest Stable Version](https://poser.pugx.org/spomky-labs/otphp/v/stable.png)](https://packagist.org/packages/spomky-labs/otphp)
 8 | [![Total Downloads](https://poser.pugx.org/spomky-labs/otphp/downloads.png)](https://packagist.org/packages/spomky-labs/otphp)
 9 | [![Latest Unstable Version](https://poser.pugx.org/spomky-labs/otphp/v/unstable.png)](https://packagist.org/packages/spomky-labs/otphp)
10 | [![License](https://poser.pugx.org/spomky-labs/otphp/license.png)](https://packagist.org/packages/spomky-labs/otphp)
11 | 
12 | A php library for generating one-time passwords according to [RFC 4226](https://datatracker.ietf.org/doc/html/rfc4226) (HOTP Algorithm) and [RFC 6238](https://datatracker.ietf.org/doc/html/rfc6238) (TOTP Algorithm)
13 | 
14 | This library is compatible with Google Authenticator apps available for Android and iPhone.
15 | It is also compatible with other applications such as [FreeOTP](https://play.google.com/store/apps/details?id=org.fedorahosted.freeotp) for example.
16 | 
17 | # Documentation
18 | 
19 | The documentation of this project is available in the [*doc* folder](doc/index.md).
20 | 
21 | # Support
22 | 
23 | I bring solutions to your problems and answer your questions.
24 | 
25 | If you really love that project, and the work I have done or if you want I prioritize your issues, then you can help me out for a couple of :beers: or more!
26 | 
27 | [Become a sponsor](https://github.com/sponsors/Spomky)
28 | 
29 | Or
30 | 
31 | [![Become a Patreon](https://c5.patreon.com/external/logo/become_a_patron_button.png)](https://www.patreon.com/FlorentMorselli)
32 | 
33 | ## Contributing
34 | 
35 | Requests for new features, bug fixed and all other ideas to make this project useful are welcome.
36 | 
37 | Please report all issues in [the repository bug tracker](hhttps://github.com/Spomky-Labs/otphp/issues).
38 | 
39 | Also make sure to [follow these best practices](.github/CONTRIBUTING.md).
40 | 
41 | ## Licence
42 | 
43 | This software is release under the [MIT licence](LICENSE).
44 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/SECURITY.md:
--------------------------------------------------------------------------------
 1 | # Security Policy
 2 | 
 3 | ## Supported Versions
 4 | 
 5 | | Version | Supported                              |
 6 | | ------- |----------------------------------------|
 7 | | 11.0.x  | :white_check_mark:                     |
 8 | | 10.0.x  | :white_check_mark: (security fix only) |
 9 | | < 10.0  | :x:                                    |
10 | 
11 | ## Reporting a Vulnerability
12 | 
13 | Please email `security@spomky-labs.com`.
14 | If deemed necessary, you can encrypt your message using one of the following GPG key
15 | 
16 | ```
17 | -----BEGIN PGP PUBLIC KEY BLOCK-----
18 | xjMEXTsJVxYJKwYBBAHaRw8BAQdAZCS93eHRx97V+LQbAWuAaeKIdUZ9YIkn
19 | QH5pQ7dDU0TNMWNvbnRhY3RAc3BvbWt5LWxhYnMuY29tIDxjb250YWN0QHNw
20 | b21reS1sYWJzLmNvbT7CdwQQFgoAHwUCXTsJVwYLCQcIAwIEFQgKAgMWAgEC
21 | GQECGwMCHgEACgkQG6hbCDSDj+1/tgEAoy11uHvDV7kkG/iN2/0ylV72hU8y
22 | c/xoqGd7qFaKD6ABANcthlg63OrQVTf0dUPOT9Y2BJpOOA88JJWgILtuUPIO
23 | zjgEXTsJVxIKKwYBBAGXVQEFAQEHQKiX7nldkmICePhzwReZnBPmjpsmNt7V
24 | Y8xHdICKsr8cAwEIB8JhBBgWCAAJBQJdOwlXAhsMAAoJEBuoWwg0g4/t0KgA
25 | /31ucb/bL/MGpWFrpSjTs6uQhZWlBmcFoeMhwCYepIpZAQDd65UBqFDKXJWv
26 | Xy3zoMQQzD9Z6fUATnFrWkzjHwhvDQ==
27 | =j4dw
28 | -----END PGP PUBLIC KEY BLOCK-----
29 | ```
30 | 
31 | 
32 | ```
33 | -----BEGIN PGP PUBLIC KEY BLOCK-----
34 | xsFNBGILZFoBEADo9pzAMRVxL5typ22Ywifdyi3CMHgg7zptfb8otrQci8IX
35 | m7B8/NTA0I9EkenzSW/Mf4k2iPNCwXc+qVEHPvPNvr3WazcdiDQJjXqMtkxG
36 | l2dvdQHdBxN46v+mvWDVGf9anYQxIAmZrj7CDLOfD/cG/8STL4hSbFjRBOKs
37 | xAP8wgRA/amcrf9WcCDxURGIq8mDPcECR8fca+iukTmMe2NDEc56pJi0KVoF
38 | pFhOMMfjgP/XvtGjjSNZNGRgHSLTQs8UiK+5BjPh+iWFIPV5+ZPLpbSOcoma
39 | GyeX5i1DmAh7cWx/FphvFzOun6to3ERuy82+zW54iA9zS8+kIfV4Wjr2qE7l
40 | Ctc9l8RIv/6dMXoW2Y42CTuywlAMnlP7XaaUgE++CXTIuO7+6Gp0E5NlmqB5
41 | lb+CZLV/LS27gUcajs23ve5B3UId2bGUflvTtY/J0VPzrJMoEErVnkCsnD7W
42 | Oiwe8GiSNMJmTGu/A45xf5nuYNcuU7blA5XXwPoHZuALj1zv6eCWVxWz02l9
43 | Fc/T+gNkOEErlXOcldyXxQ5Qb99TU5NgdqzbibyR9QAqdfwtgg19oFbiSP7t
44 | 8b5P2qAIW2GaOCkX007cBCzTXNrcQNruTwUD59LZQLhdGz5WJo/gefC/3ZvR
45 | vKoJKCRlk7s43aUjeZzE+Engpr5e1wl63WjAzQARAQABzTNzZWN1cml0eUBz
46 | cG9ta3ktbGFicy5jb20gPHNlY3VyaXR5QHNwb21reS1sYWJzLmNvbT7CwY0E
47 | EAEIACAFAmILZFoGCwkHCAMCBBUICgIEFgIBAAIZAQIbAwIeAQAhCRBy14gx
48 | FHv4aBYhBKgF8zJv89FYVv0RFHLXiDEUe/hoA+YP/ijaePtilKURzNVrPWfc
49 | gDw/ZNCR+dVAgwGo9VcbOvkyZmyqD6yBjuDWvG96KQs0LRrqWKonAvnewNtp
50 | wQruuvrlcCuNE6TTfvx0wh2+lwKD7MH5dKutHUCowVNAsZ5uZxHVF9RGLBh+
51 | JRofklupcGqUx+Jtx4uq2gAGOqV4/QdvneMjkLwqVu8FGIM59LfdNfp/iA3p
52 | wX2DvfxBO58Gu6hilmf7R+b9nX0U7xYJM6QJb7H89cV3/AoTh2kf1wtFY+Py
53 | Di6VZTMUBYOoz2iSnvCE8KlBWDu98/A2EJ7kDGQdmnuIgsURsyap3yKioaUr
54 | LGTaG0OiC/gkXkKisH6eff6Gw06qelBarf5N/GgoeAN/amE8twy3a+Hx1pyw
55 | ZzkjPsL7uWg3Koy5mPuCtWfPtIBcJaTLS5d8ESlJ8/CfaVaDludzYQZo70Xn
56 | m4KzjPnptm3djpZNwoFEUxrHVREOEe69/MnEL2PNcEMQkapg16PnH4phajnC
57 | 7bYOPDteMJlHjNmQzz9d25ZwzVBHDDT50mHDijR2D/OgKx3NQr88fiFAWhKG
58 | lEu1ZuOkKIKV5VIFbocTWSoV7bkzIfrll49xWou+4VOxgRuqjquFC4RV8fea
59 | lLbHOcJlOR00aFDmoOWQ3/QNvajaWJFzDdocGbgbnEBMDFRoUkuhqOBcnzA+
60 | apW/zsFNBGILZFoBEADSwiM49wObRpxOyas91M6WvJ4Gt3iXqj+L8dmcw0FW
61 | UdDpwOxy8tuZx+OfXEBBH3eJHOobC66vN+E9WYobVkJ5zfbGxfQruTuvUZNl
62 | X9Lo0UwoP+AP21AKUUvsf48iZGWzmlkxgPnhAQS4ECkkWCKPf7nFTk+V+jIN
63 | nf6ZDZLXaRUnG0nLvzs0raG1eTVrGvPSCC8u3R2zIh9SvoeEgTnT/Re0mhCu
64 | ah3fwG+4vXc6VIjR1ZtpM9+Y8sl+PFZ/Oiisc+46oU5qXVVLtHfLdxYZ4vl2
65 | IflHDKKmrfbfGY1hJl/foBLglT3Cd8GTu3FjiAJX9PpkiWbsflc0OUBQf9aC
66 | 73W5FLS4P4clm4nNzVGkNucWHvk+urM6nEUf02bhsfF0TPeos3QcJorfKNUS
67 | TvuGYccENuK5cVOzEcU+VhN08GT0pr0CpqJnsw+zV8vD4k3aPmMFmSVog+bY
68 | NhfB7AgwbOjd6MhQJcP7YjYTHaa6YsnKMSg4RhkDjvMa3421hfaWsVvlIb0f
69 | AZJ8BnXgfE0uI8CKA9dc6I2Posl33zC8HI2sS1MEJ90Am68P+uJt61LdJeD5
70 | VXSrCkzBhUBds0hbGR6+DF20UD496m7Lw3VBoWOl2bMeLdERDarFMDYsPH47
71 | rie9wlrnPNR57HUqK4bpkFwqTStRkRFUhFv7LLWZ1QARAQABwsF2BBgBCAAJ
72 | BQJiC2RaAhsMACEJEHLXiDEUe/hoFiEEqAXzMm/z0VhW/REUcteIMRR7+GhI
73 | lQ/9GbSwIdGue6Gw0msYAEoER9HhpYB//9/GG7/c4ZW60nLSSYuhNWIo0Akl
74 | 10CzeApezf/O9/1EExqZ9ygj4wtUphcQOdRJVhXPt+gskw7/NHoXUJ+Z1rbb
75 | EWbKle9YufZ4PAKYhlxdqTlWyQvPVxrRvbuhYeQG4S412VzKjH0/x1Fh2CfV
76 | hFuyOaRjg89T6rihXL1rCSJ/PDQeQtvtXeJ30yFj+aapCj+VqUl+2D+N0bzS
77 | LL18kEPQnJw4BOHOXrw349dAKmHN/QkRH8DINlXLyaOlABglnSViDQL3Q1t3
78 | sBuIeClsl3brQNJRp/RKOdTBMNAX+BhAjqodbwwT+UkJl9xJKw0Cla4wtbs2
79 | T0yoK/Z1iFfvPdufkK4q6ocAHJUp3+XckFIZxsHQvhQPbm9XoOt1RTO29MOw
80 | EYo8UjFQCnXJVsj1/6XMgIUe5tPYvS/ZZZNJFF4j+OE8xRKLKqg/DFcpEipC
81 | LCmzzr/hhWx0XP4CIK2tYsAMk3ieCZuk1Wa+NGLL4WfALWsNHq3wg5Wzv+yJ
82 | dp14fv711BVYlriI+VKggGFgBdz0dWkgrBk4+thLatJFcjFYr8BLkbtPraa3
83 | sFI/cGxvOXSIy4GEALdfnozyU3RJtMNtVi3IzGeIFAOb457y/IrMqpWLp1FX
84 | BUqlX5YJHneD9Q8Sfz/HKDQDCqg=
85 | =o+4z
86 | -----END PGP PUBLIC KEY BLOCK-----
87 | ```
88 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "spomky-labs/otphp",
 3 |     "type": "library",
 4 |     "description": "A PHP library for generating one time passwords according to RFC 4226 (HOTP Algorithm) and the RFC 6238 (TOTP Algorithm) and compatible with Google Authenticator",
 5 |     "license": "MIT",
 6 |     "keywords": ["otp", "hotp", "totp", "RFC 4226", "RFC 6238", "Google Authenticator", "FreeOTP"],
 7 |     "homepage": "https://github.com/Spomky-Labs/otphp",
 8 |     "authors": [
 9 |         {
10 |             "name": "Florent Morselli",
11 |             "homepage": "https://github.com/Spomky"
12 |         },
13 |         {
14 |             "name": "All contributors",
15 |             "homepage": "https://github.com/Spomky-Labs/otphp/contributors"
16 |         }
17 |     ],
18 |     "require": {
19 |         "php": ">=8.1",
20 |         "ext-mbstring": "*",
21 |         "paragonie/constant_time_encoding": "^2.0 || ^3.0",
22 |         "psr/clock": "^1.0",
23 |         "symfony/deprecation-contracts": "^3.2"
24 |     },
25 |     "require-dev": {
26 |         "ekino/phpstan-banned-code": "^1.0",
27 |         "infection/infection": "^0.26|^0.27|^0.28|^0.29",
28 |         "php-parallel-lint/php-parallel-lint": "^1.3",
29 |         "phpstan/phpstan": "^1.0",
30 |         "phpstan/phpstan-deprecation-rules": "^1.0",
31 |         "phpstan/phpstan-phpunit": "^1.0",
32 |         "phpstan/phpstan-strict-rules": "^1.0",
33 |         "phpunit/phpunit": "^9.5.26|^10.0|^11.0",
34 |         "qossmic/deptrac-shim": "^1.0",
35 |         "rector/rector": "^1.0",
36 |         "symfony/phpunit-bridge": "^6.1|^7.0",
37 |         "symplify/easy-coding-standard": "^12.0"
38 |     },
39 |     "autoload": {
40 |         "psr-4": { "OTPHP\\": "src/" }
41 |     },
42 |     "autoload-dev": {
43 |         "psr-4": { "OTPHP\\Test\\": "tests/" }
44 |     },
45 |     "config": {
46 |         "allow-plugins": {
47 |             "phpstan/extension-installer": true,
48 |             "infection/extension-installer": true,
49 |             "composer/package-versions-deprecated": true,
50 |             "symfony/flex": true,
51 |             "symfony/runtime": true
52 |         },
53 |         "optimize-autoloader": true,
54 |         "preferred-install": {
55 |             "*": "dist"
56 |         },
57 |         "sort-packages": true
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/Factory.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace OTPHP;
  6 | 
  7 | use InvalidArgumentException;
  8 | use Psr\Clock\ClockInterface;
  9 | use Throwable;
 10 | use function assert;
 11 | use function count;
 12 | 
 13 | /**
 14 |  * This class is used to load OTP object from a provisioning Uri.
 15 |  *
 16 |  * @see \OTPHP\Test\FactoryTest
 17 |  */
 18 | final class Factory implements FactoryInterface
 19 | {
 20 |     public static function loadFromProvisioningUri(string $uri, ?ClockInterface $clock = null): OTPInterface
 21 |     {
 22 |         try {
 23 |             $parsed_url = Url::fromString($uri);
 24 |             $parsed_url->getScheme() === 'otpauth' || throw new InvalidArgumentException('Invalid scheme.');
 25 |         } catch (Throwable $throwable) {
 26 |             throw new InvalidArgumentException('Not a valid OTP provisioning URI', $throwable->getCode(), $throwable);
 27 |         }
 28 |         if ($clock === null) {
 29 |             trigger_deprecation(
 30 |                 'spomky-labs/otphp',
 31 |                 '11.3.0',
 32 |                 'The parameter "$clock" will become mandatory in 12.0.0. Please set a valid PSR Clock implementation instead of "null".'
 33 |             );
 34 |             $clock = new InternalClock();
 35 |         }
 36 | 
 37 |         $otp = self::createOTP($parsed_url, $clock);
 38 | 
 39 |         self::populateOTP($otp, $parsed_url);
 40 | 
 41 |         return $otp;
 42 |     }
 43 | 
 44 |     private static function populateParameters(OTPInterface $otp, Url $data): void
 45 |     {
 46 |         foreach ($data->getQuery() as $key => $value) {
 47 |             $otp->setParameter($key, $value);
 48 |         }
 49 |     }
 50 | 
 51 |     private static function populateOTP(OTPInterface $otp, Url $data): void
 52 |     {
 53 |         self::populateParameters($otp, $data);
 54 |         $result = explode(':', rawurldecode(mb_substr($data->getPath(), 1)));
 55 | 
 56 |         if (count($result) < 2) {
 57 |             $otp->setIssuerIncludedAsParameter(false);
 58 | 
 59 |             return;
 60 |         }
 61 | 
 62 |         if ($otp->getIssuer() !== null) {
 63 |             $result[0] === $otp->getIssuer() || throw new InvalidArgumentException(
 64 |                 'Invalid OTP: invalid issuer in parameter'
 65 |             );
 66 |             $otp->setIssuerIncludedAsParameter(true);
 67 |         }
 68 | 
 69 |         assert($result[0] !== '');
 70 | 
 71 |         $otp->setIssuer($result[0]);
 72 |     }
 73 | 
 74 |     private static function createOTP(Url $parsed_url, ClockInterface $clock): OTPInterface
 75 |     {
 76 |         switch ($parsed_url->getHost()) {
 77 |             case 'totp':
 78 |                 $totp = TOTP::createFromSecret($parsed_url->getSecret(), $clock);
 79 |                 $totp->setLabel(self::getLabel($parsed_url->getPath()));
 80 | 
 81 |                 return $totp;
 82 |             case 'hotp':
 83 |                 $hotp = HOTP::createFromSecret($parsed_url->getSecret());
 84 |                 $hotp->setLabel(self::getLabel($parsed_url->getPath()));
 85 | 
 86 |                 return $hotp;
 87 |             default:
 88 |                 throw new InvalidArgumentException(sprintf('Unsupported "%s" OTP type', $parsed_url->getHost()));
 89 |         }
 90 |     }
 91 | 
 92 |     /**
 93 |      * @param non-empty-string $data
 94 |      * @return non-empty-string
 95 |      */
 96 |     private static function getLabel(string $data): string
 97 |     {
 98 |         $result = explode(':', rawurldecode(mb_substr($data, 1)));
 99 |         $label = count($result) === 2 ? $result[1] : $result[0];
100 |         assert($label !== '');
101 | 
102 |         return $label;
103 |     }
104 | }
105 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/FactoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace OTPHP;
 6 | 
 7 | interface FactoryInterface
 8 | {
 9 |     /**
10 |      * This method is the unique public method of the class. It can load a provisioning Uri and convert it into an OTP
11 |      * object.
12 |      *
13 |      * @param non-empty-string $uri
14 |      */
15 |     public static function loadFromProvisioningUri(string $uri): OTPInterface;
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/HOTP.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace OTPHP;
  6 | 
  7 | use InvalidArgumentException;
  8 | use function is_int;
  9 | 
 10 | /**
 11 |  * @see \OTPHP\Test\HOTPTest
 12 |  */
 13 | final class HOTP extends OTP implements HOTPInterface
 14 | {
 15 |     private const DEFAULT_WINDOW = 0;
 16 | 
 17 |     public static function create(
 18 |         null|string $secret = null,
 19 |         int $counter = self::DEFAULT_COUNTER,
 20 |         string $digest = self::DEFAULT_DIGEST,
 21 |         int $digits = self::DEFAULT_DIGITS
 22 |     ): self {
 23 |         $htop = $secret !== null
 24 |             ? self::createFromSecret($secret)
 25 |             : self::generate()
 26 |         ;
 27 |         $htop->setCounter($counter);
 28 |         $htop->setDigest($digest);
 29 |         $htop->setDigits($digits);
 30 | 
 31 |         return $htop;
 32 |     }
 33 | 
 34 |     public static function createFromSecret(string $secret): self
 35 |     {
 36 |         $htop = new self($secret);
 37 |         $htop->setCounter(self::DEFAULT_COUNTER);
 38 |         $htop->setDigest(self::DEFAULT_DIGEST);
 39 |         $htop->setDigits(self::DEFAULT_DIGITS);
 40 | 
 41 |         return $htop;
 42 |     }
 43 | 
 44 |     public static function generate(): self
 45 |     {
 46 |         return self::createFromSecret(self::generateSecret());
 47 |     }
 48 | 
 49 |     /**
 50 |      * @return 0|positive-int
 51 |      */
 52 |     public function getCounter(): int
 53 |     {
 54 |         $value = $this->getParameter('counter');
 55 |         (is_int($value) && $value >= 0) || throw new InvalidArgumentException('Invalid "counter" parameter.');
 56 | 
 57 |         return $value;
 58 |     }
 59 | 
 60 |     public function getProvisioningUri(): string
 61 |     {
 62 |         return $this->generateURI('hotp', [
 63 |             'counter' => $this->getCounter(),
 64 |         ]);
 65 |     }
 66 | 
 67 |     /**
 68 |      * If the counter is not provided, the OTP is verified at the actual counter.
 69 |      *
 70 |      * @param null|0|positive-int $counter
 71 |      */
 72 |     public function verify(string $otp, null|int $counter = null, null|int $window = null): bool
 73 |     {
 74 |         $counter >= 0 || throw new InvalidArgumentException('The counter must be at least 0.');
 75 | 
 76 |         if ($counter === null) {
 77 |             $counter = $this->getCounter();
 78 |         } elseif ($counter < $this->getCounter()) {
 79 |             return false;
 80 |         }
 81 | 
 82 |         return $this->verifyOtpWithWindow($otp, $counter, $window);
 83 |     }
 84 | 
 85 |     public function setCounter(int $counter): void
 86 |     {
 87 |         $this->setParameter('counter', $counter);
 88 |     }
 89 | 
 90 |     /**
 91 |      * @return array<non-empty-string, callable>
 92 |      */
 93 |     protected function getParameterMap(): array
 94 |     {
 95 |         return [...parent::getParameterMap(), ...[
 96 |             'counter' => static function (mixed $value): int {
 97 |                 $value = (int) $value;
 98 |                 $value >= 0 || throw new InvalidArgumentException('Counter must be at least 0.');
 99 | 
100 |                 return $value;
101 |             },
102 |         ]];
103 |     }
104 | 
105 |     private function updateCounter(int $counter): void
106 |     {
107 |         $this->setCounter($counter);
108 |     }
109 | 
110 |     /**
111 |      * @param null|0|positive-int $window
112 |      */
113 |     private function getWindow(null|int $window): int
114 |     {
115 |         return abs($window ?? self::DEFAULT_WINDOW);
116 |     }
117 | 
118 |     /**
119 |      * @param non-empty-string $otp
120 |      * @param 0|positive-int $counter
121 |      * @param null|0|positive-int $window
122 |      */
123 |     private function verifyOtpWithWindow(string $otp, int $counter, null|int $window): bool
124 |     {
125 |         $window = $this->getWindow($window);
126 | 
127 |         for ($i = $counter; $i <= $counter + $window; ++$i) {
128 |             if ($this->compareOTP($this->at($i), $otp)) {
129 |                 $this->updateCounter($i + 1);
130 | 
131 |                 return true;
132 |             }
133 |         }
134 | 
135 |         return false;
136 |     }
137 | }
138 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/HOTPInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace OTPHP;
 6 | 
 7 | interface HOTPInterface extends OTPInterface
 8 | {
 9 |     public const DEFAULT_COUNTER = 0;
10 | 
11 |     /**
12 |      * The initial counter (a positive integer).
13 |      */
14 |     public function getCounter(): int;
15 | 
16 |     /**
17 |      * Create a new HOTP object.
18 |      *
19 |      * If the secret is null, a random 64 bytes secret will be generated.
20 |      *
21 |      * @param null|non-empty-string $secret
22 |      * @param 0|positive-int $counter
23 |      * @param non-empty-string $digest
24 |      * @param positive-int $digits
25 |      *
26 |      * @deprecated Deprecated since v11.1, use ::createFromSecret or ::generate instead
27 |      */
28 |     public static function create(
29 |         null|string $secret = null,
30 |         int $counter = 0,
31 |         string $digest = 'sha1',
32 |         int $digits = 6
33 |     ): self;
34 | 
35 |     public function setCounter(int $counter): void;
36 | }
37 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/InternalClock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace OTPHP;
 6 | 
 7 | use DateTimeImmutable;
 8 | use Psr\Clock\ClockInterface;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class InternalClock implements ClockInterface
14 | {
15 |     public function now(): DateTimeImmutable
16 |     {
17 |         return new DateTimeImmutable();
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/OTP.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace OTPHP;
  6 | 
  7 | use Exception;
  8 | use InvalidArgumentException;
  9 | use ParagonIE\ConstantTime\Base32;
 10 | use RuntimeException;
 11 | use function assert;
 12 | use function chr;
 13 | use function count;
 14 | use function is_string;
 15 | use const STR_PAD_LEFT;
 16 | 
 17 | abstract class OTP implements OTPInterface
 18 | {
 19 |     use ParameterTrait;
 20 | 
 21 |     private const DEFAULT_SECRET_SIZE = 64;
 22 | 
 23 |     /**
 24 |      * @param non-empty-string $secret
 25 |      */
 26 |     protected function __construct(string $secret)
 27 |     {
 28 |         $this->setSecret($secret);
 29 |     }
 30 | 
 31 |     public function getQrCodeUri(string $uri, string $placeholder): string
 32 |     {
 33 |         $provisioning_uri = urlencode($this->getProvisioningUri());
 34 | 
 35 |         return str_replace($placeholder, $provisioning_uri, $uri);
 36 |     }
 37 | 
 38 |     /**
 39 |      * @param 0|positive-int $input
 40 |      */
 41 |     public function at(int $input): string
 42 |     {
 43 |         return $this->generateOTP($input);
 44 |     }
 45 | 
 46 |     /**
 47 |      * @return non-empty-string
 48 |      */
 49 |     final protected static function generateSecret(): string
 50 |     {
 51 |         return Base32::encodeUpper(random_bytes(self::DEFAULT_SECRET_SIZE));
 52 |     }
 53 | 
 54 |     /**
 55 |      * The OTP at the specified input.
 56 |      *
 57 |      * @param 0|positive-int $input
 58 |      *
 59 |      * @return non-empty-string
 60 |      */
 61 |     protected function generateOTP(int $input): string
 62 |     {
 63 |         $hash = hash_hmac($this->getDigest(), $this->intToByteString($input), $this->getDecodedSecret(), true);
 64 |         $unpacked = unpack('C*', $hash);
 65 |         $unpacked !== false || throw new InvalidArgumentException('Invalid data.');
 66 |         $hmac = array_values($unpacked);
 67 | 
 68 |         $offset = ($hmac[count($hmac) - 1] & 0xF);
 69 |         $code = ($hmac[$offset] & 0x7F) << 24 | ($hmac[$offset + 1] & 0xFF) << 16 | ($hmac[$offset + 2] & 0xFF) << 8 | ($hmac[$offset + 3] & 0xFF);
 70 |         $otp = $code % (10 ** $this->getDigits());
 71 | 
 72 |         return str_pad((string) $otp, $this->getDigits(), '0', STR_PAD_LEFT);
 73 |     }
 74 | 
 75 |     /**
 76 |      * @param array<non-empty-string, mixed> $options
 77 |      */
 78 |     protected function filterOptions(array &$options): void
 79 |     {
 80 |         foreach ([
 81 |             'algorithm' => 'sha1',
 82 |             'period' => 30,
 83 |             'digits' => 6,
 84 |         ] as $key => $default) {
 85 |             if (isset($options[$key]) && $default === $options[$key]) {
 86 |                 unset($options[$key]);
 87 |             }
 88 |         }
 89 | 
 90 |         ksort($options);
 91 |     }
 92 | 
 93 |     /**
 94 |      * @param non-empty-string $type
 95 |      * @param array<non-empty-string, mixed> $options
 96 |      *
 97 |      * @return non-empty-string
 98 |      */
 99 |     protected function generateURI(string $type, array $options): string
100 |     {
101 |         $label = $this->getLabel();
102 |         is_string($label) || throw new InvalidArgumentException('The label is not set.');
103 |         $this->hasColon($label) === false || throw new InvalidArgumentException('Label must not contain a colon.');
104 |         $options = [...$options, ...$this->getParameters()];
105 |         $this->filterOptions($options);
106 |         $params = str_replace(['+', '%7E'], ['%20', '~'], http_build_query($options, '', '&'));
107 | 
108 |         return sprintf(
109 |             'otpauth://%s/%s?%s',
110 |             $type,
111 |             rawurlencode(($this->getIssuer() !== null ? $this->getIssuer() . ':' : '') . $label),
112 |             $params
113 |         );
114 |     }
115 | 
116 |     /**
117 |      * @param non-empty-string $safe
118 |      * @param non-empty-string $user
119 |      */
120 |     protected function compareOTP(string $safe, string $user): bool
121 |     {
122 |         return hash_equals($safe, $user);
123 |     }
124 | 
125 |     /**
126 |      * @return non-empty-string
127 |      */
128 |     private function getDecodedSecret(): string
129 |     {
130 |         try {
131 |             $decoded = Base32::decodeUpper($this->getSecret());
132 |         } catch (Exception) {
133 |             throw new RuntimeException('Unable to decode the secret. Is it correctly base32 encoded?');
134 |         }
135 |         assert($decoded !== '');
136 | 
137 |         return $decoded;
138 |     }
139 | 
140 |     private function intToByteString(int $int): string
141 |     {
142 |         $result = [];
143 |         while ($int !== 0) {
144 |             $result[] = chr($int & 0xFF);
145 |             $int >>= 8;
146 |         }
147 | 
148 |         return str_pad(implode('', array_reverse($result)), 8, "\000", STR_PAD_LEFT);
149 |     }
150 | }
151 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/OTPInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace OTPHP;
  6 | 
  7 | interface OTPInterface
  8 | {
  9 |     public const DEFAULT_DIGITS = 6;
 10 | 
 11 |     public const DEFAULT_DIGEST = 'sha1';
 12 | 
 13 |     /**
 14 |      * Create a OTP object from an existing secret.
 15 |      *
 16 |      * @param non-empty-string $secret
 17 |      */
 18 |     public static function createFromSecret(string $secret): self;
 19 | 
 20 |     /**
 21 |      * Create a new OTP object. A random 64 bytes secret will be generated.
 22 |      */
 23 |     public static function generate(): self;
 24 | 
 25 |     /**
 26 |      * @param non-empty-string $secret
 27 |      */
 28 |     public function setSecret(string $secret): void;
 29 | 
 30 |     public function setDigits(int $digits): void;
 31 | 
 32 |     /**
 33 |      * @param non-empty-string $digest
 34 |      */
 35 |     public function setDigest(string $digest): void;
 36 | 
 37 |     /**
 38 |      * Generate the OTP at the specified input.
 39 |      *
 40 |      * @param 0|positive-int $input
 41 |      *
 42 |      * @return non-empty-string Return the OTP at the specified timestamp
 43 |      */
 44 |     public function at(int $input): string;
 45 | 
 46 |     /**
 47 |      * Verify that the OTP is valid with the specified input. If no input is provided, the input is set to a default
 48 |      * value or false is returned.
 49 |      *
 50 |      * @param non-empty-string $otp
 51 |      * @param null|0|positive-int $input
 52 |      * @param null|0|positive-int $window
 53 |      */
 54 |     public function verify(string $otp, null|int $input = null, null|int $window = null): bool;
 55 | 
 56 |     /**
 57 |      * @return non-empty-string The secret of the OTP
 58 |      */
 59 |     public function getSecret(): string;
 60 | 
 61 |     /**
 62 |      * @param non-empty-string $label The label of the OTP
 63 |      */
 64 |     public function setLabel(string $label): void;
 65 | 
 66 |     /**
 67 |      * @return non-empty-string|null The label of the OTP
 68 |      */
 69 |     public function getLabel(): null|string;
 70 | 
 71 |     /**
 72 |      * @return non-empty-string|null The issuer
 73 |      */
 74 |     public function getIssuer(): ?string;
 75 | 
 76 |     /**
 77 |      * @param non-empty-string $issuer
 78 |      */
 79 |     public function setIssuer(string $issuer): void;
 80 | 
 81 |     /**
 82 |      * @return bool If true, the issuer will be added as a parameter in the provisioning URI
 83 |      */
 84 |     public function isIssuerIncludedAsParameter(): bool;
 85 | 
 86 |     public function setIssuerIncludedAsParameter(bool $issuer_included_as_parameter): void;
 87 | 
 88 |     /**
 89 |      * @return positive-int Number of digits in the OTP
 90 |      */
 91 |     public function getDigits(): int;
 92 | 
 93 |     /**
 94 |      * @return non-empty-string Digest algorithm used to calculate the OTP. Possible values are 'md5', 'sha1', 'sha256' and 'sha512'
 95 |      */
 96 |     public function getDigest(): string;
 97 | 
 98 |     /**
 99 |      * @param non-empty-string $parameter
100 |      */
101 |     public function getParameter(string $parameter): mixed;
102 | 
103 |     /**
104 |      * @param non-empty-string $parameter
105 |      */
106 |     public function hasParameter(string $parameter): bool;
107 | 
108 |     /**
109 |      * @return array<non-empty-string, mixed>
110 |      */
111 |     public function getParameters(): array;
112 | 
113 |     /**
114 |      * @param non-empty-string $parameter
115 |      */
116 |     public function setParameter(string $parameter, mixed $value): void;
117 | 
118 |     /**
119 |      * Get the provisioning URI.
120 |      *
121 |      * @return non-empty-string
122 |      */
123 |     public function getProvisioningUri(): string;
124 | 
125 |     /**
126 |      * Get the provisioning URI.
127 |      *
128 |      * @param non-empty-string $uri         The Uri of the QRCode generator with all parameters. This Uri MUST contain a placeholder that will be replaced by the method.
129 |      * @param non-empty-string $placeholder the placeholder to be replaced in the QR Code generator URI
130 |      */
131 |     public function getQrCodeUri(string $uri, string $placeholder): string;
132 | }
133 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/ParameterTrait.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace OTPHP;
  6 | 
  7 | use InvalidArgumentException;
  8 | use function array_key_exists;
  9 | use function assert;
 10 | use function in_array;
 11 | use function is_int;
 12 | use function is_string;
 13 | 
 14 | trait ParameterTrait
 15 | {
 16 |     /**
 17 |      * @var array<non-empty-string, mixed>
 18 |      */
 19 |     private array $parameters = [];
 20 | 
 21 |     /**
 22 |      * @var non-empty-string|null
 23 |      */
 24 |     private null|string $issuer = null;
 25 | 
 26 |     /**
 27 |      * @var non-empty-string|null
 28 |      */
 29 |     private null|string $label = null;
 30 | 
 31 |     private bool $issuer_included_as_parameter = true;
 32 | 
 33 |     /**
 34 |      * @return array<non-empty-string, mixed>
 35 |      */
 36 |     public function getParameters(): array
 37 |     {
 38 |         $parameters = $this->parameters;
 39 | 
 40 |         if ($this->getIssuer() !== null && $this->isIssuerIncludedAsParameter() === true) {
 41 |             $parameters['issuer'] = $this->getIssuer();
 42 |         }
 43 | 
 44 |         return $parameters;
 45 |     }
 46 | 
 47 |     public function getSecret(): string
 48 |     {
 49 |         $value = $this->getParameter('secret');
 50 |         (is_string($value) && $value !== '') || throw new InvalidArgumentException('Invalid "secret" parameter.');
 51 | 
 52 |         return $value;
 53 |     }
 54 | 
 55 |     public function getLabel(): null|string
 56 |     {
 57 |         return $this->label;
 58 |     }
 59 | 
 60 |     public function setLabel(string $label): void
 61 |     {
 62 |         $this->setParameter('label', $label);
 63 |     }
 64 | 
 65 |     public function getIssuer(): null|string
 66 |     {
 67 |         return $this->issuer;
 68 |     }
 69 | 
 70 |     public function setIssuer(string $issuer): void
 71 |     {
 72 |         $this->setParameter('issuer', $issuer);
 73 |     }
 74 | 
 75 |     public function isIssuerIncludedAsParameter(): bool
 76 |     {
 77 |         return $this->issuer_included_as_parameter;
 78 |     }
 79 | 
 80 |     public function setIssuerIncludedAsParameter(bool $issuer_included_as_parameter): void
 81 |     {
 82 |         $this->issuer_included_as_parameter = $issuer_included_as_parameter;
 83 |     }
 84 | 
 85 |     public function getDigits(): int
 86 |     {
 87 |         $value = $this->getParameter('digits');
 88 |         (is_int($value) && $value > 0) || throw new InvalidArgumentException('Invalid "digits" parameter.');
 89 | 
 90 |         return $value;
 91 |     }
 92 | 
 93 |     public function getDigest(): string
 94 |     {
 95 |         $value = $this->getParameter('algorithm');
 96 |         (is_string($value) && $value !== '') || throw new InvalidArgumentException('Invalid "algorithm" parameter.');
 97 | 
 98 |         return $value;
 99 |     }
100 | 
101 |     public function hasParameter(string $parameter): bool
102 |     {
103 |         return array_key_exists($parameter, $this->parameters);
104 |     }
105 | 
106 |     public function getParameter(string $parameter): mixed
107 |     {
108 |         if ($this->hasParameter($parameter)) {
109 |             return $this->getParameters()[$parameter];
110 |         }
111 | 
112 |         throw new InvalidArgumentException(sprintf('Parameter "%s" does not exist', $parameter));
113 |     }
114 | 
115 |     public function setParameter(string $parameter, mixed $value): void
116 |     {
117 |         $map = $this->getParameterMap();
118 | 
119 |         if (array_key_exists($parameter, $map) === true) {
120 |             $callback = $map[$parameter];
121 |             $value = $callback($value);
122 |         }
123 | 
124 |         if (property_exists($this, $parameter)) {
125 |             $this->{$parameter} = $value;
126 |         } else {
127 |             $this->parameters[$parameter] = $value;
128 |         }
129 |     }
130 | 
131 |     public function setSecret(string $secret): void
132 |     {
133 |         $this->setParameter('secret', $secret);
134 |     }
135 | 
136 |     public function setDigits(int $digits): void
137 |     {
138 |         $this->setParameter('digits', $digits);
139 |     }
140 | 
141 |     public function setDigest(string $digest): void
142 |     {
143 |         $this->setParameter('algorithm', $digest);
144 |     }
145 | 
146 |     /**
147 |      * @return array<non-empty-string, callable>
148 |      */
149 |     protected function getParameterMap(): array
150 |     {
151 |         return [
152 |             'label' => function (string $value): string {
153 |                 assert($value !== '');
154 |                 $this->hasColon($value) === false || throw new InvalidArgumentException(
155 |                     'Label must not contain a colon.'
156 |                 );
157 | 
158 |                 return $value;
159 |             },
160 |             'secret' => static fn (string $value): string => mb_strtoupper(trim($value, '=')),
161 |             'algorithm' => static function (string $value): string {
162 |                 $value = mb_strtolower($value);
163 |                 in_array($value, hash_algos(), true) || throw new InvalidArgumentException(sprintf(
164 |                     'The "%s" digest is not supported.',
165 |                     $value
166 |                 ));
167 | 
168 |                 return $value;
169 |             },
170 |             'digits' => static function ($value): int {
171 |                 $value > 0 || throw new InvalidArgumentException('Digits must be at least 1.');
172 | 
173 |                 return (int) $value;
174 |             },
175 |             'issuer' => function (string $value): string {
176 |                 assert($value !== '');
177 |                 $this->hasColon($value) === false || throw new InvalidArgumentException(
178 |                     'Issuer must not contain a colon.'
179 |                 );
180 | 
181 |                 return $value;
182 |             },
183 |         ];
184 |     }
185 | 
186 |     /**
187 |      * @param non-empty-string $value
188 |      */
189 |     private function hasColon(string $value): bool
190 |     {
191 |         $colons = [':', '%3A', '%3a'];
192 |         foreach ($colons as $colon) {
193 |             if (str_contains($value, $colon)) {
194 |                 return true;
195 |             }
196 |         }
197 | 
198 |         return false;
199 |     }
200 | }
201 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/TOTP.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace OTPHP;
  6 | 
  7 | use InvalidArgumentException;
  8 | use Psr\Clock\ClockInterface;
  9 | use function assert;
 10 | use function is_int;
 11 | 
 12 | /**
 13 |  * @see \OTPHP\Test\TOTPTest
 14 |  */
 15 | final class TOTP extends OTP implements TOTPInterface
 16 | {
 17 |     private readonly ClockInterface $clock;
 18 | 
 19 |     public function __construct(string $secret, ?ClockInterface $clock = null)
 20 |     {
 21 |         parent::__construct($secret);
 22 |         if ($clock === null) {
 23 |             trigger_deprecation(
 24 |                 'spomky-labs/otphp',
 25 |                 '11.3.0',
 26 |                 'The parameter "$clock" will become mandatory in 12.0.0. Please set a valid PSR Clock implementation instead of "null".'
 27 |             );
 28 |             $clock = new InternalClock();
 29 |         }
 30 | 
 31 |         $this->clock = $clock;
 32 |     }
 33 | 
 34 |     public static function create(
 35 |         null|string $secret = null,
 36 |         int $period = self::DEFAULT_PERIOD,
 37 |         string $digest = self::DEFAULT_DIGEST,
 38 |         int $digits = self::DEFAULT_DIGITS,
 39 |         int $epoch = self::DEFAULT_EPOCH,
 40 |         ?ClockInterface $clock = null
 41 |     ): self {
 42 |         $totp = $secret !== null
 43 |             ? self::createFromSecret($secret, $clock)
 44 |             : self::generate($clock)
 45 |         ;
 46 |         $totp->setPeriod($period);
 47 |         $totp->setDigest($digest);
 48 |         $totp->setDigits($digits);
 49 |         $totp->setEpoch($epoch);
 50 | 
 51 |         return $totp;
 52 |     }
 53 | 
 54 |     public static function createFromSecret(string $secret, ?ClockInterface $clock = null): self
 55 |     {
 56 |         $totp = new self($secret, $clock);
 57 |         $totp->setPeriod(self::DEFAULT_PERIOD);
 58 |         $totp->setDigest(self::DEFAULT_DIGEST);
 59 |         $totp->setDigits(self::DEFAULT_DIGITS);
 60 |         $totp->setEpoch(self::DEFAULT_EPOCH);
 61 | 
 62 |         return $totp;
 63 |     }
 64 | 
 65 |     public static function generate(?ClockInterface $clock = null): self
 66 |     {
 67 |         return self::createFromSecret(self::generateSecret(), $clock);
 68 |     }
 69 | 
 70 |     public function getPeriod(): int
 71 |     {
 72 |         $value = $this->getParameter('period');
 73 |         (is_int($value) && $value > 0) || throw new InvalidArgumentException('Invalid "period" parameter.');
 74 | 
 75 |         return $value;
 76 |     }
 77 | 
 78 |     public function getEpoch(): int
 79 |     {
 80 |         $value = $this->getParameter('epoch');
 81 |         (is_int($value) && $value >= 0) || throw new InvalidArgumentException('Invalid "epoch" parameter.');
 82 | 
 83 |         return $value;
 84 |     }
 85 | 
 86 |     public function expiresIn(): int
 87 |     {
 88 |         $period = $this->getPeriod();
 89 | 
 90 |         return $period - ($this->clock->now()->getTimestamp() % $this->getPeriod());
 91 |     }
 92 | 
 93 |     /**
 94 |      * The OTP at the specified input.
 95 |      *
 96 |      * @param 0|positive-int $input
 97 |      */
 98 |     public function at(int $input): string
 99 |     {
100 |         return $this->generateOTP($this->timecode($input));
101 |     }
102 | 
103 |     public function now(): string
104 |     {
105 |         $timestamp = $this->clock->now()
106 |             ->getTimestamp();
107 |         assert($timestamp >= 0, 'The timestamp must return a positive integer.');
108 | 
109 |         return $this->at($timestamp);
110 |     }
111 | 
112 |     /**
113 |      * If no timestamp is provided, the OTP is verified at the actual timestamp. When used, the leeway parameter will
114 |      * allow time drift. The passed value is in seconds.
115 |      *
116 |      * @param 0|positive-int $timestamp
117 |      * @param null|0|positive-int $leeway
118 |      */
119 |     public function verify(string $otp, null|int $timestamp = null, null|int $leeway = null): bool
120 |     {
121 |         $timestamp ??= $this->clock->now()
122 |             ->getTimestamp();
123 |         $timestamp >= 0 || throw new InvalidArgumentException('Timestamp must be at least 0.');
124 | 
125 |         if ($leeway === null) {
126 |             return $this->compareOTP($this->at($timestamp), $otp);
127 |         }
128 | 
129 |         $leeway = abs($leeway);
130 |         $leeway < $this->getPeriod() || throw new InvalidArgumentException(
131 |             'The leeway must be lower than the TOTP period'
132 |         );
133 |         $timestampMinusLeeway = $timestamp - $leeway;
134 |         $timestampMinusLeeway >= 0 || throw new InvalidArgumentException(
135 |             'The timestamp must be greater than or equal to the leeway.'
136 |         );
137 | 
138 |         return $this->compareOTP($this->at($timestampMinusLeeway), $otp)
139 |             || $this->compareOTP($this->at($timestamp), $otp)
140 |             || $this->compareOTP($this->at($timestamp + $leeway), $otp);
141 |     }
142 | 
143 |     public function getProvisioningUri(): string
144 |     {
145 |         $params = [];
146 |         if ($this->getPeriod() !== 30) {
147 |             $params['period'] = $this->getPeriod();
148 |         }
149 | 
150 |         if ($this->getEpoch() !== 0) {
151 |             $params['epoch'] = $this->getEpoch();
152 |         }
153 | 
154 |         return $this->generateURI('totp', $params);
155 |     }
156 | 
157 |     public function setPeriod(int $period): void
158 |     {
159 |         $this->setParameter('period', $period);
160 |     }
161 | 
162 |     public function setEpoch(int $epoch): void
163 |     {
164 |         $this->setParameter('epoch', $epoch);
165 |     }
166 | 
167 |     /**
168 |      * @return array<non-empty-string, callable>
169 |      */
170 |     protected function getParameterMap(): array
171 |     {
172 |         return [
173 |             ...parent::getParameterMap(),
174 |             'period' => static function ($value): int {
175 |                 (int) $value > 0 || throw new InvalidArgumentException('Period must be at least 1.');
176 | 
177 |                 return (int) $value;
178 |             },
179 |             'epoch' => static function ($value): int {
180 |                 (int) $value >= 0 || throw new InvalidArgumentException(
181 |                     'Epoch must be greater than or equal to 0.'
182 |                 );
183 | 
184 |                 return (int) $value;
185 |             },
186 |         ];
187 |     }
188 | 
189 |     /**
190 |      * @param array<non-empty-string, mixed> $options
191 |      */
192 |     protected function filterOptions(array &$options): void
193 |     {
194 |         parent::filterOptions($options);
195 | 
196 |         if (isset($options['epoch']) && $options['epoch'] === 0) {
197 |             unset($options['epoch']);
198 |         }
199 | 
200 |         ksort($options);
201 |     }
202 | 
203 |     /**
204 |      * @param 0|positive-int $timestamp
205 |      *
206 |      * @return 0|positive-int
207 |      */
208 |     private function timecode(int $timestamp): int
209 |     {
210 |         $timecode = (int) floor(($timestamp - $this->getEpoch()) / $this->getPeriod());
211 |         assert($timecode >= 0);
212 | 
213 |         return $timecode;
214 |     }
215 | }
216 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/TOTPInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace OTPHP;
 6 | 
 7 | interface TOTPInterface extends OTPInterface
 8 | {
 9 |     public const DEFAULT_PERIOD = 30;
10 | 
11 |     public const DEFAULT_EPOCH = 0;
12 | 
13 |     /**
14 |      * Create a new TOTP object.
15 |      *
16 |      * If the secret is null, a random 64 bytes secret will be generated.
17 |      *
18 |      * @param null|non-empty-string $secret
19 |      * @param positive-int $period
20 |      * @param non-empty-string $digest
21 |      * @param positive-int $digits
22 |      *
23 |      * @deprecated Deprecated since v11.1, use ::createFromSecret or ::generate instead
24 |      */
25 |     public static function create(
26 |         null|string $secret = null,
27 |         int $period = self::DEFAULT_PERIOD,
28 |         string $digest = self::DEFAULT_DIGEST,
29 |         int $digits = self::DEFAULT_DIGITS
30 |     ): self;
31 | 
32 |     public function setPeriod(int $period): void;
33 | 
34 |     public function setEpoch(int $epoch): void;
35 | 
36 |     /**
37 |      * Return the TOTP at the current time.
38 |      *
39 |      * @return non-empty-string
40 |      */
41 |     public function now(): string;
42 | 
43 |     /**
44 |      * Get the period of time for OTP generation (a non-null positive integer, in second).
45 |      */
46 |     public function getPeriod(): int;
47 | 
48 |     public function expiresIn(): int;
49 | 
50 |     public function getEpoch(): int;
51 | }
52 | 


--------------------------------------------------------------------------------
/vendor/spomky-labs/otphp/src/Url.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace OTPHP;
  6 | 
  7 | use InvalidArgumentException;
  8 | use function array_key_exists;
  9 | use function is_string;
 10 | 
 11 | /**
 12 |  * @internal
 13 |  */
 14 | final class Url
 15 | {
 16 |     /**
 17 |      * @param non-empty-string $scheme
 18 |      * @param non-empty-string $host
 19 |      * @param non-empty-string $path
 20 |      * @param non-empty-string $secret
 21 |      * @param array<non-empty-string, mixed> $query
 22 |      */
 23 |     public function __construct(
 24 |         private readonly string $scheme,
 25 |         private readonly string $host,
 26 |         private readonly string $path,
 27 |         private readonly string $secret,
 28 |         private readonly array $query
 29 |     ) {
 30 |     }
 31 | 
 32 |     /**
 33 |      * @return non-empty-string
 34 |      */
 35 |     public function getScheme(): string
 36 |     {
 37 |         return $this->scheme;
 38 |     }
 39 | 
 40 |     /**
 41 |      * @return non-empty-string
 42 |      */
 43 |     public function getHost(): string
 44 |     {
 45 |         return $this->host;
 46 |     }
 47 | 
 48 |     /**
 49 |      * @return non-empty-string
 50 |      */
 51 |     public function getPath(): string
 52 |     {
 53 |         return $this->path;
 54 |     }
 55 | 
 56 |     /**
 57 |      * @return non-empty-string
 58 |      */
 59 |     public function getSecret(): string
 60 |     {
 61 |         return $this->secret;
 62 |     }
 63 | 
 64 |     /**
 65 |      * @return array<non-empty-string, mixed>
 66 |      */
 67 |     public function getQuery(): array
 68 |     {
 69 |         return $this->query;
 70 |     }
 71 | 
 72 |     /**
 73 |      * @param non-empty-string $uri
 74 |      */
 75 |     public static function fromString(string $uri): self
 76 |     {
 77 |         $parsed_url = parse_url($uri);
 78 |         $parsed_url !== false || throw new InvalidArgumentException('Invalid URI.');
 79 |         foreach (['scheme', 'host', 'path', 'query'] as $key) {
 80 |             array_key_exists($key, $parsed_url) || throw new InvalidArgumentException(
 81 |                 'Not a valid OTP provisioning URI'
 82 |             );
 83 |         }
 84 |         $scheme = $parsed_url['scheme'] ?? null;
 85 |         $host = $parsed_url['host'] ?? null;
 86 |         $path = $parsed_url['path'] ?? null;
 87 |         $query = $parsed_url['query'] ?? null;
 88 |         $scheme === 'otpauth' || throw new InvalidArgumentException('Not a valid OTP provisioning URI');
 89 |         is_string($host) || throw new InvalidArgumentException('Invalid URI.');
 90 |         is_string($path) || throw new InvalidArgumentException('Invalid URI.');
 91 |         is_string($query) || throw new InvalidArgumentException('Invalid URI.');
 92 |         $parsedQuery = [];
 93 |         parse_str($query, $parsedQuery);
 94 |         array_key_exists('secret', $parsedQuery) || throw new InvalidArgumentException(
 95 |             'Not a valid OTP provisioning URI'
 96 |         );
 97 |         $secret = $parsedQuery['secret'];
 98 |         unset($parsedQuery['secret']);
 99 | 
100 |         return new self($scheme, $host, $path, $secret, $parsedQuery);
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/vendor/symfony/deprecation-contracts/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | CHANGELOG
2 | =========
3 | 
4 | The changelog is maintained for all Symfony contracts at the following URL:
5 | https://github.com/symfony/contracts/blob/main/CHANGELOG.md
6 | 


--------------------------------------------------------------------------------
/vendor/symfony/deprecation-contracts/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2020-present Fabien Potencier
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is furnished
 8 | to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/vendor/symfony/deprecation-contracts/README.md:
--------------------------------------------------------------------------------
 1 | Symfony Deprecation Contracts
 2 | =============================
 3 | 
 4 | A generic function and convention to trigger deprecation notices.
 5 | 
 6 | This package provides a single global function named `trigger_deprecation()` that triggers silenced deprecation notices.
 7 | 
 8 | By using a custom PHP error handler such as the one provided by the Symfony ErrorHandler component,
 9 | the triggered deprecations can be caught and logged for later discovery, both on dev and prod environments.
10 | 
11 | The function requires at least 3 arguments:
12 |  - the name of the Composer package that is triggering the deprecation
13 |  - the version of the package that introduced the deprecation
14 |  - the message of the deprecation
15 |  - more arguments can be provided: they will be inserted in the message using `printf()` formatting
16 | 
17 | Example:
18 | ```php
19 | trigger_deprecation('symfony/blockchain', '8.9', 'Using "%s" is deprecated, use "%s" instead.', 'bitcoin', 'fabcoin');
20 | ```
21 | 
22 | This will generate the following message:
23 | `Since symfony/blockchain 8.9: Using "bitcoin" is deprecated, use "fabcoin" instead.`
24 | 
25 | While not recommended, the deprecation notices can be completely ignored by declaring an empty
26 | `function trigger_deprecation() {}` in your application.
27 | 


--------------------------------------------------------------------------------
/vendor/symfony/deprecation-contracts/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "symfony/deprecation-contracts",
 3 |     "type": "library",
 4 |     "description": "A generic function and convention to trigger deprecation notices",
 5 |     "homepage": "https://symfony.com",
 6 |     "license": "MIT",
 7 |     "authors": [
 8 |         {
 9 |             "name": "Nicolas Grekas",
10 |             "email": "p@tchwork.com"
11 |         },
12 |         {
13 |             "name": "Symfony Community",
14 |             "homepage": "https://symfony.com/contributors"
15 |         }
16 |     ],
17 |     "require": {
18 |         "php": ">=8.1"
19 |     },
20 |     "autoload": {
21 |         "files": [
22 |             "function.php"
23 |         ]
24 |     },
25 |     "minimum-stability": "dev",
26 |     "extra": {
27 |         "branch-alias": {
28 |             "dev-main": "3.5-dev"
29 |         },
30 |         "thanks": {
31 |             "name": "symfony/contracts",
32 |             "url": "https://github.com/symfony/contracts"
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/vendor/symfony/deprecation-contracts/function.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * This file is part of the Symfony package.
 5 |  *
 6 |  * (c) Fabien Potencier <fabien@symfony.com>
 7 |  *
 8 |  * For the full copyright and license information, please view the LICENSE
 9 |  * file that was distributed with this source code.
10 |  */
11 | 
12 | if (!function_exists('trigger_deprecation')) {
13 |     /**
14 |      * Triggers a silenced deprecation notice.
15 |      *
16 |      * @param string $package The name of the Composer package that is triggering the deprecation
17 |      * @param string $version The version of the package that introduced the deprecation
18 |      * @param string $message The message of the deprecation
19 |      * @param mixed  ...$args Values to insert in the message using printf() formatting
20 |      *
21 |      * @author Nicolas Grekas <p@tchwork.com>
22 |      */
23 |     function trigger_deprecation(string $package, string $version, string $message, mixed ...$args): void
24 |     {
25 |         @trigger_error(($package || $version ? "Since $package $version: " : '').($args ? vsprintf($message, $args) : $message), \E_USER_DEPRECATED);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------