login version finale

API_LOGIN/config/core.php

+<?php
+// show error reporting
+error_reporting(E_ALL);
+ 
+// set your default time-zone
+date_default_timezone_set('Asia/Manila');
+ 
+// variables used for jwt
+$key = "example_key";
+$iss = "http://example.org";
+$aud = "http://example.com";
+$iat = 1356999524;
+$nbf = 1357000000;
+?>
\ No newline at end of file

API_LOGIN/config/database.php

+<?php
+    class Database{
+        
+        // specify your own database credentials
+        private $host = "localhost";
+        private $db_name = "liang_wu";
+        private $username = "liang.wu";
+        private $password = "oMmyE2aw";
+        public $conn;
+        
+        // get the database connection
+        public function getConnection(){
+            
+            $this->conn = null;
+            
+            try{
+                $this->conn = new PDO("mysql:host=" . $this->host . ";dbname=" . $this->db_name, $this->username, $this->password);
+                $this->conn->exec("set names utf8");
+            }catch(PDOException $exception){
+                echo "Connection error: " . $exception->getMessage();
+            }
+            
+            return $this->conn;
+        }
+    }
+    ?>

API_LOGIN/identite/create.php

+<?php
+// required headers
+header("Access-Control-Allow-Origin: *");
+header("Content-Type: application/json; charset=UTF-8");
+header("Access-Control-Allow-Methods: POST");
+header("Access-Control-Max-Age: 3600");
+header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
+  
+// get database connection
+include_once '../config/database.php';
+  
+// instantiate product object
+include_once '../objects/identite.php';
+  
+$database = new Database();
+$db = $database->getConnection();
+  
+$identite = new Identite($db);
+  
+// get posted data
+$data = json_decode(file_get_contents("php://input"));
+
+// make sure data is not empty
+if(
+    !empty($data->login) &&
+    !empty($data->password) &&
+    !empty($data->pseudo) &&
+    !empty($data->age) &&
+    !empty($data->poids) &&
+    !empty($data->taille) &&
+    !empty($data->sexe) &&
+    !empty($data->niveaudusport)
+){
+    // set product property values
+    $identite->login = $data->login;
+    $identite->password = $data->password;
+    $identite->pseudo = $data->pseudo;
+    $identite->age = $data->age;
+    $identite->poids = $data->poids;
+    $identite->taille = $data->taille;
+    $identite->sexe = $data->sexe;
+    $identite->niveaudusport = $data->niveaudusport;
+    
+    if($identite->create()){
+    // set response code - 201 created
+        http_response_code(201);
+  
+        // tell the user
+        echo json_encode(array("message" => "L'identifiant est bien crée!"));
+    }
+  
+    // if unable to create the product, tell the user
+    else{
+  
+        // set response code - 503 service unavailable
+        http_response_code(503);
+  
+        // tell the user
+        echo json_encode(array("message" => "Impossible de créer."));
+    }
+}
+  
+// tell the user data is incomplete
+else{
+  
+    // set response code - 400 bad request
+    http_response_code(400);
+  
+    // tell the user
+    echo json_encode(array("message" => "Informations incomplètes"));
+}
+?>

API_LOGIN/identite/delete.php

+<?php
+// required headers
+header("Access-Control-Allow-Origin: *");
+header("Content-Type: application/json; charset=UTF-8");
+header("Access-Control-Allow-Methods: POST");
+header("Access-Control-Max-Age: 3600");
+header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
+  
+// include database and object file
+include_once '../config/database.php';
+include_once '../objects/identite.php';
+  
+// get database connection
+$database = new Database();
+$db = $database->getConnection();
+  
+// prepare product object
+$identite = new Identite($db);
+  
+// get product id
+$data = json_decode(file_get_contents("php://input"));
+  
+// set product id to be deleted
+$identite->id = $data->id;
+  
+// delete the product
+if($identite->delete()){
+  
+    // set response code - 200 ok
+    http_response_code(200);
+  
+    // tell the user
+    echo json_encode(array("message" => "L'identifiant a bien été supprimé."));
+}
+  
+// if unable to delete the product
+else{
+  
+    // set response code - 503 service unavailable
+    http_response_code(503);
+  
+    // tell the user
+    echo json_encode(array("message" => "Impossible de supprimer"));
+}
+?>
\ No newline at end of file

API_LOGIN/identite/login.php

+<?php
+    // required headers
+    header("Access-Control-Allow-Origin: *");
+    header("Content-Type: application/json; charset=UTF-8");
+    header("Access-Control-Allow-Methods: POST");
+    header("Access-Control-Max-Age: 3600");
+    header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
+    
+    // files needed to connect to database
+    include_once '../config/database.php';
+    include_once '../objects/identite.php';
+    
+    // get database connection
+    $database = new Database();
+    $db = $database->getConnection();
+    
+    // instantiate user object
+    $identite = new Identite($db);
+   
+    // get posted data
+    $data = json_decode(file_get_contents("php://input"));
+    
+    // set product property values
+    $identite->login = $data->login;
+    $login_exists = $identite->loginExists();
+    
+    // check if email exists and if password is correct
+    if($login_exists){
+        $password = $identite->password;
+        if($password==$data->password){
+            http_response_code(200);
+            echo json_encode(array( 
+                "message" => "Successful login."
+            ));
+         }
+         else{
+            http_response_code(401);
+            // tell the user login failed
+            echo json_encode(array("message" => "Mot de passe incorrect"));
+         }
+        }
+    
+    
+    // login failed
+    else{
+        // set response code
+        http_response_code(401);
+        // tell the user login failed
+        echo json_encode(array("message" => "login inexistant."));
+        
+    }
+    ?>

API_LOGIN/identite/read.php

