duplicated TP4

BackEnd/src/api.php

+<?php
+
+    // define __ROOT_DIR constant which contains the absolute path on disk
+    // of the directory that contains this file (index.php)
+    // e.g. http://eden.imt-lille-douai.fr/~luc.fabresse/index.php => __ROOT_DIR = /home/luc.fabresse/public_html
+    $rootDirectoryPath = realpath(dirname(__FILE__));
+    define ('__ROOT_DIR', $rootDirectoryPath );
+
+    // Load all application config
+    require_once(__ROOT_DIR . "/config/config.php");
+
+    // Load the Loader class to automatically load classes when needed
+    require_once(__ROOT_DIR . '/classes/AutoLoader.class.php');
+
+    // Reify the current request
+    $request = Request::getCurrentRequest();
+    Response::interceptEchos();
+
+    try {
+        $controller = Dispatcher::dispatch($request);
+        $response = $controller->execute();
+    } catch (Exception $e) {
+        $log = Response::getEchos();
+        $log .= " " . $e->getMessage();
+        $response = Response::errorResponse($log);
+    }
+
+    $response->send();
\ No newline at end of file

BackEnd/src/classes/AutoLoader.class.php

+<?php
+
+class AutoLoader {
+    
+
+    public function __construct() {
+        spl_autoload_register( array($this, 'load') );
+        // spl_autoload_register(array($this, 'loadComplete'));
+    }
+
+    // This method will be automatically executed by PHP whenever it encounters an unknown class name in the source code
+    private function load($className) {
+        if(in_array($className.'.class.php', scandir("model"))){
+            require_once "model/$className.class.php";
+            if (is_readable("sql/$className.sql.php")) 
+                require_once "sql/$className.sql.php";
+        }
+
+        if (in_array($className.'.class.php', scandir("classes"))) 
+            require_once "classes/$className.class.php";
+        
+        if (in_array($className.'.class.php', scandir("controller"))) 
+            require_once "controller/$className.class.php";
+
+
+        // TODO : compute path of the file to load (cf. PHP function is_readable)
+        // it is in one of these subdirectory '/classes/', '/model/', '/controller/'
+        // if it is a model, load its sql queries file too in sql/ directory
+
+    }
+}
+
+$__LOADER = new AutoLoader();
\ No newline at end of file

BackEnd/src/classes/DatabasePDO.class.php

+<?php
+
+class DatabasePDO extends PDO {
+
+   protected static $singleton = NULL;
+
+   public static function singleton(){
+      if(is_null(static::$singleton))
+         static::$singleton = new static();
+
+      return static::$singleton;
+   }
+
+   public function __construct() {
+       // $db = new PDO("sqlite::memory");
+
+       $connectionString = "mysql:host=". DB_HOST;
+
+       if(defined('DB_PORT'))
+           $connectionString .= ";port=". DB_PORT;
+
+       $connectionString .= ";dbname=" . DB_DATABASE;
+       $connectionString .= ";charset=utf8";
+
+      parent::__construct($connectionString,DB_USERNAME,DB_PASSWORD);
+      $this->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+   }
+}
\ No newline at end of file

BackEnd/src/classes/Dispatcher.class.php

+<?php
+
+/*
+* Analyses a request, created the right Controller passing it the request
+*/
+
+class Dispatcher {
+
+    public static function dispatch($request) {
+        return static::dispatchToController($request->getControllerName(),$request);
+    }
+
+    public static function dispatchToController($controllerName, $request) {
+        $controllerClassName = ucfirst($controllerName) . 'Controller';
+
+        if(!class_exists($controllerClassName))
+            throw(new Exception("Class $controllerName does not exist"));
+        
+        return new $controllerClassName($controllerName, $request);
+    }
+}
\ No newline at end of file

BackEnd/src/classes/Request.class.php