+<?php
+// required headers
+header("Access-Control-Allow-Origin: *");
+header("Content-Type: application/json; charset=UTF-8");
+  
+// include database and object files
+include_once '../config/database.php';
+include_once '../objects/identite.php';
+  
+// instantiate database and identite object
+$database = new Database();
+$db = $database->getConnection();
+  
+// initialize object
+$identite = new Identite($db);
+  
+// read products will be here
+// query products
+$stmt = $identite->read();
+$num = $stmt->rowCount();
+  
+// check if more than 0 record found
+if($num>0){
+  
+    // products array
+    $identites_arr=array();
+    $identites_arr["records"]=array();
+  
+    // retrieve our table contents
+    // fetch() is faster than fetchAll()
+    // http://stackoverflow.com/questions/2770630/pdofetchall-vs-pdofetch-in-a-loop
+    while ($row = $stmt->fetch(PDO::FETCH_ASSOC)){
+        // extract row
+        // this will make $row['name'] to
+        // just $name only
+        extract($row);
+  
+        $identite_item=array(
+            "id" => $id,
+            "login" => $login,
+            "password" => $password,
+            "pseudo" => $pseudo,
+            "age" => $age,
+            "poids" => $poids,
+            "taille" => $taille,
+            "sexe" => $sexe,
+            "niveaudusport" =>$niveaudusport
+        );
+  
+        array_push($identites_arr["records"], $identite_item);
+    }
+  
+    // set response code - 200 OK
+    http_response_code(200);
+  
+    // show products data in json format
+    echo json_encode($identites_arr);
+}
+  
+// no products found will be here
+else{
+  
+    // set response code - 404 Not found
+    http_response_code(404);
+  
+    // tell the user no products found
+    echo json_encode(
+        array("message" => "No products found.")
+    );
+}

API_LOGIN/identite/read_one.php

+<?php
+// required headers
+header("Access-Control-Allow-Origin: *");
+header("Access-Control-Allow-Headers: access");
+header("Access-Control-Allow-Methods: GET");
+header("Access-Control-Allow-Credentials: true");
+header('Content-Type: application/json');
+  
+// include database and object files
+include_once '../config/database.php';
+include_once '../objects/identite.php';
+  
+// get database connection
+$database = new Database();
+$db = $database->getConnection();
+  
+// prepare product object
+$identite = new Identite($db);
+  
+// set ID property of record to read
+$identite->login = isset($_GET['login']) ? $_GET['login'] : die();
+  
+// read the details of product to be edited
+$identite->readOne();
+  
+if($identite->id!=null){
+    // create array
+    $identite_arr = array(
+        "id" =>  $identite->id,
+        "login" => $identite->login,
+        "password" => $identite->password,
+        "pseudo" => $identite->pseudo,
+        "age" => $identite->age,
+        "poids" => $identite->poids,
+        "taille" => $identite->taille,
+        "sexe" => $identite->sexe,
+        "niveaudusport" =>$identite->niveaudusport
+    );
+  
+    // set response code - 200 OK
+    http_response_code(200);
+  
+    // make it json format
+    echo json_encode($identite_arr);
+}
+  
+else{
+    // set response code - 404 Not found
+    http_response_code(404);
+  
+    // tell the user product does not exist
+    echo json_encode(array("message" => "Cet identifiant n'existe pas."));
+}
+?>

API_LOGIN/identite/search.php

+<?php
+// required headers
+header("Access-Control-Allow-Origin: *");
+header("Content-Type: application/json; charset=UTF-8");
+  
+// include database and object files
+include_once '../config/core.php';
+include_once '../config/database.php';
+include_once '../objects/identite.php';
+  
+// instantiate database and product object
+$database = new Database();
+$db = $database->getConnection();
+  
+// initialize object
+$identite = new Identite($db);
+  
+// get keywords
+$keywords=isset($_GET["s"]) ? $_GET["s"] : "";
+  
+// query products
+$stmt = $identite->search($keywords);
+$num = $stmt->rowCount();
+  
+// check if more than 0 record found
+if($num>0){
+  
+    // products array
+    $identites_arr=array();
+    $identites_arr["records"]=array();
+  
+    // retrieve our table contents
+    // fetch() is faster than fetchAll()
+    // http://stackoverflow.com/questions/2770630/pdofetchall-vs-pdofetch-in-a-loop
+    while ($row = $stmt->fetch(PDO::FETCH_ASSOC)){
+        // extract row
+        // this will make $row['name'] to
+        // just $name only
+        extract($row);
+  
+        $identite_item=array(
+            "id" => $id,
+            "login" => $login,
+            "password" => $password,
+            "pseudo" => $pseudo,
+            "age" => $age,
+            "poids" => $poids,
+            "taille" => $taille,
+            "sexe" => $sexe,
+            "niveaudusport" =>$niveaudusport
+        );
+  
+        array_push($identites_arr["records"], $identite_item);
+    }
+  
+    // set response code - 200 OK
+    http_response_code(200);
+  
+    // show products data
+    echo json_encode($identites_arr);
+}
+  
+else{
+    // set response code - 404 Not found
+    http_response_code(404);
+  
+    // tell the user no products found
+    echo json_encode(
+        array("message" => "L'identifiant est introuvable")
+    );
+}
+?>

API_LOGIN/identite/update.php

+<?php
+// required headers
+header("Access-Control-Allow-Origin: *");
+header("Content-Type: application/json; charset=UTF-8");
+header("Access-Control-Allow-Methods: POST");
+header("Access-Control-Max-Age: 3600");
+header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
+  
+// include database and object files
+include_once '../config/database.php';
+include_once '../objects/identite.php';
+  
+// get database connection
+$database = new Database();
+$db = $database->getConnection();
+  
+// prepare product object
+$identite = new Identite($db);
+  
+// get id of product to be edited
+$data = json_decode(file_get_contents("php://input"));
+  
+// set ID property of product to be edited
+$identite->id = $data->id;
+  
+// set product property values
+$identite->login = $data->login;
+$identite->password = $data->password;
+$identite->pseudo = $data->pseudo;
+$identite->age = $data->age;
+$identite->poids = $data->poids;
+$identite->taille = $data->taille;
+$identite->sexe = $data->sexe;
+$identite->niveaudusport = $data->niveaudusport;
+  
+// update the product
+if($identite->update()){
+  
+    // set response code - 200 ok
+    http_response_code(200);
+  
+    // tell the user
+    echo json_encode(array("message" => "Les modifications ont été prises en compte."));
+}
+  
+// if unable to update the product, tell the user
+else{
+  
+    // set response code - 503 service unavailable
+    http_response_code(503);
+  
+    // tell the user
+    echo json_encode(array("message" => "Impossible de mettre à jour"));
+}
+?>

API_LOGIN/identite/validate_tocken.php

+<?php
+// required headers
+header("Access-Control-Allow-Origin: *");
+header("Content-Type: application/json; charset=UTF-8");
+header("Access-Control-Allow-Methods: POST");
+header("Access-Control-Max-Age: 3600");
+header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
+ 
+// required to decode jwt
+include_once '../config/core.php';
+include_once '../libs/php-jwt-master/src/BeforeValidException.php';
+include_once '../libs/php-jwt-master/src/ExpiredException.php';
+include_once '../libs/php-jwt-master/src/SignatureInvalidException.php';
+include_once '../libs/php-jwt-master/src/JWT.php';
+use \Firebase\JWT\JWT;
+ 
+// get posted data
+$data = json_decode(file_get_contents("php://input"));
+ 
+// get jwt
+$jwt=isset($data->jwt) ? $data->jwt : "";
+ 
+// if jwt is not empty
+if($jwt){
+ 
+    // if decode succeed, show user details
+    try {
+        // decode jwt
+        $decoded = JWT::decode($jwt, $key, array('HS256'));
+ 
+        // set response code
+        http_response_code(200);
+ 
+        // show user details
+        echo json_encode(array(
+            "message" => "Access granted.",
+            "data" => $decoded->data
+        ));
+ 
+    }
+    // if decode fails, it means jwt is invalid
+catch (Exception $e){
+ 
+    // set response code
+    http_response_code(401);
+ 
+    // tell the user access denied  & show error message
+    echo json_encode(array(
+        "message" => "Access denied.",
+        "error" => $e->getMessage()
+    ));
+}
+}
+// show error message if jwt is empty
+else{
+ 
+    // set response code
+    http_response_code(401);
+ 
+    // tell the user access denied
+    echo json_encode(array("message" => "Access denied."));
+}
+?>
\ No newline at end of file

API_LOGIN/libs/php-jwt-master/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.