+<?php
+class Request {
+
+    protected $controllerName;
+    protected $uriParameters;
+    protected $data;
+    protected static $_instance;
+
+    public static function getCurrentRequest(){
+        if(is_null(self::$_instance)) {
+            self::$_instance = new Request();  
+          }
+      
+          return self::$_instance;
+    }
+
+   public function __construct() {
+      $this->initBaseURI();
+      $this->initControllerAndParametersFromURI();
+      $this->initData();
+   }
+
+   // intialise baseURI
+   // e.g. http://eden.imt-lille-douai.fr/~luc.fabresse/api.php => __BASE_URI = /~luc.fabresse
+   // e.g. http://localhost/CDAW/api.php => __BASE_URI = /CDAW
+   protected function initBaseURI() {
+      $this->baseURI = parse_url($_SERVER['REQUEST_URI'], PHP_URL_QUERY);
+   }
+
+   // intialise controllerName et uriParameters
+   // controllerName contient chaîne 'default' ou le nom du controleur s'il est présent dans l'URI (la requête)
+   // uriParameters contient un tableau vide ou un tableau contenant les paramètres passés dans l'URI (la requête)
+   // e.g. http://eden.imt-lille-douai.fr/~luc.fabresse/api.php
+   //    => controllerName == 'default'
+   //       uriParameters == []
+   // e.g. http://eden.imt-lille-douai.fr/~luc.fabresse/api.php/user/1
+   //    => controllerName == 'user'
+   //       uriParameters == [ 1 ]
+   protected function initControllerAndParametersFromURI(){
+
+        $prefix = $_SERVER['SCRIPT_NAME'];
+        $uriParameters = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
+
+        $i=0;
+        while($i<strlen($prefix) && $i<strlen($uriParameters))
+        if($prefix[$i]===$uriParameters[$i])
+        $i++;
+
+        $uriParameters = substr($uriParameters, $i);
+
+        $uriParameters = trim($uriParameters, '/');
+        $uriSegments = explode('/', $uriParameters);
+
+        $this->controllerName = array_shift($uriSegments) ?: "default";
+        $this->uriParameters = $uriSegments;
+    }
+
+   // ==============
+   // Public API
+   // ==============
+
+    // retourne le name du controleur qui doit traiter la requête courante
+    public function getControllerName() {
+      return $this->controllerName;
+   }
+
+   public function getUriParams() {
+      return $this->uriParameters;
+   }
+
+   public function initData() {
+      if ($this->getHttpMethod() === 'PUT' || $this->getHttpMethod() === 'POST'){
+         $jsondata=file_get_contents("php://input");
+         $this->data = json_decode($jsondata, true);   
+      }
+         
+   }
+   
+
+    // retourne la méthode HTTP utilisée dans la requête courante
+    public function getHttpMethod() {
+      return $_SERVER["REQUEST_METHOD"];
+   }
+
+   public function getData() {
+      return $this->data;
+   }
+   // returns JWT token in Authorization header or throw an exception
+   public function getJwtToken() {
+      $headers = getallheaders();
+      $autorization = $headers['Authorization'];
+      $arr = explode(" ", $autorization);
+
+      if(count($arr)<2)
+         throw new Exception("Missing JWT token");
+
+      $jwt_token = $arr[1];
+
+      return $jwt_token;
+   }
+
+   
+
+}
\ No newline at end of file

BackEnd/src/classes/Response.class.php

+<?php
+class Response {
+   protected $code;
+   protected $body;
+
+   public function __construct($code = 404, $msg = "") {
+      $this->code = $code;
+      $this->body = $msg;
+   }
+
+   public static function errorResponse($message = "") {
+      return new Response(400,$message);
+   }
+
+   public static function serverErrorResponse($message = "")
+   {
+      return new Response(500,$message);
+   }
+
+   public static function okResponse($message = "")
+   {
+      return new Response(200,$message);
+   }
+
+   public static function notFoundResponse($message = "")
+   {
+      return new Response(404,$message);
+   }
+
+   public static function errorInParametersResponse($message = "")
+   {
+      return new Response(400,$message);
+   }
+   
+   public static function unauthorizedResponse($message = "")
+   {
+      return new Response(401,$message);
+   }
+
+   public static function interceptEchos() {
+      ob_start();
+   }
+
+   public static function getEchos() {
+      return ob_get_clean();
+   }
+
+   public function send() {
+      // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin
+      header("Access-Control-Allow-Origin: *");
+
+      header("Content-Type: application/json; charset=UTF-8");
+
+      // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Methods
+      header("Access-Control-Allow-Methods: GET,POST,PUT,DELETE");
+
+      header("Access-Control-Max-Age: 3600"); // Maximum number of seconds the results can be cached.
+
+      // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers
+      header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
+
+      http_response_code($this->code);
+      echo $this->body;
+      exit; // do we keep that?
+   }
+}
\ No newline at end of file

BackEnd/src/config/config.php

+<?php
+define('DB_HOST','127.0.0.1');
+define('DB_PORT',3306);
+define('DB_DATABASE','dbtest');
+define('DB_USERNAME','root');
+define('DB_PASSWORD','');
+
+// define('__DEBUG', false);
+define('__DEBUG', true);
+
+define( 'JWT_BACKEND_KEY', '6d8HbcZndVGNAbo4Ih1TGaKcuA1y2BKs-I5CmP' );
+define( 'JWT_ISSUER', $_SERVER['HTTP_HOST'] . $_SERVER['CONTEXT_PREFIX']);
+
+
+// ================================================================================
+// Debug utilities
+// ================================================================================
+
+if(__DEBUG) {
+    error_reporting(E_ALL);
+    ini_set("display_errors", E_ALL);
+} else {
+    error_reporting(0);
+    ini_set("display_errors", 0);
+}
+
+function myLog($msg) {
+    if(__DEBUG) {
+        echo $msg;
+    }
+}
+
+function myDump($var) {
+    if(__DEBUG) {
+        var_dump($var);
+    }
+}
\ No newline at end of file

BackEnd/src/controller/Controller.class.php

+<?php
+
+/*
+* A Controller is dedicated to process a request
+* its responsabilities are:
+* - analyses the action to be done
+* - analyses the parameters
+* - act on the model objects to perform the action
+* - process the data
+* - call the view and passes it the data
+* - return the response
+*/
+
+abstract class Controller {
+
+    protected $name;
+    protected $request;
+
+    public function __construct($name, $request) {
+        $this->request = $request;
+        $this->name = $name;
+    }
+
+    public abstract function processRequest();
+
+    public function execute() {
+        $response = $this->processRequest();
+        if(empty($response)) {
+            // $response = Response::serverErrorResponse("error processing request in ". self::class); // Oh my PHP!
+            $response = Response::serverErrorResponse("error processing request in ". static::class);
+        }
+        return $response;
+    }
+
+
+}
\ No newline at end of file

BackEnd/src/controller/DefaultController.class.php

+<?php
+
+class DefaultController extends Controller {
+
+   public function __construct($name, $request) {
+      parent::__construct($name, $request);
+   }
+
+
+   // ==============
+   // Actions
+   // ==============
+
+    public function processRequest() {
+      return Response::errorResponse('{ "message" : "Unsupported endpoint"}' );
+    }
+
+}
\ No newline at end of file

BackEnd/src/controller/LoginController.class.php

+<?php
+include_once __ROOT_DIR . '/libs/php-jwt/src/BeforeValidException.php';
+include_once __ROOT_DIR . '/libs/php-jwt/src/ExpiredException.php';
+include_once __ROOT_DIR . '/libs/php-jwt/src/SignatureInvalidException.php';
+include_once __ROOT_DIR . '/libs/php-jwt/src/JWT.php';
+use \Firebase\JWT\JWT;
+
+class LoginController extends Controller {
+
+   public function __construct($name, $request) {
+      parent::__construct($name, $request);
+   }
+
+    public function processRequest() {
+      if($this->request->getHttpMethod() !== 'POST')
+         return Response::errorResponse('{ "message" : "Unsupported endpoint" }' );
+
+      $json = $this->request->getData();
+      if(!isset($json['login']) || !isset($json['login'])) {
+         $r = new Response(422,"login and pwd fields are mandatory");
+            $r->send();
+      }
+
+      $user = User::tryLogin($json['login']);
+      if(empty($user) || !hash_equals($json['pwd'],$user->password())) {
+            $r = new Response(422,"wrong credentials");
+            $r->send();
+      }
+
+      // generate json web token
+      $issued_at = time();
+      $expiration_time = $issued_at + (60 * 60); // valid for 1 hour
+
+      $token = array(
+         "iat" => $issued_at,
+         "exp" => $expiration_time,
+         "iss" => JWT_ISSUER,
+         "data" => array(
+            "id" => $user->id(),
+            "firstname" => $user->firstname(),
+            "lastname" => $user->lastname(),
+            "email" => $user->email()
+         )
+      );
+
+      $jwt = JWT::encode( $token, JWT_BACKEND_KEY );
+      $jsonResult = json_encode(
+            array(
+               "jwt_token" => $jwt
+            )
+      );
+
+        return Response::okResponse($jsonResult);
+    }
+}
\ No newline at end of file

BackEnd/src/controller/UserController.class.php

+<?php
+include_once __ROOT_DIR . '/libs/php-jwt/src/BeforeValidException.php';
+include_once __ROOT_DIR . '/libs/php-jwt/src/ExpiredException.php';
+include_once __ROOT_DIR . '/libs/php-jwt/src/SignatureInvalidException.php';
+include_once __ROOT_DIR . '/libs/php-jwt/src/JWT.php';
+use \Firebase\JWT\JWT;
+class UserController extends Controller {
+
+    public function __construct($name, $request) {
+        parent::__construct($name, $request);
+    }
+
+    // ==============
+    // Actions
+    // ==============
+
+    public function processRequest()
+    {
+         switch ($this->request->getHttpMethod()) {
+            case 'GET':
+                if ($this->request->getUriParams())
+                    return $this->getUser($this->request->getUriParams()[0]);
+
+                return $this->getAllUsers();
+                break;
+            case 'PUT':
+                if ($this->request->getUriParams())
+                    return $this->updateUser(array_merge($this->request->getData(),['id'=>$this->request->getUriParams()[0]]));
+                break;
+        }
+        return Response::errorResponse("unsupported parameters or method in users");
+    }
+
+    protected function getAllUsers()
+    {
+        $users = User::getList();
+        $response = Response::okResponse(json_encode($users));
+        //var_dump($json);die;
+        // TODO
+        return $response;
+    }
+
+    protected function getUser($id){
+        $user = User::getRow($id);
+        $response = Response::okResponse(json_encode($user));
+        return $response;
+    }
+    protected function updateUser($array){
+        try {
+            //var_dump($array);die;
+            $jwt_token = $this->request->getJwtToken();
+            // echo "jwt = $jwt_token";
+            $decodedJWT = JWT::decode($jwt_token, JWT_BACKEND_KEY, array('HS256'));
+            
+            if($decodedJWT->data->id != $array['id']){
+                throw new Exception("You don't have access to this account.", 1);
+            } 
+            
+            User::updateUser($array);
+   
+         } catch (Exception $e){
+            header('WWW-Authenticate: Bearer realm="'.JWT_ISSUER.'"');
+   
+            $jsonResult =  json_encode(array(
+                "message" => "Access denied.",
+                "error" => $e->getMessage()
+            ));
+            return Response::unauthorizedResponse($jsonResult);
+         }
+         $response = Response::okResponse('User succesfully updated !');
+         return $response;
+    }
+}
\ No newline at end of file