API_LOGIN/libs/php-jwt-master/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";
+?>
+```
+
+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).

API_LOGIN/libs/php-jwt-master/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"
+    }
+}

API_LOGIN/libs/php-jwt-master/src/BeforeValidException.php

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

API_LOGIN/libs/php-jwt-master/src/ExpiredException.php

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

API_LOGIN/libs/php-jwt-master/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);
+    }
+}

API_LOGIN/libs/php-jwt-master/src/JWT.php

+<?php
+
+namespace Firebase\JWT;
+
+use \DomainException;
+use \InvalidArgumentException;
+use \UnexpectedValueException;
+use \DateTime;
+
+/**
+ * JSON Web Token implementation, based on this spec:
+ * https://tools.ietf.org/html/rfc7519
+ *
+ * PHP version 5
+ *
+ * @category Authentication
+ * @package  Authentication_JWT
+ * @author   Neuman Vong <neuman@twilio.com>
+ * @author   Anant Narayanan <anant@php.net>
+ * @license  http://opensource.org/licenses/BSD-3-Clause 3-clause BSD
+ * @link     https://github.com/firebase/php-jwt
+ */
+class JWT
+{
+    const ASN1_INTEGER = 0x02;
+    const ASN1_SEQUENCE = 0x10;
+    const ASN1_BIT_STRING = 0x03;
+
+    /**
+     * When checking nbf, iat or expiration times,
+     * we want to provide some extra leeway time to
+     * account for clock skew.
+     */
+    public static $leeway = 0;
+
+    /**
+     * Allow the current timestamp to be specified.
+     * Useful for fixing a value within unit testing.
+     *
+     * Will default to PHP time() value if null.
+     */
+    public static $timestamp = null;
+
+    public static $supported_algs = array(
+        'ES256' => array('openssl', 'SHA256'),
+        'HS256' => array('hash_hmac', 'SHA256'),
+        'HS384' => array('hash_hmac', 'SHA384'),
+        'HS512' => array('hash_hmac', 'SHA512'),
+        'RS256' => array('openssl', 'SHA256'),
+        'RS384' => array('openssl', 'SHA384'),
+        'RS512' => array('openssl', 'SHA512'),
+    );
+
+    /**
+     * Decodes a JWT string into a PHP object.
+     *
+     * @param string                    $jwt            The JWT
+     * @param string|array|resource     $key            The key, or map of keys.
+     *                                                  If the algorithm used is asymmetric, this is the public key
+     * @param array                     $allowed_algs   List of supported verification algorithms
+     *                                                  Supported algorithms are 'ES256', 'HS256', 'HS384', 'HS512', 'RS256', 'RS384', and 'RS512'
+     *
+     * @return object The JWT's payload as a PHP object
+     *
+     * @throws UnexpectedValueException     Provided JWT was invalid
+     * @throws SignatureInvalidException    Provided JWT was invalid because the signature verification failed
+     * @throws BeforeValidException         Provided JWT is trying to be used before it's eligible as defined by 'nbf'
+     * @throws BeforeValidException         Provided JWT is trying to be used before it's been created as defined by 'iat'
+     * @throws ExpiredException             Provided JWT has since expired, as defined by the 'exp' claim
+     *
+     * @uses jsonDecode
+     * @uses urlsafeB64Decode
+     */
+    public static function decode($jwt, $key, array $allowed_algs = array())
+    {
+        $timestamp = \is_null(static::$timestamp) ? \time() : static::$timestamp;
+
+        if (empty($key)) {
+            throw new InvalidArgumentException('Key may not be empty');
+        }
+        $tks = \explode('.', $jwt);
+        if (\count($tks) != 3) {
+            throw new UnexpectedValueException('Wrong number of segments');
+        }
+        list($headb64, $bodyb64, $cryptob64) = $tks;
+        if (null === ($header = static::jsonDecode(static::urlsafeB64Decode($headb64)))) {
+            throw new UnexpectedValueException('Invalid header encoding');
+        }
+        if (null === $payload = static::jsonDecode(static::urlsafeB64Decode($bodyb64))) {
+            throw new UnexpectedValueException('Invalid claims encoding');
+        }
+        if (false === ($sig = static::urlsafeB64Decode($cryptob64))) {
+            throw new UnexpectedValueException('Invalid signature encoding');
+        }
+        if (empty($header->alg)) {
+            throw new UnexpectedValueException('Empty algorithm');
+        }
+        if (empty(static::$supported_algs[$header->alg])) {
+            throw new UnexpectedValueException('Algorithm not supported');
+        }
+        if (!\in_array($header->alg, $allowed_algs)) {
+            throw new UnexpectedValueException('Algorithm not allowed');
+        }
+        if ($header->alg === 'ES256') {
+            // OpenSSL expects an ASN.1 DER sequence for ES256 signatures
+            $sig = self::signatureToDER($sig);
+        }
+
+        if (\is_array($key) || $key instanceof \ArrayAccess) {
+            if (isset($header->kid)) {
+                if (!isset($key[$header->kid])) {
+                    throw new UnexpectedValueException('"kid" invalid, unable to lookup correct key');
+                }
+                $key = $key[$header->kid];
+            } else {
+                throw new UnexpectedValueException('"kid" empty, unable to lookup correct key');
+            }
+        }
+
+        // Check the signature
+        if (!static::verify("$headb64.$bodyb64", $sig, $key, $header->alg)) {
+            throw new SignatureInvalidException('Signature verification failed');
+        }
+
+        // Check the nbf if it is defined. This is the time that the
+        // token can actually be used. If it's not yet that time, abort.
+        if (isset($payload->nbf) && $payload->nbf > ($timestamp + static::$leeway)) {
+            throw new BeforeValidException(
+                'Cannot handle token prior to ' . \date(DateTime::ISO8601, $payload->nbf)
+            );
+        }
+
+        // Check that this token has been created before 'now'. This prevents
+        // using tokens that have been created for later use (and haven't
+        // correctly used the nbf claim).
+        if (isset($payload->iat) && $payload->iat > ($timestamp + static::$leeway)) {
+            throw new BeforeValidException(
+                'Cannot handle token prior to ' . \date(DateTime::ISO8601, $payload->iat)
+            );
+        }
+
+        // Check if this token has expired.
+        if (isset($payload->exp) && ($timestamp - static::$leeway) >= $payload->exp) {
+            throw new ExpiredException('Expired token');
+        }
+
+        return $payload;
+    }
+
+    /**
+     * Converts and signs a PHP object or array into a JWT string.
+     *
+     * @param object|array  $payload    PHP object or array
+     * @param string        $key        The secret key.
+     *                                  If the algorithm used is asymmetric, this is the private key
+     * @param string        $alg        The signing algorithm.
+     *                                  Supported algorithms are 'ES256', 'HS256', 'HS384', 'HS512', 'RS256', 'RS384', and 'RS512'
+     * @param mixed         $keyId
+     * @param array         $head       An array with header elements to attach
+     *
+     * @return string A signed JWT
+     *
+     * @uses jsonEncode
+     * @uses urlsafeB64Encode
+     */
+    public static function encode($payload, $key, $alg = 'HS256', $keyId = null, $head = null)
+    {
+        $header = array('typ' => 'JWT', 'alg' => $alg);
+        if ($keyId !== null) {
+            $header['kid'] = $keyId;
+        }
+        if (isset($head) && \is_array($head)) {
+            $header = \array_merge($head, $header);
+        }
+        $segments = array();
+        $segments[] = static::urlsafeB64Encode(static::jsonEncode($header));
+        $segments[] = static::urlsafeB64Encode(static::jsonEncode($payload));
+        $signing_input = \implode('.', $segments);
+
+        $signature = static::sign($signing_input, $key, $alg);
+        $segments[] = static::urlsafeB64Encode($signature);
+
+        return \implode('.', $segments);
+    }
+
+    /**
+     * Sign a string with a given key and algorithm.
+     *
+     * @param string            $msg    The message to sign
+     * @param string|resource   $key    The secret key
+     * @param string            $alg    The signing algorithm.
+     *                                  Supported algorithms are 'ES256', 'HS256', 'HS384', 'HS512', 'RS256', 'RS384', and 'RS512'
+     *
+     * @return string An encrypted message
+     *
+     * @throws DomainException Unsupported algorithm was specified
+     */
+    public static function sign($msg, $key, $alg = 'HS256')
+    {
+        if (empty(static::$supported_algs[$alg])) {
+            throw new DomainException('Algorithm not supported');
+        }
+        list($function, $algorithm) = static::$supported_algs[$alg];
+        switch ($function) {
+            case 'hash_hmac':
+                return \hash_hmac($algorithm, $msg, $key, true);
+            case 'openssl':
+                $signature = '';
+                $success = \openssl_sign($msg, $signature, $key, $algorithm);
+                if (!$success) {
+                    throw new DomainException("OpenSSL unable to sign data");
+                } else {
+                    if ($alg === 'ES256') {
+                        $signature = self::signatureFromDER($signature, 256);
+                    }
+                    return $signature;
+                }
+        }
+    }
+
+    /**
+     * Verify a signature with the message, key and method. Not all methods
+     * are symmetric, so we must have a separate verify and sign method.
+     *
+     * @param string            $msg        The original message (header and body)
+     * @param string            $signature  The original signature
+     * @param string|resource   $key        For HS*, a string key works. for RS*, must be a resource of an openssl public key
+     * @param string            $alg        The algorithm
+     *
+     * @return bool
+     *
+     * @throws DomainException Invalid Algorithm or OpenSSL failure
+     */
+    private static function verify($msg, $signature, $key, $alg)
+    {
+        if (empty(static::$supported_algs[$alg])) {
+            throw new DomainException('Algorithm not supported');
+        }
+
+        list($function, $algorithm) = static::$supported_algs[$alg];
+        switch ($function) {
+            case 'openssl':
+                $success = \openssl_verify($msg, $signature, $key, $algorithm);
+                if ($success === 1) {
+                    return true;
+                } elseif ($success === 0) {
+                    return false;
+                }
+                // returns 1 on success, 0 on failure, -1 on error.
+                throw new DomainException(
+                    'OpenSSL error: ' . \openssl_error_string()
+                );
+            case 'hash_hmac':
+            default:
+                $hash = \hash_hmac($algorithm, $msg, $key, true);
+                if (\function_exists('hash_equals')) {
+                    return \hash_equals($signature, $hash);
+                }
+                $len = \min(static::safeStrlen($signature), static::safeStrlen($hash));
+
+                $status = 0;
+                for ($i = 0; $i < $len; $i++) {
+                    $status |= (\ord($signature[$i]) ^ \ord($hash[$i]));
+                }
+                $status |= (static::safeStrlen($signature) ^ static::safeStrlen($hash));
+
+                return ($status === 0);
+        }
+    }
+
+    /**
+     * Decode a JSON string into a PHP object.
+     *
+     * @param string $input JSON string
+     *
+     * @return object Object representation of JSON string
+     *
+     * @throws DomainException Provided string was invalid JSON
+     */
+    public static function jsonDecode($input)
+    {
+        if (\version_compare(PHP_VERSION, '5.4.0', '>=') && !(\defined('JSON_C_VERSION') && PHP_INT_SIZE > 4)) {
+            /** In PHP >=5.4.0, json_decode() accepts an options parameter, that allows you
+             * to specify that large ints (like Steam Transaction IDs) should be treated as
+             * strings, rather than the PHP default behaviour of converting them to floats.
+             */
+            $obj = \json_decode($input, false, 512, JSON_BIGINT_AS_STRING);
+        } else {
+            /** Not all servers will support that, however, so for older versions we must
+             * manually detect large ints in the JSON string and quote them (thus converting
+             *them to strings) before decoding, hence the preg_replace() call.
+             */
+            $max_int_length = \strlen((string) PHP_INT_MAX) - 1;
+            $json_without_bigints = \preg_replace('/:\s*(-?\d{'.$max_int_length.',})/', ': "$1"', $input);
+            $obj = \json_decode($json_without_bigints);
+        }
+
+        if ($errno = \json_last_error()) {
+            static::handleJsonError($errno);
+        } elseif ($obj === null && $input !== 'null') {
+            throw new DomainException('Null result with non-null input');
+        }
+        return $obj;
+    }
+
+    /**
+     * Encode a PHP object into a JSON string.
+     *
+     * @param object|array $input A PHP object or array
+     *
+     * @return string JSON representation of the PHP object or array
+     *
+     * @throws DomainException Provided object could not be encoded to valid JSON
+     */
+    public static function jsonEncode($input)
+    {
+        $json = \json_encode($input);
+        if ($errno = \json_last_error()) {
+            static::handleJsonError($errno);
+        } elseif ($json === 'null' && $input !== null) {
+            throw new DomainException('Null result with non-null input');
+        }
+        return $json;
+    }
+
+    /**
+     * Decode a string with URL-safe Base64.
+     *
+     * @param string $input A Base64 encoded string
+     *
+     * @return string A decoded string
+     */
+    public static function urlsafeB64Decode($input)
+    {
+        $remainder = \strlen($input) % 4;
+        if ($remainder) {
+            $padlen = 4 - $remainder;
+            $input .= \str_repeat('=', $padlen);
+        }
+        return \base64_decode(\strtr($input, '-_', '+/'));
+    }
+
+    /**
+     * Encode a string with URL-safe Base64.
+     *
+     * @param string $input The string you want encoded
+     *
+     * @return string The base64 encode of what you passed in
+     */
+    public static function urlsafeB64Encode($input)
+    {
+        return \str_replace('=', '', \strtr(\base64_encode($input), '+/', '-_'));
+    }
+
+    /**
+     * Helper method to create a JSON error.
+     *
+     * @param int $errno An error number from json_last_error()
+     *
+     * @return void
+     */
+    private static function handleJsonError($errno)
+    {
+        $messages = array(
+            JSON_ERROR_DEPTH => 'Maximum stack depth exceeded',
+            JSON_ERROR_STATE_MISMATCH => 'Invalid or malformed JSON',
+            JSON_ERROR_CTRL_CHAR => 'Unexpected control character found',
+            JSON_ERROR_SYNTAX => 'Syntax error, malformed JSON',
+            JSON_ERROR_UTF8 => 'Malformed UTF-8 characters' //PHP >= 5.3.3
+        );
+        throw new DomainException(
+            isset($messages[$errno])
+            ? $messages[$errno]
+            : 'Unknown JSON error: ' . $errno
+        );
+    }
+
+    /**
+     * Get the number of bytes in cryptographic strings.
+     *
+     * @param string $str
+     *
+     * @return int
+     */
+    private static function safeStrlen($str)
+    {
+        if (\function_exists('mb_strlen')) {
+            return \mb_strlen($str, '8bit');
+        }
+        return \strlen($str);
+    }
+
+    /**
+     * Convert an ECDSA signature to an ASN.1 DER sequence
+     *
+     * @param   string $sig The ECDSA signature to convert
+     * @return  string The encoded DER object
+     */
+    private static function signatureToDER($sig)
+    {
+        // Separate the signature into r-value and s-value
+        list($r, $s) = \str_split($sig, (int) (\strlen($sig) / 2));
+
+        // Trim leading zeros
+        $r = \ltrim($r, "\x00");
+        $s = \ltrim($s, "\x00");
+
+        // Convert r-value and s-value from unsigned big-endian integers to
+        // signed two's complement
+        if (\ord($r[0]) > 0x7f) {
+            $r = "\x00" . $r;
+        }
+        if (\ord($s[0]) > 0x7f) {
+            $s = "\x00" . $s;
+        }
+
+        return self::encodeDER(
+            self::ASN1_SEQUENCE,
+            self::encodeDER(self::ASN1_INTEGER, $r) .
+            self::encodeDER(self::ASN1_INTEGER, $s)
+        );
+    }
+
+    /**
+     * Encodes a value into a DER object.
+     *
+     * @param   int     $type DER tag
+     * @param   string  $value the value to encode
+     * @return  string  the encoded object
+     */
+    private static function encodeDER($type, $value)
+    {
+        $tag_header = 0;
+        if ($type === self::ASN1_SEQUENCE) {
+            $tag_header |= 0x20;
+        }
+
+        // Type
+        $der = \chr($tag_header | $type);
+
+        // Length
+        $der .= \chr(\strlen($value));
+
+        return $der . $value;
+    }
+
+    /**
+     * Encodes signature from a DER object.
+     *
+     * @param   string  $der binary signature in DER format
+     * @param   int     $keySize the number of bits in the key
+     * @return  string  the signature
+     */
+    private static function signatureFromDER($der, $keySize)
+    {
+        // OpenSSL returns the ECDSA signatures as a binary ASN.1 DER SEQUENCE
+        list($offset, $_) = self::readDER($der);
+        list($offset, $r) = self::readDER($der, $offset);
+        list($offset, $s) = self::readDER($der, $offset);
+
+        // Convert r-value and s-value from signed two's compliment to unsigned
+        // big-endian integers
+        $r = \ltrim($r, "\x00");
+        $s = \ltrim($s, "\x00");
+
+        // Pad out r and s so that they are $keySize bits long
+        $r = \str_pad($r, $keySize / 8, "\x00", STR_PAD_LEFT);
+        $s = \str_pad($s, $keySize / 8, "\x00", STR_PAD_LEFT);
+
+        return $r . $s;
+    }
+
+    /**
+     * Reads binary DER-encoded data and decodes into a single object
+     *
+     * @param string $der the binary data in DER format
+     * @param int $offset the offset of the data stream containing the object
+     * to decode
+     * @return array [$offset, $data] the new offset and the decoded object
+     */
+    private static function readDER($der, $offset = 0)
+    {
+        $pos = $offset;
+        $size = \strlen($der);
+        $constructed = (\ord($der[$pos]) >> 5) & 0x01;
+        $type = \ord($der[$pos++]) & 0x1f;
+
+        // Length
+        $len = \ord($der[$pos++]);
+        if ($len & 0x80) {
+            $n = $len & 0x1f;
+            $len = 0;
+            while ($n-- && $pos < $size) {
+                $len = ($len << 8) | \ord($der[$pos++]);
+            }
+        }
+
+        // Value
+        if ($type == self::ASN1_BIT_STRING) {
+            $pos++; // Skip the first contents octet (padding indicator)
+            $data = \substr($der, $pos, $len - 1);
+            $pos += $len - 1;
+        } elseif (!$constructed) {
+            $data = \substr($der, $pos, $len);
+            $pos += $len;
+        } else {
+            $data = null;
+        }
+
+        return array($pos, $data);
+    }
+}

API_LOGIN/libs/php-jwt-master/src/SignatureInvalidException.php

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

API_LOGIN/objects/identite.php

+<?php
+class Identite{
+     // database connection and table name
+     private $conn;
+     private $table_name = "identites";
+   
+     // object properties
+     public $id;
+     public $login;
+     public $password;
+     public $pseudo;
+     public $age;
+     public $poids;
+     public $taille;
+     public $sexe;
+     public $niveaudusport;
+   
+     // constructor with $db as database connection
+     public function __construct($db){
+         $this->conn = $db;
+     }
+
+     // read identites
+    function read(){
+  
+        // select all query
+        $query = "SELECT * FROM $this->table_name";
+    
+        // prepare query statement
+        $stmt = $this->conn->prepare($query);
+    
+        // execute query
+        $stmt->execute();
+    
+        return $stmt;
+    }
+    // check if given login exist in the database
+    function loginExists(){
+        
+        // query to check if email exists
+        $query = "SELECT *
+        FROM $this->table_name
+        WHERE login = ?
+        LIMIT 0,1";
+        
+        // prepare the query
+        $stmt = $this->conn->prepare( $query );
+        
+        // sanitize
+        $this->login=htmlspecialchars(strip_tags($this->login));
+        
+        // bind given email value
+        $stmt->bindParam(1, $this->login);
+        // execute the query
+        $stmt->execute();
+        
+        // get number of rows
+        $num = $stmt->rowCount();
+        
+        // if email exists, assign values to object properties for easy access and use for php sessions
+        if($num>0){
+            
+            // get record details / values
+            $row = $stmt->fetch(PDO::FETCH_ASSOC);
+            
+            // assign values to object properties
+            $this->id = $row['id'];
+            $this->password = $row['password'];
+            $this->pseudo = $row['pseudo'];
+            $this->age = $row['age'];
+            $this->poids = $row['poids'];
+            $this->taille = $row['taille'];
+            $this->sexe = $row['sexe'];
+            $this->niveaudusport = $row['niveaudusport'];
+            
+            // return true because email exists in the database
+            return true;
+        }
+        
+        // return false if email does not exist in the database
+        return false;
+    }
+    
+   
+    // create identite
+    function create(){
+        
+        // query to insert record
+        $query = "INSERT INTO
+                    ".$this->table_name."
+                SET
+                    login=:login, password=:password, pseudo=:pseudo, age=:age, poids=:poids, taille=:taille, sexe=:sexe, niveaudusport=:niveaudusport";
+        
+        // prepare query
+        $stmt = $this->conn->prepare($query);
+        
+        // sanitize
+        $this->login=htmlspecialchars(strip_tags($this->login));
+        $this->password=htmlspecialchars(strip_tags($this->password));
+        $this->pseudo=htmlspecialchars(strip_tags($this->pseudo));
+        $this->age=htmlspecialchars(strip_tags($this->age));
+        $this->poids=htmlspecialchars(strip_tags($this->poids));
+        $this->taille=htmlspecialchars(strip_tags($this->taille));
+        $this->sexe=htmlspecialchars(strip_tags($this->sexe));
+        $this->niveaudusport=htmlspecialchars(strip_tags($this->niveaudusport));
+        
+        // bind values
+        $stmt->bindParam(":login", $this->login);
+        $stmt->bindParam(":password", $this->password);
+        $stmt->bindParam(":pseudo", $this->pseudo);
+        $stmt->bindParam(":age", $this->age);
+        $stmt->bindParam(":poids", $this->poids);
+        $stmt->bindParam(":taille", $this->taille);
+        $stmt->bindParam(":sexe", $this->sexe);
+        $stmt->bindParam(":niveaudusport", $this->niveaudusport);
+        
+        
+        // execute query
+        if($stmt->execute()){
+            return true;
+        }
+        
+        return false;
+        
+    }
+    // used when filling up the update product form
+    function readOne(){
+        
+        // query to read single record
+        $query = "SELECT * FROM $this->table_name WHERE login = ?";
+        
+        // prepare query statement
+        $stmt = $this->conn->prepare( $query );
+        
+        // bind id of product to be updated
+        $stmt->bindParam(1, $this->login);
+        
+        // execute query
+        $stmt->execute();
+        
+        // get retrieved row
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+        
+        // set values to object properties
+        $this->id = $row['id'];
+        $this->password = $row['password'];
+        $this->pseudo = $row['pseudo'];
+        $this->age = $row['age'];
+        $this->poids = $row['poids'];
+        $this->taille = $row['taille'];
+        $this->sexe = $row['sexe'];
+        $this->niveaudusport = $row['niveaudusport'];
+        //$this->besoin_en_calories = $row['besoin_en_calories'];
+    }
+    // update the product
+    function update(){
+        
+        // update query
+        $query = "UPDATE
+        " . $this->table_name . "
+        SET
+        login=:login,
+        password=:password,
+        pseudo=:pseudo,
+        age=:age,
+        poids=:poids,
+        taille=:taille,
+        sexe=:sexe,
+        niveaudusport=:niveaudusport
+        //besoin_en_calories =:besoin_en_calories
+        WHERE
+        id=:id";
+        
+        // prepare query statement
+        $stmt = $this->conn->prepare($query);
+        
+        // sanitize
+        $this->id=htmlspecialchars(strip_tags($this->id));
+        $this->login=htmlspecialchars(strip_tags($this->login));
+        $this->password=htmlspecialchars(strip_tags($this->password));
+        $this->pseudo=htmlspecialchars(strip_tags($this->pseudo));
+        $this->age=htmlspecialchars(strip_tags($this->age));
+        $this->poids=htmlspecialchars(strip_tags($this->poids));
+        $this->taille=htmlspecialchars(strip_tags($this->taille));
+        $this->sexe=htmlspecialchars(strip_tags($this->sexe));
+        $this->niveaudusport=htmlspecialchars(strip_tags($this->niveaudusport));
+        //$this->besoin_en_calories=htmlspecialchars(strip_tags($this->besoin_en_calories));
+        
+        
+        // bind new values
+        $stmt->bindParam(':id', $this->id);
+        $stmt->bindParam(':login', $this->login);
+        $stmt->bindParam(':password', $this->password);
+        $stmt->bindParam(':pseudo', $this->pseudo);
+        $stmt->bindParam(':age', $this->age);
+        $stmt->bindParam(':poids', $this->poids);
+        $stmt->bindParam(':taille', $this->taille);
+        $stmt->bindParam(':sexe', $this->sexe);
+        $stmt->bindParam(':niveaudusport', $this->niveaudusport);
+       // $stmt->bindParam(':besoin_en_calories', $this->besoin_en_calories);
+        
+        
+        // execute the query
+        if($stmt->execute()){
+            return true;
+        }
+        return false;
+    }
+    
+    // delete the product
+    function delete(){
+        
+        // delete query
+        $query = "DELETE FROM " . $this->table_name . " WHERE id = ?";
+        
+        // prepare query
+        $stmt = $this->conn->prepare($query);
+        
+        // sanitize
+        $this->id=htmlspecialchars(strip_tags($this->id));
+        
+        // bind id of record to delete
+        $stmt->bindParam(1, $this->id);
+        
+        // execute query
+        if($stmt->execute()){
+            return true;
+        }
+        
+        return false;
+    }
+    // search products
+    function search($keywords){
+        
+        // select all query
+        $query = "SELECT * FROM
+        " . $this->table_name . "
+        WHERE
+        login LIKE ? OR pseudo LIKE ? ";
+        
+        // prepare query statement
+        $stmt = $this->conn->prepare($query);
+        
+        // sanitize
+        $keywords=htmlspecialchars(strip_tags($keywords));
+        $keywords = "%{$keywords}%";
+        
+        // bind
+        $stmt->bindParam(1, $keywords);
+        $stmt->bindParam(2, $keywords);
+        
+        // execute query
+        $stmt->execute();
+        
+        return $stmt;
+    }
+
+     
+ }
+ ?>
+

api/ajouter_identifiant.php

-<?php
-require_once("template_l.php");
-if(isset($_POST["login"]) && isset($_POST["password"]) && isset($_POST["pseudo"])&& isset($_POST["âge"])&& isset($_POST["poids"])&& isset($_POST["taille"])&& isset($_POST["sexe"])&& isset($_POST["niveau_du_sport"])){
-    $requete="INSERT INTO `identites` (`id`,`login`, `password`, `pseudo`, `âge`, `poids`, `taille`, `sexe`, `niveau_du_sport`) VALUES (NULL,'" .$_POST['login'] . "', '" . $_POST['password'] . "','" . $_POST['âge'] . "', '" .$_POST['poids'] . "', '" .$_POST['taille'] . "', '" . $_POST['sexe'] . "','" .$_POST['niveau_du_sport'] . "',)";
-    $mysqli->query($requete);
-    $msg="L'identifiant a bien été ajouté";
-} else{
-    $msg="Il manque des informations";
-}

api/database.php

-<?php
-    try{
-        DEFINE('DB_USERNAME','liang.wu');
-        DEFINE('DB_PASSWORD','oMmyE2aw');
-        DEFINE('DB_HOST','127.0.0.1');
-        DEFINE('DB_DATABASE','liang_wu');
-        
-        $mysqli = new mysqli(DB_HOST, DB_USERNAME, DB_PASSWORD, DB_DATABASE);
-        $retour["success"]=true;
-    } catch(Exception $e){
-        $retour["success"]=false;
-    };
-    ?>

api/template_l.php

-<?php
-header('Content-Type: application/json'); //pour que le navigateur l'affiche dans le format json
-include('database.php');
-
-function reponse_json($data){
-
-    echo json_encode($data);
-
-}

connected.php

-
-<?php
-require_once('template_header.php');
-?>
-
-<script type="text/javascript">
-    $(document).ready( function() {
-            $.getJSON('https://eden.imt-lille-douai.fr/~liang.wu/API_LOGIN/identite/read.php',
-            function(json){
-                        // console.log(json);
-                        var table = <?php echo json_encode($users); ?>;
-                        table.php('');
-
-                        // cf. https://api.jquery.com/jQuery.getJSON/
-                        $.each( json, function( key, val ) {
-                            table.append(val['login']+'=>'+val['password']+',');
-                        });
-                    }
-            )
-        });
-</script>
-
-<?php
-
-$users = array();
-
-$login = "anonymous";
-$errorText = "";
-$successfullyLogged = false;
-
-if(isset($_GET['login']) && isset($_GET['password'])){
-    $tryLogin=$_GET['login'];
-    $tryPwd=$_GET['password'];
-
-        //si le mdp est correct
-        if(array_key_exists($tryLogin,$users) && $users[$tryLogin]==$tryPwd){
-            $successfullyLogged = true;
-            $login = $tryLogin;
-        } else
-        $errorText = "Erreur de login/password1";
-
-} else
-    $errorText = "Merci d'utiliser le formulaire de login";
-        
-if(!$successfullyLogged) {
-    echo $errorText;
-} else {
-        session_start();
-        $_SESSION['login']=$login;
-        $_SESSION['password']=$password;
-        header('Location: home.php');
-
-
-}
-
-?>

index.php

-<!doctype html>
-<html>
-<head>
-</head>
-<body>
+<?php
+require_once('template_header.php');
+?>
 
 <main role="main" class="container starter-template">
  
@@ -56,7 +54,6 @@ $(document).ready(function() {
     $(document).on('submit', '#login_form', function(){
         // get form data
         var form_data=JSON.stringify($(this).serializeObject());
-        // console.log(form_data);
 
         // submit form data to api
         $.ajax({
@@ -65,7 +62,10 @@ $(document).ready(function() {
             contentType : 'application/json',
             data : form_data,
             success : function(result){
+                var ac_log=JSON.parse(form_data);
+                document.cookie ="IdentifiantActuel="+ac_log.login;
                 window.location="https://eden.imt-lille-douai.fr/~liang.wu/projet_idaw/home.php";
+                
             },
             error: function(xhr, resp, text){
             // on error, tell the user login has failed & empty the input boxes
@@ -77,5 +77,7 @@ $(document).ready(function() {
 });
 </script>
 
-</body>
-</html>
\ No newline at end of file
+            
+<?php
+    require_once('template_footer.php');
+?>
\ No newline at end of file

profil_affichage.php

-<?php
- session_start();
- ?>
+<head>
+    <meta charset="utf-8"/>
+    <script src="https://code.jquery.com/jquery-3.4.1.js"   integrity="sha256-WpOohJOqMqqyKL9FccASB9O0KwACQJpFTUBLTYOVvVU="   crossorigin="anonymous"></script>
+    <link rel="stylesheet" type="text/css" href="https://cdn.datatables.net/1.10.20/css/jquery.dataTables.css">
 
-</script>
+    <script type="text/javascript" charset="utf8" src="https://cdn.datatables.net/1.10.20/js/jquery.dataTables.js"></script>
+    <script type="text/javascript">
+      $(document).ready(function() {
+          $('#table_info').DataTable();
+      } );
+    </script>
     <script type="text/javascript">
         $(document).ready( function() {
-                $.getJSON('https://eden.imt-lille-douai.fr/~liang.wu/API_LOGIN/identite/read_one.php?login=$_SESSION['login']',
-                    function(json){
-                        // console.log(json);
+               // $ident= getCookie("IdentifiantActuel");
+                $.getJSON('https://eden.imt-lille-douai.fr/~liang.wu/API_LOGIN/identite/read.php',
+                    function(data){
                         table = $('#tbody_info');
                         table.html('');
 
-                        // cf. https://api.jquery.com/jQuery.getJSON/
-                        $.each( json, function( key, val ) {
-                            table.append('<tr><td>'+val['id']+'</td><td>'+val['login']+'</td><td>'+val['password']+'</td><td>'+val['pseudo']+'</td><td>'+val['âge']+'</td><td>'+val['poids']+'</td><td>'+val['taille']+'</td><td>'+val['sexe']+'</td><td>'+val['niveau_du_sport']+'</td><td><button type='submit' class='update'>Modifier</button></td><td><button type='submit' class='delete'>Supprimer</button></td></tr>');
+                        $.each( data.records, function( key, val ) {
+                            table.append('<tr><td>'+val.id+'</td><td>'+val.login+'</td><td>'+val.password+'</td><td>'+val.pseudo+'</td><td>'+val.age+'</td><td>'+val.poids+'</td><td>'+val.taille+'</td><td>'+val.sexe+'</td><td>'+val.niveaudusport+'</td></tr>');
                         });
+
                     }
                 );
     </script>
+</head>
 
-
-<head>
+<section id="profil_contenu" style="display : flex; flex-direction : row; ">
 
 <div style="margin-right:100px">
-    <table id="table_info" class="dataTable" style="color : #212529; ">
 
-        <thead>
+<table id="table_info" class="dataTable" style="color : #212529; "> 
+    <thead>
             <tr>
                 <th>id</th>
                 <th>login</th>
                 <th>password</th>
                 <th>pseudo</th>
                 <th>âge</th>
-                <th>poids</th>
-                <th>taille</th>
+                <th>poids(kg)</th>
+                <th>taille(cm)</th>
                 <th>sexe</th>
                 <th>niveau_du_sport</th>
-                <th>modifier</th>
-                <th>supprimer</th>
+                <th>Action</th>
             </tr>
-        </thead>
-        <tbody id="tbody_info"><tbody>
-
-        </table>
+    </thead>
+    <tbody id="tbody_info"><tbody>
+</table>
 </div>
-
-</head>
\ No newline at end of file
+</section>
\ No newline at end of file

signup.php

-<head>
-<script
-    src="https://code.jquery.com/jquery-3.4.1.min.js"
-    integrity="sha256-CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo="
-    crossorigin="anonymous"></script>
+<?php
+require_once('template_header.php');
+?>
 
+<section>
+<div id="response"></div>
+<div><a href="index.php">Se connecter</a></div>
+</section>
 
+<section>
 <!-- 'create identite' html form -->
-<form id="form_signup" action="api/ajouter_identifiant.php" method="POST" >
+<form id="form_signup" action="#" method="POST" >
         <div>
             <label>Login</label>
             <input type='text' id='login' name='login' class="form-control" required />
@@ -24,7 +27,7 @@
 
         <div>
             <label>Âge</label>
-            <input type='text' id='âge' name='âge' class="form-control" required />
+            <input type='text' id='age' name='age' class="form-control" required />
         </div>
 
         <div>
@@ -37,31 +40,23 @@
             <input type='text' id='taille' name='taille' class="form-control" required/>
         </div>
        
-        <div>
+        <div class="form-group">
             <label>Sexe</label>
-            <div>
-                <label> Homme
-                <input type="radio" name="sexe" id="M">
-                </label><br>
-                <label> Femme 
-                <input type="radio" name="sexe" id="F">
-                </label>
-            </div>
+            <select class="form-control" id="sexe" name="sexe">
+            <option selected>Choisir...</option>
+            <option>Femme</option>
+            <option>Homme</option>
+        </select>
         </div>
 
-        <div>
-            <label>Niveau de pratique sportive</label>
-            <div>
-                <label> Bas
-                <input type="radio" name="niveau_du_sport" id="bas">
-                </label><br>
-                <label> Moyen 
-                <input type="radio" name="niveau_du_sport" id="moyen">
-                </label><br>
-                <label> Elevé
-                <input type="radio" name="niveau_du_sport" id="eleve">
-                </label>
-            </div>
+        <div class="form-group">
+            <label>Niveau de sport</label>
+            <select class="form-control" id="niveaudusport" name="niveaudusport">
+            <option selected>Choisir...</option>
+            <option>Bas</option>
+            <option>Moyen</option>
+            <option>Elevé</option>
+        </select>
         </div>
 
         <!-- button to submit form -->
@@ -72,4 +67,48 @@
 </form>
 
 
-</head>
+
+<script
+    src="https://code.jquery.com/jquery-3.4.1.min.js"
+    integrity="sha256-CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo="
+    crossorigin="anonymous"></script>
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-serialize-object/2.5.0/jquery.serialize-object.min.js" ></script>
+
+<script type="text/javascript">
+
+$(document).ready( function($) {
+    // will run if create identite form was submitted
+    $(document).on('submit', '#form_signup', function(){
+        // get form data
+        var form_data=JSON.stringify($(this).serializeObject());
+        // console.log(form_data);
+
+        // submit form data to api
+        $.ajax({
+            url: "https://eden.imt-lille-douai.fr/~liang.wu/API_LOGIN/identite/create.php",
+            type : "POST",
+            contentType : 'application/json',
+            data : form_data,
+            success : function(result){
+            $('#response').html("<div class='alert alert-danger'>success.</div>");
+                
+            },
+            error: function(xhr, resp, text){
+            // on error, tell the user login has failed & empty the input boxes
+            $('#response').html("<div class='alert alert-danger'>failed</div>");
+            login_form.find('input').val('');
+            }
+
+
+
+        });
+    });
+});
+</script>
+
+</section>
+
+<?php
+    require_once('template_footer.php');
+?>