BackEnd/src/controller/ValidateTokenController.class.php

+<?php
+
+include_once __ROOT_DIR . '/libs/php-jwt/src/BeforeValidException.php';
+include_once __ROOT_DIR . '/libs/php-jwt/src/ExpiredException.php';
+include_once __ROOT_DIR . '/libs/php-jwt/src/SignatureInvalidException.php';
+include_once __ROOT_DIR . '/libs/php-jwt/src/JWT.php';
+use \Firebase\JWT\JWT;
+
+class ValidateTokenController extends Controller {
+
+   public function __construct($name, $request) {
+      parent::__construct($name, $request);
+   }
+
+    public function processRequest() {
+      try {
+         $jwt_token = $this->request->getJwtToken();
+         // echo "jwt = $jwt_token";
+         $decodedJWT = JWT::decode($jwt_token, JWT_BACKEND_KEY, array('HS256'));
+         $jsonResult = json_encode(array(
+             "message" => "Access granted.",
+             "data" => $decodedJWT
+         ));
+
+      } catch (Exception $e){
+         header('WWW-Authenticate: Bearer realm="'.JWT_ISSUER.'"');
+
+         $jsonResult =  json_encode(array(
+             "message" => "Access denied.",
+             "error" => $e->getMessage()
+         ));
+         return Response::unauthorizedResponse($jsonResult);
+      }
+      $response = Response::okResponse($jsonResult);
+      return $response;
+    }
+}
\ No newline at end of file

BackEnd/src/libs/php-jwt/LICENSE

+Copyright (c) 2011, Neuman Vong
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Neuman Vong nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

BackEnd/src/libs/php-jwt/README.md

+[![Build Status](https://travis-ci.org/firebase/php-jwt.png?branch=master)](https://travis-ci.org/firebase/php-jwt)
+[![Latest Stable Version](https://poser.pugx.org/firebase/php-jwt/v/stable)](https://packagist.org/packages/firebase/php-jwt)
+[![Total Downloads](https://poser.pugx.org/firebase/php-jwt/downloads)](https://packagist.org/packages/firebase/php-jwt)
+[![License](https://poser.pugx.org/firebase/php-jwt/license)](https://packagist.org/packages/firebase/php-jwt)
+
+PHP-JWT
+=======
+A simple library to encode and decode JSON Web Tokens (JWT) in PHP, conforming to [RFC 7519](https://tools.ietf.org/html/rfc7519).
+
+Installation
+------------
+
+Use composer to manage your dependencies and download PHP-JWT:
+
+```bash
+composer require firebase/php-jwt
+```
+
+Example
+-------
+```php
+<?php
+use \Firebase\JWT\JWT;
+
+$key = "example_key";
+$payload = array(
+    "iss" => "http://example.org",
+    "aud" => "http://example.com",
+    "iat" => 1356999524,
+    "nbf" => 1357000000
+);
+
+/**
+ * IMPORTANT:
+ * You must specify supported algorithms for your application. See
+ * https://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-40
+ * for a list of spec-compliant algorithms.
+ */
+$jwt = JWT::encode($payload, $key);
+$decoded = JWT::decode($jwt, $key, array('HS256'));
+
+print_r($decoded);
+
+/*
+ NOTE: This will now be an object instead of an associative array. To get
+ an associative array, you will need to cast it as such:
+*/
+
+$decoded_array = (array) $decoded;
+
+/**
+ * You can add a leeway to account for when there is a clock skew times between
+ * the signing and verifying servers. It is recommended that this leeway should
+ * not be bigger than a few minutes.
+ *
+ * Source: http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html#nbfDef
+ */
+JWT::$leeway = 60; // $leeway in seconds
+$decoded = JWT::decode($jwt, $key, array('HS256'));
+
+?>
+```
+Example with RS256 (openssl)
+----------------------------
+```php
+<?php
+use \Firebase\JWT\JWT;
+
+$privateKey = <<<EOD
+-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQC8kGa1pSjbSYZVebtTRBLxBz5H4i2p/llLCrEeQhta5kaQu/Rn
+vuER4W8oDH3+3iuIYW4VQAzyqFpwuzjkDI+17t5t0tyazyZ8JXw+KgXTxldMPEL9
+5+qVhgXvwtihXC1c5oGbRlEDvDF6Sa53rcFVsYJ4ehde/zUxo6UvS7UrBQIDAQAB
+AoGAb/MXV46XxCFRxNuB8LyAtmLDgi/xRnTAlMHjSACddwkyKem8//8eZtw9fzxz
+bWZ/1/doQOuHBGYZU8aDzzj59FZ78dyzNFoF91hbvZKkg+6wGyd/LrGVEB+Xre0J
+Nil0GReM2AHDNZUYRv+HYJPIOrB0CRczLQsgFJ8K6aAD6F0CQQDzbpjYdx10qgK1
+cP59UHiHjPZYC0loEsk7s+hUmT3QHerAQJMZWC11Qrn2N+ybwwNblDKv+s5qgMQ5
+5tNoQ9IfAkEAxkyffU6ythpg/H0Ixe1I2rd0GbF05biIzO/i77Det3n4YsJVlDck
+ZkcvY3SK2iRIL4c9yY6hlIhs+K9wXTtGWwJBAO9Dskl48mO7woPR9uD22jDpNSwe
+k90OMepTjzSvlhjbfuPN1IdhqvSJTDychRwn1kIJ7LQZgQ8fVz9OCFZ/6qMCQGOb
+qaGwHmUK6xzpUbbacnYrIM6nLSkXgOAwv7XXCojvY614ILTK3iXiLBOxPu5Eu13k
+eUz9sHyD6vkgZzjtxXECQAkp4Xerf5TGfQXGXhxIX52yH+N2LtujCdkQZjXAsGdm
+B2zNzvrlgRmgBrklMTrMYgm1NPcW+bRLGcwgW2PTvNM=
+-----END RSA PRIVATE KEY-----
+EOD;
+
+$publicKey = <<<EOD
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8kGa1pSjbSYZVebtTRBLxBz5H
+4i2p/llLCrEeQhta5kaQu/RnvuER4W8oDH3+3iuIYW4VQAzyqFpwuzjkDI+17t5t
+0tyazyZ8JXw+KgXTxldMPEL95+qVhgXvwtihXC1c5oGbRlEDvDF6Sa53rcFVsYJ4
+ehde/zUxo6UvS7UrBQIDAQAB
+-----END PUBLIC KEY-----
+EOD;
+
+$payload = array(
+    "iss" => "example.org",
+    "aud" => "example.com",
+    "iat" => 1356999524,
+    "nbf" => 1357000000
+);
+
+$jwt = JWT::encode($payload, $privateKey, 'RS256');
+echo "Encode:\n" . print_r($jwt, true) . "\n";
+
+$decoded = JWT::decode($jwt, $publicKey, array('RS256'));
+
+/*
+ NOTE: This will now be an object instead of an associative array. To get
+ an associative array, you will need to cast it as such:
+*/
+
+$decoded_array = (array) $decoded;
+echo "Decode:\n" . print_r($decoded_array, true) . "\n";
+?>
+```
+
+Using JWKs
+----------
+
+```php
+// Set of keys. The "keys" key is required. For example, the JSON response to
+// this endpoint: https://www.gstatic.com/iap/verify/public_key-jwk
+$jwks = ['keys' => []];
+
+// JWK::parseKeySet($jwks) returns an associative array of **kid** to private
+// key. Pass this as the second parameter to JWT::decode.
+JWT::decode($payload, JWK::parseKeySet($jwks), $supportedAlgorithm);
+```
+
+Changelog
+---------
+
+#### 5.0.0 / 2017-06-26
+- Support RS384 and RS512.
+  See [#117](https://github.com/firebase/php-jwt/pull/117). Thanks [@joostfaassen](https://github.com/joostfaassen)!
+- Add an example for RS256 openssl.
+  See [#125](https://github.com/firebase/php-jwt/pull/125). Thanks [@akeeman](https://github.com/akeeman)!
+- Detect invalid Base64 encoding in signature.
+  See [#162](https://github.com/firebase/php-jwt/pull/162). Thanks [@psignoret](https://github.com/psignoret)!
+- Update `JWT::verify` to handle OpenSSL errors.
+  See [#159](https://github.com/firebase/php-jwt/pull/159). Thanks [@bshaffer](https://github.com/bshaffer)!
+- Add `array` type hinting to `decode` method
+  See [#101](https://github.com/firebase/php-jwt/pull/101). Thanks [@hywak](https://github.com/hywak)!
+- Add all JSON error types.
+  See [#110](https://github.com/firebase/php-jwt/pull/110). Thanks [@gbalduzzi](https://github.com/gbalduzzi)!
+- Bugfix 'kid' not in given key list.
+  See [#129](https://github.com/firebase/php-jwt/pull/129). Thanks [@stampycode](https://github.com/stampycode)!
+- Miscellaneous cleanup, documentation and test fixes.
+  See [#107](https://github.com/firebase/php-jwt/pull/107), [#115](https://github.com/firebase/php-jwt/pull/115),
+  [#160](https://github.com/firebase/php-jwt/pull/160), [#161](https://github.com/firebase/php-jwt/pull/161), and
+  [#165](https://github.com/firebase/php-jwt/pull/165). Thanks [@akeeman](https://github.com/akeeman),
+  [@chinedufn](https://github.com/chinedufn), and [@bshaffer](https://github.com/bshaffer)!
+
+#### 4.0.0 / 2016-07-17
+- Add support for late static binding. See [#88](https://github.com/firebase/php-jwt/pull/88) for details. Thanks to [@chappy84](https://github.com/chappy84)!
+- Use static `$timestamp` instead of `time()` to improve unit testing. See [#93](https://github.com/firebase/php-jwt/pull/93) for details. Thanks to [@josephmcdermott](https://github.com/josephmcdermott)!
+- Fixes to exceptions classes. See [#81](https://github.com/firebase/php-jwt/pull/81) for details. Thanks to [@Maks3w](https://github.com/Maks3w)!
+- Fixes to PHPDoc. See [#76](https://github.com/firebase/php-jwt/pull/76) for details. Thanks to [@akeeman](https://github.com/akeeman)!
+
+#### 3.0.0 / 2015-07-22
+- Minimum PHP version updated from `5.2.0` to `5.3.0`.
+- Add `\Firebase\JWT` namespace. See
+[#59](https://github.com/firebase/php-jwt/pull/59) for details. Thanks to
+[@Dashron](https://github.com/Dashron)!
+- Require a non-empty key to decode and verify a JWT. See
+[#60](https://github.com/firebase/php-jwt/pull/60) for details. Thanks to
+[@sjones608](https://github.com/sjones608)!
+- Cleaner documentation blocks in the code. See
+[#62](https://github.com/firebase/php-jwt/pull/62) for details. Thanks to
+[@johanderuijter](https://github.com/johanderuijter)!
+
+#### 2.2.0 / 2015-06-22
+- Add support for adding custom, optional JWT headers to `JWT::encode()`. See
+[#53](https://github.com/firebase/php-jwt/pull/53/files) for details. Thanks to
+[@mcocaro](https://github.com/mcocaro)!
+
+#### 2.1.0 / 2015-05-20
+- Add support for adding a leeway to `JWT:decode()` that accounts for clock skew
+between signing and verifying entities. Thanks to [@lcabral](https://github.com/lcabral)!
+- Add support for passing an object implementing the `ArrayAccess` interface for
+`$keys` argument in `JWT::decode()`. Thanks to [@aztech-dev](https://github.com/aztech-dev)!
+
+#### 2.0.0 / 2015-04-01
+- **Note**: It is strongly recommended that you update to > v2.0.0 to address
+  known security vulnerabilities in prior versions when both symmetric and
+  asymmetric keys are used together.
+- Update signature for `JWT::decode(...)` to require an array of supported
+  algorithms to use when verifying token signatures.
+
+
+Tests
+-----
+Run the tests using phpunit:
+
+```bash
+$ pear install PHPUnit
+$ phpunit --configuration phpunit.xml.dist
+PHPUnit 3.7.10 by Sebastian Bergmann.
+.....
+Time: 0 seconds, Memory: 2.50Mb
+OK (5 tests, 5 assertions)
+```
+
+New Lines in private keys
+-----
+
+If your private key contains `\n` characters, be sure to wrap it in double quotes `""`
+and not single quotes `''` in order to properly interpret the escaped characters.
+
+License
+-------
+[3-Clause BSD](http://opensource.org/licenses/BSD-3-Clause).

BackEnd/src/libs/php-jwt/composer.json

+{
+    "name": "firebase/php-jwt",
+    "description": "A simple library to encode and decode JSON Web Tokens (JWT) in PHP. Should conform to the current spec.",
+    "homepage": "https://github.com/firebase/php-jwt",
+    "keywords": [
+        "php",
+        "jwt"
+    ],
+    "authors": [
+        {
+            "name": "Neuman Vong",
+            "email": "neuman+pear@twilio.com",
+            "role": "Developer"
+        },
+        {
+            "name": "Anant Narayanan",
+            "email": "anant@php.net",
+            "role": "Developer"
+        }
+    ],
+    "license": "BSD-3-Clause",
+    "require": {
+        "php": ">=5.3.0"
+    },
+    "autoload": {
+        "psr-4": {
+            "Firebase\\JWT\\": "src"
+        }
+    },
+    "require-dev": {
+        "phpunit/phpunit": ">=4.8 <=9"
+    }
+}

BackEnd/src/libs/php-jwt/src/BeforeValidException.php

+<?php
+namespace Firebase\JWT;
+
+class BeforeValidException extends \UnexpectedValueException
+{
+}

BackEnd/src/libs/php-jwt/src/ExpiredException.php

+<?php
+namespace Firebase\JWT;
+
+class ExpiredException extends \UnexpectedValueException
+{
+}

BackEnd/src/libs/php-jwt/src/JWK.php

+<?php
+
+namespace Firebase\JWT;
+
+use DomainException;
+use UnexpectedValueException;
+
+/**
+ * JSON Web Key implementation, based on this spec:
+ * https://tools.ietf.org/html/draft-ietf-jose-json-web-key-41
+ *
+ * PHP version 5
+ *
+ * @category Authentication
+ * @package  Authentication_JWT
+ * @author   Bui Sy Nguyen <nguyenbs@gmail.com>
+ * @license  http://opensource.org/licenses/BSD-3-Clause 3-clause BSD
+ * @link     https://github.com/firebase/php-jwt
+ */
+class JWK
+{
+    /**
+     * Parse a set of JWK keys
+     *
+     * @param array $jwks The JSON Web Key Set as an associative array
+     *
+     * @return array An associative array that represents the set of keys
+     *
+     * @throws InvalidArgumentException     Provided JWK Set is empty
+     * @throws UnexpectedValueException     Provided JWK Set was invalid
+     * @throws DomainException              OpenSSL failure
+     *
+     * @uses parseKey
+     */
+    public static function parseKeySet(array $jwks)
+    {
+        $keys = array();
+
+        if (!isset($jwks['keys'])) {
+            throw new UnexpectedValueException('"keys" member must exist in the JWK Set');
+        }
+        if (empty($jwks['keys'])) {
+            throw new InvalidArgumentException('JWK Set did not contain any keys');
+        }
+
+        foreach ($jwks['keys'] as $k => $v) {
+            $kid = isset($v['kid']) ? $v['kid'] : $k;
+            if ($key = self::parseKey($v)) {
+                $keys[$kid] = $key;
+            }
+        }
+
+        if (0 === \count($keys)) {
+            throw new UnexpectedValueException('No supported algorithms found in JWK Set');
+        }
+
+        return $keys;
+    }
+
+    /**
+     * Parse a JWK key
+     *
+     * @param array $jwk An individual JWK
+     *
+     * @return resource|array An associative array that represents the key
+     *
+     * @throws InvalidArgumentException     Provided JWK is empty
+     * @throws UnexpectedValueException     Provided JWK was invalid
+     * @throws DomainException              OpenSSL failure
+     *
+     * @uses createPemFromModulusAndExponent
+     */
+    private static function parseKey(array $jwk)
+    {
+        if (empty($jwk)) {
+            throw new InvalidArgumentException('JWK must not be empty');
+        }
+        if (!isset($jwk['kty'])) {
+            throw new UnexpectedValueException('JWK must contain a "kty" parameter');
+        }
+
+        switch ($jwk['kty']) {
+            case 'RSA':
+                if (\array_key_exists('d', $jwk)) {
+                    throw new UnexpectedValueException('RSA private keys are not supported');
+                }
+                if (!isset($jwk['n']) || !isset($jwk['e'])) {
+                    throw new UnexpectedValueException('RSA keys must contain values for both "n" and "e"');
+                }
+
+                $pem = self::createPemFromModulusAndExponent($jwk['n'], $jwk['e']);
+                $publicKey = \openssl_pkey_get_public($pem);
+                if (false === $publicKey) {
+                    throw new DomainException(
+                        'OpenSSL error: ' . \openssl_error_string()
+                    );
+                }
+                return $publicKey;
+            default:
+                // Currently only RSA is supported
+                break;
+        }
+    }
+
+    /**
+     * Create a public key represented in PEM format from RSA modulus and exponent information
+     *
+     * @param string $n The RSA modulus encoded in Base64
+     * @param string $e The RSA exponent encoded in Base64
+     *
+     * @return string The RSA public key represented in PEM format
+     *
+     * @uses encodeLength
+     */
+    private static function createPemFromModulusAndExponent($n, $e)
+    {
+        $modulus = JWT::urlsafeB64Decode($n);
+        $publicExponent = JWT::urlsafeB64Decode($e);
+
+        $components = array(
+            'modulus' => \pack('Ca*a*', 2, self::encodeLength(\strlen($modulus)), $modulus),
+            'publicExponent' => \pack('Ca*a*', 2, self::encodeLength(\strlen($publicExponent)), $publicExponent)
+        );
+
+        $rsaPublicKey = \pack(
+            'Ca*a*a*',
+            48,
+            self::encodeLength(\strlen($components['modulus']) + \strlen($components['publicExponent'])),
+            $components['modulus'],
+            $components['publicExponent']
+        );
+
+        // sequence(oid(1.2.840.113549.1.1.1), null)) = rsaEncryption.
+        $rsaOID = \pack('H*', '300d06092a864886f70d0101010500'); // hex version of MA0GCSqGSIb3DQEBAQUA
+        $rsaPublicKey = \chr(0) . $rsaPublicKey;
+        $rsaPublicKey = \chr(3) . self::encodeLength(\strlen($rsaPublicKey)) . $rsaPublicKey;
+
+        $rsaPublicKey = \pack(
+            'Ca*a*',
+            48,
+            self::encodeLength(\strlen($rsaOID . $rsaPublicKey)),
+            $rsaOID . $rsaPublicKey
+        );
+
+        $rsaPublicKey = "-----BEGIN PUBLIC KEY-----\r\n" .
+            \chunk_split(\base64_encode($rsaPublicKey), 64) .
+            '-----END PUBLIC KEY-----';
+
+        return $rsaPublicKey;
+    }
+
+    /**
+     * DER-encode the length
+     *
+     * DER supports lengths up to (2**8)**127, however, we'll only support lengths up to (2**8)**4.  See
+     * {@link http://itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf#p=13 X.690 paragraph 8.1.3} for more information.
+     *
+     * @param int $length
+     * @return string
+     */
+    private static function encodeLength($length)
+    {
+        if ($length <= 0x7F) {
+            return \chr($length);
+        }
+
+        $temp = \ltrim(\pack('N', $length), \chr(0));
+
+        return \pack('Ca*', 0x80 | \strlen($temp), $temp);
+    }
+}

BackEnd/src/libs/php-jwt/src/SignatureInvalidException.php

+<?php
+namespace Firebase\JWT;
+
+class SignatureInvalidException extends \UnexpectedValueException
+{
+}

BackEnd/src/model/Model.class.php

+<?php
+
+class Model {
+
+    protected static function db(){
+        return DatabasePDO::singleton();
+    }
+
+    // *** Queries in sql/model.sql.php ****
+    protected static $requests = array();
+
+    public static function addSqlQuery($key, $sql){
+        static::$requests[$key] = $sql;
+    }
+
+    public static function sqlQueryNamed($key){
+        return static::$requests[$key];
+    }
+
+    protected static function query($sql){
+        $st = static::db()->query($sql)  or die("sql query error ! request : " . $sql);
+        $st->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, get_called_class());
+        return $st;
+    }
+
+    protected static function exec($sqlKey,$values=array()){
+        $sth = static::db()->prepare(static::sqlQueryNamed($sqlKey));
+        $sth->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, get_called_class());
+        $sth->execute($values);
+        return $sth;
+    }
+}
\ No newline at end of file

BackEnd/src/model/User.class.php

+<?php
+
+class User extends Model {
+
+   // ===========
+   // = Statics =
+   // ===========
+   protected static $table_name = 'USER';
+
+   // load all users from Db
+   public static function getList() {
+      $stm = parent::exec('USER_LIST');
+      return $stm->fetchAll();
+   }
+   public static function getRow($id) {
+      $stm = parent::exec('USER_GET_WITH_ID', ['id' => $id]);
+      return $stm->fetchAll();
+   }
+
+   public static function updateUser($array) {
+      $stm = parent::exec('USER_UPDATE', $array);
+   }
+
+   public static function tryLogin($login){
+      $stm = parent::exec('USER_GET_WITH_LOGIN', ['login' => $login]);
+      return $stm->fetchAll(PDO::FETCH_CLASS, 'User')[0];
+   }
+
+   public function password(){
+      return trim($this->USER_PWD);
+   }
+   public function id(){
+      return trim($this->USER_ID);
+   }
+   public function firstname(){
+      return trim($this->USER_NAME);
+   }
+   public function lastname(){
+      return trim($this->USER_SURNAME);
+   }
+   public function email(){
+      return trim($this->USER_EMAIL);
+   }
+   
+
+}
\ No newline at end of file

BackEnd/src/sql/User.sql.php

+<?php
+
+User::addSqlQuery('USER_LIST',
+    'SELECT * FROM  USER ORDER BY USER_LOGIN');
+
+User::addSqlQuery('USER_GET_WITH_LOGIN',
+'SELECT * FROM USER WHERE USER_LOGIN=:login');
+
+User::addSqlQuery('USER_GET_WITH_ID',
+'SELECT * FROM USER WHERE USER_ID=:id');
+
+User::addSqlQuery('USER_CREATE',
+    'INSERT INTO USER (USER_ID, USER_LOGIN, USER_EMAIL, USER_ROLE, USER_PWD, USER_NAME, USER_SURNAME) VALUES (NULL, :login, :email, :role, :pwd, :name, :surname)');
+
+User::addSqlQuery('USER_CONNECT',
+    'SELECT * FROM USER WHERE USER_LOGIN=:login and USER_PWD=:password');
+
+User::addSqlQuery('USER_UPDATE',
+    'UPDATE USER SET USER_EMAIL = :email WHERE USER_ID = :id');
\ No newline at end of file

BackEnd/src/sql/createDB.sql

+-- phpMyAdmin SQL Dump
+-- version 5.0.3
+-- https://www.phpmyadmin.net/
+--
+-- Host: localhost
+-- Generation Time: Nov 13, 2020 at 05:47 PM
+-- Server version: 10.4.14-MariaDB
+-- PHP Version: 7.4.11
+
+SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
+START TRANSACTION;
+SET time_zone = "+00:00";
+
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+/*!40101 SET NAMES utf8mb4 */;
+
+--
+-- Database: `dbtest`
+--
+
+-- --------------------------------------------------------
+
+--
+-- Table structure for table `USER`
+--
+
+CREATE TABLE `USER` (
+  `USER_ID` int(11) NOT NULL,
+  `USER_LOGIN` varchar(55) NOT NULL,
+  `USER_EMAIL` varchar(100) NOT NULL,
+  `USER_ROLE` varchar(100) NOT NULL,
+  `USER_PWD` varchar(100) NOT NULL,
+  `USER_NAME` varchar(55) NOT NULL,
+  `USER_SURNAME` varchar(55) NOT NULL
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+--
+-- Dumping data for table `USER`
+--
+
+INSERT INTO `USER` (`USER_ID`, `USER_LOGIN`, `USER_EMAIL`, `USER_ROLE`, `USER_PWD`, `USER_NAME`, `USER_SURNAME`) VALUES
+(1, 'qvrel', 'qvrel@mail.fr', 'Admin', '123456', 'Quentin', 'Vrel');
+
+--
+-- Indexes for dumped tables
+--
+
+--
+-- Indexes for table `USER`
+--
+ALTER TABLE `USER`
+  ADD PRIMARY KEY (`USER_ID`);
+
+--
+-- AUTO_INCREMENT for dumped tables
+--
+
+--
+-- AUTO_INCREMENT for table `USER`
+--
+ALTER TABLE `USER`
+  MODIFY `USER_ID` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=2;
+COMMIT;
+
+/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
+/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
+/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
\ No newline at end of file