snakeia-server 1.2.7 → 2.0.0

package/server.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Eliastik (eliastiksofts.com)
+ * Copyright (C) 2020-2026 Eliastik (eliastiksofts.com)
  *
  * This file is part of "SnakeIA Server".
  *
@@ -16,25 +16,32 @@
  * You should have received a copy of the GNU General Public License
  * along with "SnakeIA Server".  If not, see <http://www.gnu.org/licenses/>.
  */
-const express        = require("express");
-const app            = express();
-const fs             = require("fs");
-const httpLib        = require("http");
-const httpsLib       = require("https");
-let server           = null;
-let io               = null;
-const entities       = require("html-entities");
-const ejs            = require("ejs");
-const jwt            = require("jsonwebtoken");
-const fetch          = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
-const cookieParser   = require("cookie-parser");
-const ioCookieParser = require("socket.io-cookie-parser");
-const i18n           = require("i18n");
-const rateLimit      = require("express-rate-limit");
-const winston        = require("winston");
-const { doubleCsrf } = require("csrf-csrf");
-const bodyParser     = require("body-parser");
-const node_config    = require("config");
+const express          = require("express");
+const app              = express();
+const fs               = require("fs");
+const httpLib          = require("http");
+const httpsLib         = require("https");
+let server             = null;
+let io                 = null;
+const entities         = require("html-entities");
+const ejs              = require("ejs");
+const { SignJWT,
+  jwtVerify,
+  decodeJwt }          = require("jose");
+const fetch            = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
+const cookieParser     = require("cookie-parser");
+const ioCookieParser   = require("socket.io-cookie-parser");
+const i18n             = require("i18n");
+const rateLimit        = require("express-rate-limit");
+const winston          = require("winston");
+const { doubleCsrf }   = require("csrf-csrf");
+const bodyParser       = require("body-parser");
+const node_config      = require("config");
+const { randomUUID,
+  randomBytes,
+  createSecretKey,
+  createHash }         = require("crypto");
+const semver           = require("semver");
 
 process.env["ALLOW_CONFIG_MUTATIONS"] = true;
 let config = node_config.get("ServerConfig"); // Server configuration (see default config file config.json)
@@ -44,15 +51,26 @@ const configSources = node_config.util.getConfigSources();
 const configFile = configSources[configSources.length - 1].name;
 
 config.port = process.env.PORT || config.port;
-const jsonWebTokenSecretKey = config.jsonWebTokenSecretKey && config.jsonWebTokenSecretKey.trim() != "" ? config.jsonWebTokenSecretKey : generateRandomJsonWebTokenSecretKey();
-const jsonWebTokenSecretKeyAdmin = config.jsonWebTokenSecretKeyAdmin && config.jsonWebTokenSecretKeyAdmin.trim() != "" ? config.jsonWebTokenSecretKeyAdmin : generateRandomJsonWebTokenSecretKey(jsonWebTokenSecretKey);
+
+const jsonWebTokenSecretKey = createSecretKey(
+  Buffer.from(config.jsonWebTokenSecretKey?.trim() || randomBytes(32))
+);
+
+const jsonWebTokenSecretKeyAdmin = createSecretKey(
+  Buffer.from(config.jsonWebTokenSecretKeyAdmin?.trim() || randomBytes(32))
+);
 
 const productionMode = process.env.NODE_ENV === "production";
 
 // Update config to file
 function updateConfigToFile() {
-  fs.writeFileSync(configFile, JSON.stringify({ "ServerConfig": config }, null, 4), "UTF-8");
-  config = node_config.get("ServerConfig");
+  try {
+    fs.writeFileSync(configFile, JSON.stringify({ "ServerConfig": config }, null, 4), "UTF-8");
+    config = node_config.get("ServerConfig");
+    logger.info("updated config file");
+  } catch(e) {
+    logger.error("failed to update config file", e);
+  }
 }
 
 // Logging
@@ -114,7 +132,6 @@ io = require("socket.io")(server, {
 
 // Game modules
 const snakeia        = require("snakeia");
-const { randomUUID } = require("crypto");
 const Snake          = snakeia.Snake;
 const Grid           = snakeia.Grid;
 const GameConstants  = snakeia.GameConstants;
@@ -122,9 +139,10 @@ const GameEngine     = config.enableMultithreading ? require("./GameEngineMultit
 const Player         = require("./Player");
 
 const games = {}; // Contains all the games processed by the server
-const tokens = []; // User tokens
-const invalidatedUserTokens = []; // Invalidated user tokens
-const invalidatedAdminTokens = []; // Invalidated admin tokens
+const tokens = new Map(); // User tokens
+const socketSessions = new Map();
+const invalidatedUserTokens = new Set(); // Invalidated user tokens
+const invalidatedAdminTokens = new Set(); // Invalidated admin tokens
 
 function getRoomsData() {
   const rooms = [];
@@ -164,20 +182,30 @@ function getRoomsData() {
 }
 
 function getRandomRoomKey() {
-  let r;
+  let roomKey;
 
   do {
-    r = Math.random().toString(36).substring(2, 10);
-  } while(r in games);
+    const length = 8;
+    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+    const charsLength = chars.length;
+  
+    const bytes = randomBytes(length);
+
+    roomKey = "";
+    
+    for(let i = 0; i < length; i++) {
+      roomKey += chars[bytes[i] % charsLength];
+    }
+  } while(roomKey in games);
 
-  return r;
+  return roomKey;
 }
 
 function generateRandomJsonWebTokenSecretKey(precValue) {
   let key;
 
   do {
-    key = require("crypto").randomBytes(256).toString("base64");
+    key = randomBytes(256).toString("base64");
   } while(precValue && precValue == key);
 
   return key;
@@ -206,8 +234,8 @@ function getMaxPlayers(code) {
   return Math.min(config.maxPlayers, Math.max(Math.round(numberEmptyCases / 5), 2));
 }
 
-function createRoom(data, socket) {
-  if(Object.keys(games).filter(key => games[key] != null).length < config.maxRooms && !Player.containsTokenAllGames(socket?.handshake?.auth?.token || socket?.handshake?.query?.token || socket?.request?.cookies?.token, games) && !Player.containsIdAllGames(socket.id, games)) {
+async function createRoom(data, socket) {
+  if(Object.keys(games).filter(key => games[key] != null).length < config.maxRooms && !Player.containsTokenAllGames(Player.getSocketToken(socket), games) && !Player.containsIdAllGames(socket.id, games)) {
     let heightGrid = 20;
     let widthGrid = 20;
     let borderWalls = false;
@@ -218,13 +246,13 @@ function createRoom(data, socket) {
     let validSettings = true;
     let privateGame = false;
   
-    if(data.heightGrid == null || isNaN(data.heightGrid) || data.heightGrid < config.minGridSize || data.heightGrid > config.maxGridSize) {
+    if(data.heightGrid == null || isNaN(data.heightGrid) || !Number.isInteger(data.heightGrid) || data.heightGrid < config.minGridSize || data.heightGrid > config.maxGridSize) {
       validSettings = false;
     } else {
       heightGrid = data.heightGrid;
     }
   
-    if(data.widthGrid == null || isNaN(data.widthGrid) || data.widthGrid < config.minGridSize || data.widthGrid > config.maxGridSize) {
+    if(data.widthGrid == null || isNaN(data.widthGrid) || !Number.isInteger(data.widthGrid) || data.widthGrid < config.minGridSize || data.widthGrid > config.maxGridSize) {
       validSettings = false;
     } else {
       widthGrid = data.widthGrid;
@@ -249,12 +277,12 @@ function createRoom(data, socket) {
     }
   
     if(data.speed == "custom") {
-      if(data.customSpeed == null || isNaN(data.customSpeed) || data.customSpeed < config.minSpeed || data.customSpeed > config.maxSpeed) {
+      if(data.customSpeed == null || isNaN(data.customSpeed) || !Number.isInteger(data.customSpeed) || data.customSpeed < config.minSpeed || data.customSpeed > config.maxSpeed) {
         validSettings = false;
       } else {
         speed = data.customSpeed;
       }
-    } else if(data.speed == null || isNaN(data.speed) || data.speed < config.minSpeed || data.speed > config.maxSpeed) {
+    } else if(data.speed == null || isNaN(data.speed) || !Number.isInteger(data.speed) || data.speed < config.minSpeed || data.speed > config.maxSpeed) {
       validSettings = false;
     } else {
       speed = data.speed;
@@ -294,13 +322,14 @@ function createRoom(data, socket) {
         started: false,
         alreadyInit: false,
         timeoutPlay: null,
+        timeoutMatchmaking: null,
         timeStart: null,
         timeoutMaxTimePlay: null
       };
 
       games[code].numberAIToAdd = enableAI ? Math.round(getMaxPlayers(code) / 2 - 1) : 0;
 
-      logger.info("room creation (code: " + code + ") - username: " + (Player.getUsernameSocket(socket)) + " - ip: " + getIPSocketIO(socket.handshake) + " - socket: " + socket.id, {
+      logger.info("room creation (code: " + code + ") - username: " + (await Player.getUsernameSocket(socket, jsonWebTokenSecretKey)) + " - ip: " + getIPSocketIO(socket.handshake) + " - socket: " + socket.id, {
         "widthGrid": widthGrid,
         "heightGrid": heightGrid,
         "generateWalls": generateWalls,
@@ -326,7 +355,7 @@ function createRoom(data, socket) {
       });
     }
   } else if(socket != null) {
-    if(Player.containsTokenAllGames(socket?.handshake?.auth?.token || socket?.handshake?.query?.token || socket?.request?.cookies?.token, games) || Player.containsIdAllGames(socket.id, games)) {
+    if(Player.containsTokenAllGames(Player.getSocketToken(socket), games) || Player.containsIdAllGames(socket.id, games)) {
       socket.emit("process", {
         success: false,
         code: null,
@@ -358,11 +387,11 @@ function copySnakes(snakes) {
         snakeCopy.aiLevel = snake.aiLevel;
   
         if(snake.lastTail) {
-          snakeCopy.lastTail = JSON.parse(JSON.stringify(snake.lastTail));
+          snakeCopy.lastTail = structuredClone(snake.lastTail);
         }
   
         if(snake.lastHead) {
-          snakeCopy.lastHead = JSON.parse(JSON.stringify(snake.lastHead));
+          snakeCopy.lastHead = structuredClone(snake.lastHead);
         }
   
         snakeCopy.lastTailMoved = snake.lastTailMoved;
@@ -371,7 +400,7 @@ function copySnakes(snakes) {
         snakeCopy.player = snake.player;
   
         if(snake.queue) {
-          snakeCopy.queue = JSON.parse(JSON.stringify(snake.queue));
+          snakeCopy.queue = structuredClone(snake.queue);
         }
   
         snakeCopy.score = snake.score;
@@ -416,6 +445,8 @@ function setupRoom(code) {
       "confirmExit": false,
       "getInfos": false,
       "getInfosGame": false,
+      "getInfosControls": false,
+      "getInfosGoal": false,
       "errorOccurred": game.errorOccurred,
       "timerToDisplay": config.enableMaxTimeGame ? (config.maxTimeGame - (Date.now() - game.timeStart)) / 1000 : -1,
       "aiStuck": game.aiStuck,
@@ -435,6 +466,8 @@ function setupRoom(code) {
       "confirmExit": false,
       "getInfos": false,
       "getInfosGame": false,
+      "getInfosControls": false,
+      "getInfosGoal": false,
       "errorOccurred": game.errorOccurred,
       "searchingPlayers": false
     });
@@ -447,6 +480,8 @@ function setupRoom(code) {
       "confirmExit": false,
       "getInfos": false,
       "getInfosGame": false,
+      "getInfosControls": false,
+      "getInfosGoal": false,
       "errorOccurred": game.errorOccurred
     });
   });
@@ -457,6 +492,8 @@ function setupRoom(code) {
       "confirmExit": false,
       "getInfos": false,
       "getInfosGame": false,
+      "getInfosControls": false,
+      "getInfosGoal": false,
       "errorOccurred": game.errorOccurred
     });
   });
@@ -471,13 +508,22 @@ function setupRoom(code) {
       "confirmExit": false,
       "getInfos": false,
       "getInfosGame": false,
+      "getInfosControls": false,
+      "getInfosGoal": false,
       "errorOccurred": game.errorOccurred
     });
 
     if(games[code] != null) {
       games[code].started = false;
       games[code].searchingPlayers = true;
+
       clearTimeout(games[code].timeoutMaxTimePlay);
+      clearTimeout(games[code].timeoutMatchmaking);
+
+      games[code].timeoutMatchmaking = setTimeout(() => {
+        gameMatchmaking(games[code], code);
+        io.to("room-" + code).emit("reset", { "gameOver": false, "gameFinished": false, "scoreMax": false, "gameMazeWin": false });
+      }, config.matchmakingWaitTime);
     }
   });
 
@@ -491,6 +537,8 @@ function setupRoom(code) {
       "confirmExit": false,
       "getInfos": false,
       "getInfosGame": false,
+      "getInfosControls": false,
+      "getInfosGoal": false,
       "errorOccurred": game.errorOccurred
     });
   });
@@ -507,6 +555,8 @@ function setupRoom(code) {
       "confirmExit": false,
       "getInfos": false,
       "getInfosGame": false,
+      "getInfosControls": false,
+      "getInfosGoal": false,
       "errorOccurred": game.errorOccurred
     });
   });
@@ -577,10 +627,9 @@ function cleanRooms() {
     const game = games[keys[i]];
 
     if(game != null) {
-      const players = Object.keys(game.players) + Object.keys(game.spectators);
-      const nb = players.length;
+      const players = Object.keys(game.players).length + Object.keys(game.spectators).length;
   
-      if(nb <= 0) {
+      if(players <= 0) {
         toRemove.push(keys[i]);
 
         if(game.gameEngine && game.gameEngine.kill) {
@@ -591,11 +640,16 @@ function cleanRooms() {
   }
 
   for(let i = 0; i < toRemove.length; i++) {
-    games[toRemove[i]] = null;
+    delete games[toRemove[i]];
   }
 }
 
 function gameMatchmaking(game, code) {
+  if(game.timeoutMatchmaking != null) {
+    clearTimeout(game.timeoutMatchmaking);
+    game.timeoutMatchmaking = null;
+  }
+
   if(game != null && games[code] != null && games[code].searchingPlayers) {
     let numberPlayers = game.players.length + games[code].numberAIToAdd;
 
@@ -661,6 +715,11 @@ async function startGame(code) {
       game.timeoutPlay = null;
     }
 
+    if(game.timeoutMatchmaking != null) {
+      clearTimeout(game.timeoutMatchmaking);
+      game.timeoutMatchmaking = null;
+    }
+
     game.searchingPlayers = false;
     game.started = true;
     game.gameEngine.snakes = [];
@@ -745,9 +804,9 @@ function sendStatus(code) {
   }
 }
 
-function exitGame(game, socket, code) {
+async function exitGame(game, socket, code) {
   if(game) {
-    logger.info("exit game (code: " + code + ") - username: " + Player.getUsernameSocket(socket) + " - ip: " + getIPSocketIO(socket.handshake) + " - socket: " + socket.id);
+    logger.info("exit game (code: " + code + ") - username: " + (await Player.getUsernameSocket(socket, jsonWebTokenSecretKey)) + " - ip: " + getIPSocketIO(socket.handshake) + " - socket: " + socket.id);
 
     if(Player.containsId(game.players, socket.id) && Player.getPlayer(game.players, socket.id).snake != null) {
       Player.getPlayer(game.players, socket.id).snake.gameOver = true;
@@ -778,94 +837,92 @@ function ipBanned(ip) {
     ip = ip.substr(7, ip.length);
   }
 
-  return new Promise((resolve, reject) => {
-    config.ipBan.forEach(ipBanned => {
-      if(ipBanned == ip) {
-        resolve();
-      }
-    });
-
-    reject();
-  });
+  return config.ipBan.includes(ip);
 }
 
 function usernameBanned(username) {
-  return new Promise((resolve, reject) => {
-    config.usernameBan.forEach(usernameBanned => {
-      if(username.toLowerCase().indexOf(usernameBanned.toLowerCase()) > -1) {
-        resolve();
-      }
-    });
+  for(const usernameBanned of config.usernameBan) {
+    if(username.toLowerCase().indexOf(usernameBanned.toLowerCase()) > -1) {
+      return true;
+    }
+  }
 
-    reject();
-  });
+  return false;
 }
 
-function usernameAlreadyInUse(username) {
-  return new Promise((resolve, reject) => {
-    tokens.forEach(token => {
-      try {
-        const otherUsername = jwt.verify(token, jsonWebTokenSecretKey).username;
+async function getUsernameToken(token, secretKey) {
+  try {
+    const { payload } = await jwtVerify(token, secretKey);
+    return payload.username ?? null;
+  } catch {
+    return null;
+  }
+}
 
-        if(otherUsername) {
-          if(otherUsername.toLowerCase().indexOf(username.toLowerCase()) > -1) {
-            resolve();
-          }
-        }
-      } catch(e) {}
-    });
+async function usernameAlreadyInUse(username) {
+  if(!tokens.has(username.toLowerCase())) {
+    return false;
+  }
 
-    reject();
-  });
+  try {
+    const token = tokens.get(username.toLowerCase());
+    const result = await getUsernameToken(token, jsonWebTokenSecretKey);
+
+    return result != null;
+  } catch(e) {
+    logger.error(e);
+    return false;
+  }
 }
 
-function verifyRecaptcha(response) {
+async function verifyRecaptcha(response) {
   if(config.enableRecaptcha && config.recaptchaPrivateKey && config.recaptchaPrivateKey.trim() != "" && config.recaptchaPublicKey && config.recaptchaPublicKey.trim() != "") {
     const params = new URLSearchParams();
+
     params.append("secret", config.recaptchaPrivateKey);
     params.append("response", response);
-  
-    return new Promise((resolve, reject) => {
-      fetch(config.recaptchaApiUrl, {
+
+    try {
+      const fetchResponse = await fetch(config.recaptchaApiUrl, {
         method: "POST",
         body: params
-      }).then(res => res.json()).then(json => {
-        if(json && json.success) {
-          resolve();
-        } else {
-          reject();
-        }
       });
-    });
-  } else {
-    return new Promise((resolve, reject) => {
-      resolve();
-    });
+
+      const responseBody = await fetchResponse.json();
+
+      if(responseBody && responseBody.success) {
+        return Promise.resolve();
+      } 
+      
+      return Promise.reject();
+    } catch(e) {
+      return Promise.reject();
+    }
   }
+  
+  return Promise.resolve();
 }
 
-function verifyFormAuthentication(body) {
-  return new Promise((resolve, reject) => {
-    verifyRecaptcha(body["g-recaptcha-response"]).then(() => {
-      const username = body["username"];
-
-      if(username && username.trim() != "" && username.length >= config.minCharactersUsername && username.length <= config.maxCharactersUsername) {
-        usernameBanned(username).then(() => {
-          reject("BANNED_USERNAME");
-        }, () => {
-          usernameAlreadyInUse(username).then(() => {
-            reject("USERNAME_ALREADY_IN_USE");
-          }, () => {
-            resolve();
-          });
-        });
-      } else {
-        reject("BAD_USERNAME");
-      }
-    }, () => {
-      reject("INVALID_RECAPTCHA");
-    });
-  });
+async function verifyFormAuthentication(body) {
+  try {
+    await verifyRecaptcha(body["g-recaptcha-response"]);
+  } catch {
+    throw "INVALID_RECAPTCHA";
+  }
+
+  const username = body["username"];
+
+  if(!username || username.trim() === "" || username.length < config.minCharactersUsername || username.length > config.maxCharactersUsername) {
+    throw "BAD_USERNAME";
+  }
+
+  if(usernameBanned(username)) {
+    throw "BANNED_USERNAME";
+  }
+
+  if(await usernameAlreadyInUse(username)) {
+    throw "USERNAME_ALREADY_IN_USE";
+  }
 }
 
 app.engine("html", ejs.renderFile);
@@ -878,6 +935,44 @@ app.use(express.urlencoded({ extended: true }));
 app.use(cookieParser());
 app.use(i18n.init);
 
+const csrfSecretAdmin = generateRandomJsonWebTokenSecretKey(jsonWebTokenSecretKeyAdmin);
+const { doubleCsrfProtection: doubleCsrfProtectionAdmin, generateCsrfToken: generateCsrfTokenAdmin } = doubleCsrf({
+  getSecret: () => csrfSecretAdmin,
+  getSessionIdentifier: (req) => req.cookies.tokenAdmin || randomUUID(),
+  getCsrfTokenFromRequest: (req) => {
+    return (
+      req.headers["x-csrf-token"] ||
+      req.body?._csrf ||
+      req.query?._csrf
+    );
+  },
+  cookieName: productionMode ? "__Host-snakeia-server.x-csrf-token-admin" : "snakeia-server.x-csrf-token-admin",
+  cookieOptions: {
+    sameSite: productionMode ? "strict" : "lax",
+    path: "/",
+    secure: productionMode
+  }
+});
+
+const csrfSecretUser = generateRandomJsonWebTokenSecretKey(jsonWebTokenSecretKeyAdmin);
+const { doubleCsrfProtection: doubleCsrfProtectionUserAuthent, generateCsrfToken: generateCsrfTokenUserAuthent } = doubleCsrf({
+  getSecret: () => csrfSecretUser,
+  getSessionIdentifier: (req) => req.cookies.sessionId || randomUUID(),
+  getCsrfTokenFromRequest: (req) => {
+    return (
+      req.headers["x-csrf-token"] ||
+      req.body?._csrf ||
+      req.query?._csrf
+    );
+  },
+  cookieName: "snakeia-server.x-csrf-token-user",
+  cookieOptions: {
+    sameSite: "lax",
+    path: "/authentication",
+    secure: productionMode
+  }
+});
+
 // Rate limiter
 app.use("/authentication", rateLimit({
   windowMs: config.authentWindowMs,
@@ -887,15 +982,16 @@ app.use("/authentication", rateLimit({
 
 // IP ban
 app.use(function(req, res, next) {
-  ipBanned(req.ip).then(() => {
-    res.render(__dirname + "/views/banned.html", {
+  if(ipBanned(req.ip)) {
+    res.status(403);
+
+    return res.render(__dirname + "/views/banned.html", {
       contact: config.contactBan,
       theme: req.query.theme
     });
-    res.end();
-  }, () => {
-    next()
-  });
+  }
+
+  next();
 });
 
 app.get("/", function(req, res) {
@@ -906,96 +1002,170 @@ app.get("/", function(req, res) {
   });
 });
 
-app.get("/authentication", function(req, res) {
-  if(req.cookies && config.enableAuthentication) {
-    let err = false;
-
-    checkAuthenticationExpress(req).catch(() => err = true).finally(() => {
-      res.render(__dirname + "/views/authentication.html", {
-        publicKey: config.recaptchaPublicKey,
-        enableRecaptcha: config.enableRecaptcha,
-        errorRecaptcha: false,
-        errorUsername: false,
-        errorUsernameBanned: false,
-        errorUsernameAlreadyInUse: false,
-        success: false,
-        authent: !err,
-        locale: i18n.getLocale(req),
-        min: config.minCharactersUsername,
-        max: config.maxCharactersUsername,
-        enableMaxTimeGame: config.enableMaxTimeGame,
-        maxTimeGame: config.maxTimeGame,
-        theme: req.query.theme
-      });
-    });
-  } else {
-    res.end();
+app.get("/authentication", async (req, res) => {
+  if(!req.cookies || !config.enableAuthentication) {
+    res.status(400);
+    return res.end();
+  }
+
+  const authenticated = await checkAuthenticationExpress(req).then(() => true).catch(() => false);
+
+  setSessionCookie(req, res);
+
+  const clientCompatible = isClientCompatible(req.query.version, req.query.id);
+
+  if(!clientCompatible) {
+    res.status(403);
+  }
+
+  res.render(__dirname + "/views/authentication.html", {
+    publicKey: config.recaptchaPublicKey,
+    enableRecaptcha: config.enableRecaptcha,
+    errorRecaptcha: false,
+    errorUsername: false,
+    errorUsernameBanned: false,
+    errorUsernameAlreadyInUse: false,
+    success: false,
+    authent: authenticated,
+    locale: i18n.getLocale(req),
+    min: config.minCharactersUsername,
+    max: config.maxCharactersUsername,
+    enableMaxTimeGame: config.enableMaxTimeGame,
+    maxTimeGame: config.maxTimeGame,
+    theme: req.query.theme,
+    clientCompatible,
+    serverGameVersion: GameConstants.Setting.APP_VERSION,
+    csrfToken: generateCsrfTokenUserAuthent(req, res, { overwrite: true, validateOnReuse: true }),
+  });
+
+  if(authenticated && clientCompatible) {
+    sendTokenToSocket(req, getExpressUserToken(req));
   }
 });
 
-app.post("/authentication", function(req, res) {
-  if(req.cookies && config.enableAuthentication) {
-    let err = false;
-    
-    checkAuthenticationExpress(req).catch(() => err = true).finally(() => {
-      if(err) {
-        verifyFormAuthentication(req.body).then(() => {
-          const username = req.body["username"];
-          const id = req.query.id;
-
-          const token = jwt.sign({
-            username: username
-          }, jsonWebTokenSecretKey, { expiresIn: config.authenticationTime / 1000 });
-      
-          res.cookie("token", token, { expires: new Date(Date.now() + config.authenticationTime), httpOnly: true, sameSite: "None", secure: (req.protocol == "https" ? true : false)  });
-
-          res.render(__dirname + "/views/authentication.html", {
-            publicKey: config.recaptchaPublicKey,
-            enableRecaptcha: config.enableRecaptcha,
-            errorRecaptcha: false,
-            errorUsername: false,
-            errorUsernameBanned: false,
-            errorUsernameAlreadyInUse: false,
-            success: true,
-            authent: false,
-            locale: i18n.getLocale(req),
-            min: config.minCharactersUsername,
-            max: config.maxCharactersUsername,
-            enableMaxTimeGame: config.enableMaxTimeGame,
-            maxTimeGame: config.maxTimeGame,
-            theme: req.query.theme
-          });
+function isClientCompatible(version, hasIdQueryParam) {
+  const hasNoVersion = !version || version.trim().length === 0;
 
-          logger.info("authentication - username: " + username + " - ip: " + req.ip);
+  if((hasNoVersion && hasIdQueryParam) || hasNoVersion) {
+    return false;
+  }
 
-          if(id != null) {
-            io.to("" + id).emit("token", token);
-          }
-        }, (err) => {
-          res.render(__dirname + "/views/authentication.html", {
-            publicKey: config.recaptchaPublicKey,
-            enableRecaptcha: config.enableRecaptcha,
-            errorRecaptcha: err == "INVALID_RECAPTCHA",
-            errorUsername: err == "BAD_USERNAME",
-            errorUsernameBanned: err == "BANNED_USERNAME",
-            errorUsernameAlreadyInUse: err == "USERNAME_ALREADY_IN_USE",
-            success: false,
-            authent: false,
-            locale: i18n.getLocale(req),
-            min: config.minCharactersUsername,
-            max: config.maxCharactersUsername,
-            enableMaxTimeGame: config.enableMaxTimeGame,
-            maxTimeGame: config.maxTimeGame,
-            theme: req.query.theme
-          });
-        });
-      }
+  return semver.gte(version, GameConstants.Setting.APP_VERSION);
+}
+
+function setSessionCookie(req, res) {
+  let sessionId = req.cookies.sessionId;
+
+  if(!sessionId) {
+    sessionId = randomUUID();
+
+    res.cookie("sessionId", sessionId, {
+      httpOnly: true,
+      sameSite: "lax",
+      secure: req.protocol === "https"
     });
-  } else {
-    res.end();
+
+    req.cookies.sessionId = sessionId;
+  }
+}
+
+app.post("/authentication", doubleCsrfProtectionUserAuthent, async (req, res) => {
+  if(!req.cookies || !config.enableAuthentication) {
+    res.status(400);
+    return res.end();
   }
+
+  const alreadyAuthenticated = await checkAuthenticationExpress(req).then(() => true).catch(() => false);
+
+  if(alreadyAuthenticated) {
+    return res.end();
+  }
+
+  const clientCompatible = isClientCompatible(req.query.version, req.query.id);
+
+  let formError = null;
+
+  if(clientCompatible) {
+    await verifyFormAuthentication(req.body).catch(e => formError = e);
+  }
+
+  if(formError || !clientCompatible) {
+    res.status(403);
+
+    return res.render(__dirname + "/views/authentication.html", {
+      publicKey: config.recaptchaPublicKey,
+      enableRecaptcha: config.enableRecaptcha,
+      errorRecaptcha: formError == "INVALID_RECAPTCHA",
+      errorUsername: formError == "BAD_USERNAME",
+      errorUsernameBanned: formError == "BANNED_USERNAME",
+      errorUsernameAlreadyInUse: formError == "USERNAME_ALREADY_IN_USE",
+      success: false,
+      authent: false,
+      locale: i18n.getLocale(req),
+      min: config.minCharactersUsername,
+      max: config.maxCharactersUsername,
+      enableMaxTimeGame: config.enableMaxTimeGame,
+      maxTimeGame: config.maxTimeGame,
+      theme: req.query.theme,
+      clientCompatible,
+      serverGameVersion: GameConstants.Setting.APP_VERSION,
+      csrfToken: generateCsrfTokenUserAuthent(req, res, { overwrite: true, validateOnReuse: true })
+    });
+  }
+
+  const username = req.body["username"];
+
+  const token = await new SignJWT({ username })
+    .setProtectedHeader({ alg: "HS256" })
+    .setExpirationTime(Math.floor(config.authenticationTime / 1000) + "s")
+    .setIssuedAt()
+    .sign(jsonWebTokenSecretKey);
+
+  generateTokenCookie(res, token, req);
+
+  res.render(__dirname + "/views/authentication.html", {
+    publicKey: config.recaptchaPublicKey,
+    enableRecaptcha: config.enableRecaptcha,
+    errorRecaptcha: false,
+    errorUsername: false,
+    errorUsernameBanned: false,
+    errorUsernameAlreadyInUse: false,
+    success: true,
+    authent: false,
+    locale: i18n.getLocale(req),
+    min: config.minCharactersUsername,
+    max: config.maxCharactersUsername,
+    enableMaxTimeGame: config.enableMaxTimeGame,
+    maxTimeGame: config.maxTimeGame,
+    theme: req.query.theme,
+    clientCompatible,
+    serverGameVersion: GameConstants.Setting.APP_VERSION,
+    csrfToken: null
+  });
+
+  logger.info("authentication - username: " + username + " - ip: " + req.ip);
+
+  sendTokenToSocket(req, token);
 });
 
+function generateTokenCookie(res, token, req) {
+  res.cookie("token", token, {
+    expires: new Date(Date.now() + config.authenticationTime),
+    httpOnly: true,
+    sameSite: "None",
+    secure: req.protocol === "https"
+  });
+}
+
+function sendTokenToSocket(req, token) {
+  const sessionId = req.cookies.sessionId;
+  const socketId = socketSessions.get(sessionId);
+
+  if(socketId != null) {
+    io.to("" + socketId).emit("token", token);
+  }
+}
+
 app.get("/rooms", function(req, res) {
   const callbackName = req.query.callback;
   res.charset = "UTF-8";
@@ -1019,25 +1189,18 @@ function kickUser(socketId, token) {
 }
 
 function kickUsername(username) {
-  tokens.forEach(token => {
-    jwt.verify(token, jsonWebTokenSecretKey, function(err, data) {
-      if(!err && data && data.username && data.username == username) {
-        invalidateUserToken(token);
-      }
-    });
-  });
-}
+  const usernameToken = tokens.get(username.toLowerCase());
 
-function invalidateUserToken(token) {
-  invalidatedUserTokens.push(token);
-
-  for(let i = tokens.length - 1; i >= 0; i--) {
-    if(tokens[i] == token) {
-      tokens.splice(i, 1);
-    }
+  if(usernameToken) {
+    invalidateUserToken(username, usernameToken);
   }
 }
 
+function invalidateUserToken(username, token) {
+  invalidatedUserTokens.add(token);
+  tokens.delete(username.toLowerCase());
+}
+
 function banUserIP(socketId) {
   const sockets = io.of("/").sockets;
 
@@ -1057,17 +1220,16 @@ function banUserIP(socketId) {
   }
 }
 
-function banUserName(token) {
-  jwt.verify(token, jsonWebTokenSecretKey, function(err, data) {
-    if(!err && data) {
-      if(data.username) {
-        config.usernameBan.push(data.username);
-        logger.info("username banned (" + data.username + ")");
-      }
-
+async function banUserName(token) {
+  try {
+    const { payload } = await jwtVerify(token, jsonWebTokenSecretKey);
+    
+    if(payload.username) {
+      config.usernameBan.push(payload.username);
+      logger.info("username banned (" + payload.username + ")");
       updateConfigToFile();
     }
-  });
+  } catch {}
 }
 
 function unbanUsername(value) {
@@ -1095,13 +1257,21 @@ function manualIPBan(value) {
 }
 
 function resetLog() {
-  fs.writeFileSync(config.logFile, "", "UTF-8");
-  logger.info("log file reseted");
+  try {
+    fs.writeFileSync(config.logFile, "", "UTF-8");
+    logger.info("log file reseted");
+  } catch(e) {
+    logger.error("failed to reset log file", e);
+  }
 }
 
 function resetErrorLog() {
-  fs.writeFileSync(config.errorLogFile, "", "UTF-8");
-  logger.info("error log file reseted");
+  try {
+    fs.writeFileSync(config.errorLogFile, "", "UTF-8");
+    logger.info("error log file reseted");
+  } catch(e) {
+    logger.error("failed to reset error log file", e);
+  }
 }
 
 function updateConfig(value) {
@@ -1120,178 +1290,188 @@ function updateConfig(value) {
   }
 }
 
-function verifyFormAuthenticationAdmin(body) {
-  return new Promise((resolve, reject) => {
-    verifyRecaptcha(body["g-recaptcha-response"]).then(() => {
-      const username = body["username"];
-      const password = body["password"];
-      
-      const accounts = config.adminAccounts;
+async function verifyFormAuthenticationAdmin(body) {
+  try {
+    await verifyRecaptcha(body["g-recaptcha-response"]);
+  } catch {
+    throw "INVALID_RECAPTCHA";
+  }
 
-      if(accounts) {
-        const usernames = Object.keys(accounts);
+  const { username, password } = body;
+  const accounts = config.adminAccounts;
 
-        if(usernames.includes(username)) {
-          const hashPassword = accounts[username]["password"];
-          const enteredPasswordHash = require("crypto").createHash("sha512").update(password).digest("hex");
+  if(!accounts || !Object.keys(accounts).includes(username)) {
+    throw "INVALID";
+  }
 
-          if(hashPassword === enteredPasswordHash) {
-            resolve();
-          } else {
-            reject("INVALID");
-          }
-        } else {
-          reject("INVALID");
-        }
-      }
-    }, () => {
-      reject("INVALID_RECAPTCHA");
-    });
-  });
+  const hashPassword = accounts[username]["password"];
+  const enteredPasswordHash = createHash("sha512").update(password).digest("hex");
+
+  if(hashPassword !== enteredPasswordHash) {
+    throw "INVALID";
+  }
 }
 
-const csrfSecret = generateRandomJsonWebTokenSecretKey(jsonWebTokenSecretKeyAdmin);
-const { doubleCsrfProtection, generateCsrfToken } = doubleCsrf({
-  getSecret: () => csrfSecret,
-  getSessionIdentifier: (req) => req.cookies.tokenAdmin || randomUUID(),
-  getCsrfTokenFromRequest: (req) => {
-    return (
-      req.headers["x-csrf-token"] ||
-      req.body?._csrf ||
-      req.query?._csrf
-    );
-  },
-  cookieName: productionMode ? "__Host-snakeia-server.x-csrf-token" : "snakeia-server.x-csrf-token",
-  cookieOptions: {
-    sameSite: productionMode ? "strict" : "lax",
-    path: "/",
-    secure: productionMode
+async function verifyAdminToken(req) {
+  const token = req.cookies?.tokenAdmin;
+
+  if(!token || invalidatedAdminTokens.has(token)) {
+    return null;
   }
+
+  try {
+    const { payload } = await jwtVerify(token, jsonWebTokenSecretKeyAdmin);
+    const usernames = Object.keys(config.adminAccounts);
+
+    if(payload.username && usernames.includes(payload.username)) {
+      return payload;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+const adminAuthentRateLimiter = rateLimit({
+  windowMs: config.adminAuthentWindowMs,
+  max: config.adminAuthentMaxRequest,
+  validate: { trustProxy: false }
 });
 
-app.get("/admin", doubleCsrfProtection, function(req, res) {
-  if(req.cookies) {
-    jwt.verify(req.cookies.tokenAdmin, jsonWebTokenSecretKeyAdmin, function(err, data) {
-      if(invalidatedAdminTokens.includes(req.cookies.tokenAdmin)) err = true;
-      
-      const usernames = Object.keys(config.adminAccounts);
-      const authenticated = !err && data && data.username && usernames.includes(data.username);
-      let role = "none";
+const adminActionsRateLimiter = rateLimit({
+  windowMs: config.adminActionsWindowMs,
+  max: config.adminActionsMaxRequest,
+  validate: { trustProxy: false }
+});
 
-      if(authenticated) {
-        role = config.adminAccounts[data.username]["role"] || "moderator";
-      }
-      
-      fs.readFile(config.logFile, "UTF-8", function(e1, logFile) {
-        fs.readFile(config.errorLogFile, "UTF-8", function(e2, errorLogFile) {
-          res.render(__dirname + "/views/admin.html", {
-            publicKey: config.recaptchaPublicKey,
-            enableRecaptcha: config.enableRecaptcha,
-            authent: authenticated,
-            role: role,
-            username: authenticated ? data.username : "",
-            success: false,
-            errorAuthent: false,
-            errorRecaptcha: false,
-            locale: i18n.getLocale(req),
-            games: games,
-            io: io,
-            config: config,
-            csrfToken: generateCsrfToken(req, res, { overwrite: true, validateOnReuse: true }),
-            serverLog: logFile,
-            errorLog: errorLogFile,
-            getIPSocketIO: getIPSocketIO,
-            theme: req.query.theme
-          });
-        });
-      });
-    });
-  } else {
-    res.end();
+app.get("/admin", adminActionsRateLimiter, doubleCsrfProtectionAdmin, async (req, res) => {
+  if(!req.cookies) {
+    res.status(400);
+    return res.end();
+  }
+
+  const payload = await verifyAdminToken(req);
+  const authenticated = payload != null;
+  const role = authenticated ? (config.adminAccounts[payload.username]["role"] || "moderator") : "none";
+
+  const [logFile, errorLogFile] = await Promise.all([
+    fs.promises.readFile(config.logFile, "UTF-8").catch(() => ""),
+    fs.promises.readFile(config.errorLogFile, "UTF-8").catch(() => "")
+  ]);
+
+  if(!authenticated) {
+    res.status(401);
   }
+      
+  res.render(__dirname + "/views/admin.html", {
+    publicKey: config.recaptchaPublicKey,
+    enableRecaptcha: config.enableRecaptcha,
+    authent: authenticated,
+    role: role,
+    username: authenticated ? payload.username : "",
+    success: false,
+    errorAuthent: false,
+    errorRecaptcha: false,
+    locale: i18n.getLocale(req),
+    games: games,
+    io: io,
+    config: role === "administrator" ? config : null,
+    csrfToken: generateCsrfTokenAdmin(req, res, { overwrite: true, validateOnReuse: true }),
+    serverLog: logFile,
+    errorLog: errorLogFile,
+    getIPSocketIO: getIPSocketIO,
+    theme: req.query.theme
+  });
 });
 
-function adminAction(req, res, action) {
-  if(req.cookies) {
-    jwt.verify(req.cookies.tokenAdmin, jsonWebTokenSecretKeyAdmin, function(err, data) {
-      if(invalidatedAdminTokens.includes(req.cookies.tokenAdmin)) err = true;
-
-      const usernames = Object.keys(config.adminAccounts);
-      const authenticated = !err && data && data.username && usernames.includes(data.username);
-
-      if(authenticated) {
-        const username = data.username;
-        const role = config.adminAccounts[username]["role"] || "moderator";
-
-        if(action == "disconnect") {
-          invalidatedAdminTokens.push(req.cookies.tokenAdmin);
-          res.cookie("tokenAdmin", { expires: -1 });
-          res.redirect("/admin");
-          return;
-        } else if(action) {
-          const socket = req.body.socket;
-          const token = req.body.token;
-          const value = req.body.value;
-
-          switch(action) {
-            case "kick":
-              kickUser(socket, token);
-              break;
-            case "banIP":
-              if(value) {
-                manualIPBan(value);
-              } else {
-                banUserIP(socket);
-                kickUser(socket, token);
-              }
-              break;
-            case "banUserName":
-              if(value) {
-                manualUsernameBan(value);
-                kickUsername(value);
-              } else {
-                banUserName(token);
-                kickUser(socket, token);
-              }
-              break;
-            case "banIPUserName":
-              banUserIP(socket);
-              banUserName(token);
-              kickUser(socket, token);
-              break;
-            case "unbanUsername":
-              unbanUsername(value);
-              break;
-            case "unbanIP":
-              unbanIP(value);
-              break;
-            case "resetLog":
-              if(role === "administrator") resetLog();
-              break;
-            case "resetErrorLog":
-              if(role === "administrator") resetErrorLog();
-              break;
-            case "updateConfig":
-              if(role === "administrator") updateConfig(value);
-              break;
-          }
+async function adminAction(req, res, action) {
+  if(!req.cookies) {
+    res.status(400);
+    return res.end();
+  }
 
-          res.redirect("/admin");
-          return;
-        }
-      }
+  const payload = await verifyAdminToken(req);
 
-      res.redirect("/admin");
-      return;
-    });
-  } else {
-    res.end();
+  if(!payload) {
+    return res.redirect(303, "/admin");
+  }
+
+  const role = config.adminAccounts[payload.username]["role"] || "moderator";
+
+  if(action === "disconnect") {
+    invalidatedAdminTokens.add(req.cookies.tokenAdmin);
+    res.clearCookie("tokenAdmin");
+
+    return res.redirect(303, "/admin");
+  }
+
+  const { socket, token, value } = req.body;
+
+  switch(action) {
+    case "kick":
+      kickUser(socket, token);
+      break;
+    case "banIP":
+      if(value) {
+        manualIPBan(value);
+      } else {
+        banUserIP(socket);
+        kickUser(socket, token);
+      }
+      break;
+    case "banUserName":
+      if(value) {
+        manualUsernameBan(value);
+        kickUsername(value);
+      } else {
+        await banUserName(token);
+        kickUser(socket, token);
+      }
+      break;
+    case "banIPUserName":
+      banUserIP(socket);
+      await banUserName(token);
+      kickUser(socket, token);
+      break;
+    case "unbanUsername":
+      unbanUsername(value);
+      break;
+    case "unbanIP":
+      unbanIP(value);
+      break;
+    case "resetLog":
+      if(role === "administrator") {
+        resetLog();
+      } else {
+        res.status(403);
+        return res.end();
+      }
+      break;
+    case "resetErrorLog":
+      if(role === "administrator") {
+        resetErrorLog();
+      } else {
+        res.status(403);
+        return res.end();
+      }
+      break;
+    case "updateConfig":
+      if(role === "administrator") {
+        updateConfig(value);
+      } else {
+        res.status(403);
+        return res.end();
+      }
+      break;
   }
+
+  res.redirect(303, "/admin");
 }
 
 const jsonParser = bodyParser.json();
 
-app.post("/admin/:action", jsonParser, doubleCsrfProtection, function(req, res) {
+app.post("/admin/:action", adminActionsRateLimiter, jsonParser, doubleCsrfProtectionAdmin, function(req, res) {
   adminAction(req, res, req.params.action);
 });
 
@@ -1301,113 +1481,123 @@ app.use(function (err, req, res, next) {
   res.send("Error: invalid CSRF token");
 });
 
-const adminRateLimiter = rateLimit({
-  windowMs: config.authentWindowMs,
-  max: config.authentMaxRequest,
-  validate: { trustProxy: false }
-});
+app.post("/admin", adminAuthentRateLimiter, async (req, res) => {
+  if(!req.cookies) {
+    res.status(400);
+    return res.end();
+  }
 
-app.post("/admin", adminRateLimiter, function(req, res) {
-  if(req.cookies) {
-    jwt.verify(req.cookies.tokenAdmin, jsonWebTokenSecretKeyAdmin, function(err, data) {
-      if(invalidatedAdminTokens.includes(req.cookies.tokenAdmin)) res = true;
+  const payload = await verifyAdminToken(req);
 
-      if(err) {
-        verifyFormAuthenticationAdmin(req.body).then(() => {
-          const username = req.body["username"];
+  if(payload) {
+    return res.redirect(303, "/admin");
+  }
 
-          const token = jwt.sign({
-            username: username
-          }, jsonWebTokenSecretKeyAdmin, { expiresIn: config.authenticationTime / 1000 });
-      
-          res.cookie("tokenAdmin", token, { expires: new Date(Date.now() + config.authenticationTime), httpOnly: true, sameSite: "strict", secure: (req.protocol == "https" ? true : false)  });
-          res.redirect("/admin");
-          logger.info("admin authent - username: " + username + " - ip: " + req.ip);
-          return;
-        }, (err) => {
-          res.render(__dirname + "/views/admin.html", {
-            publicKey: config.recaptchaPublicKey,
-            enableRecaptcha: config.enableRecaptcha,
-            authent: false,
-            errorAuthent: true,
-            errorRecaptcha: err == "INVALID_RECAPTCHA",
-            locale: i18n.getLocale(req),
-            games: null,
-            io: null,
-            config: null,
-            csrfToken: null,
-            serverLog: null,
-            errorLog: null,
-            getIPSocketIO: getIPSocketIO,
-            theme: req.query.theme
-          });
-        });
-      }
+  try {
+    await verifyFormAuthenticationAdmin(req.body);
+  } catch(err) {
+    res.status(403);
+
+    return res.render(__dirname + "/views/admin.html", {
+      publicKey: config.recaptchaPublicKey,
+      enableRecaptcha: config.enableRecaptcha,
+      authent: false,
+      errorAuthent: true,
+      errorRecaptcha: err == "INVALID_RECAPTCHA",
+      locale: i18n.getLocale(req),
+      games: null,
+      io: null,
+      config: null,
+      csrfToken: null,
+      serverLog: null,
+      errorLog: null,
+      getIPSocketIO: getIPSocketIO,
+      theme: req.query.theme
     });
-  } else {
-    res.end();
   }
+
+  const username = req.body["username"];
+
+  const token = await new SignJWT({ username })
+    .setProtectedHeader({ alg: "HS256" })
+    .setExpirationTime(Math.floor(config.authenticationTime / 1000) + "s")
+    .setIssuedAt()
+    .sign(jsonWebTokenSecretKeyAdmin);
+
+  res.cookie("tokenAdmin", token, {
+    expires: new Date(Date.now() + config.authenticationTime),
+    httpOnly: true,
+    sameSite: "strict",
+    secure: req.protocol === "https"
+  });
+
+  res.redirect(303, "/admin");
+
+  logger.info("admin authent - username: " + username + " - ip: " + req.ip);
 });
 
 io.use(ioCookieParser());
 
 function getIPSocketIO(req) {
-  let ipAddress;
-
-  if(req && req.headers) {
+  if(req?.headers) {
     const forwardedIpsStr = req.headers["x-forwarded-for"];
-  
-    if(forwardedIpsStr && forwardedIpsStr !== undefined && config.proxyMode) {
-      const forwardedIps = forwardedIpsStr.split(",");
-      ipAddress = forwardedIps[0];
-    }
-  
-    if(!ipAddress) {
-      ipAddress = req.address;
+
+    if(forwardedIpsStr && config.proxyMode) {
+      const forwardedIps = forwardedIpsStr.split(",").map(ip => ip.trim());
+      const index = forwardedIps.length - config.numberOfProxies;
+
+      if(index >= 0) {
+        return forwardedIps[index];
+      }
     }
-  }
 
-  return ipAddress;
+    return req.address;
+  }
 }
 
-function checkAuthentication(token) {
-  return new Promise((resolve, reject) => {
-    if(!config.enableAuthentication) {
-      resolve();
-    } else {
-      if(token && invalidatedUserTokens.includes(token)) reject();
-  
-      jwt.verify(token, jsonWebTokenSecretKey, function(err, data) {
-        if(!err) {
-          resolve(token);
-        } else {
-          reject();
-        }
-      });
-    }
-  });
+async function checkAuthentication(token) {
+  if(!config.enableAuthentication) {
+    return;
+  }
+
+  if(!token || invalidatedUserTokens.has(token)) {
+    throw new Error("UNAUTHORIZED");
+  }
+
+  try {
+    await jwtVerify(token, jsonWebTokenSecretKey);
+    return token;
+  } catch {
+    throw new Error("UNAUTHORIZED");
+  }
 }
 
 function checkAuthenticationSocket(socket) {
-  return checkAuthentication(socket?.handshake?.auth?.token || socket?.handshake?.query?.token || socket?.request?.cookies?.token);
+  return checkAuthentication(Player.getSocketToken(socket));
+}
+
+function getExpressUserToken(req) {
+  return req.cookies.token;
 }
 
 function checkAuthenticationExpress(req) {
-  return checkAuthentication(req.cookies.token);
+  return checkAuthentication(getExpressUserToken(req));
 }
 
 const checkBanned = function(socket, next) {
-  ipBanned(getIPSocketIO(socket.handshake)).then(() => {
-    next(new Error(GameConstants.Error.BANNED));
-  }, () => {
-    next();
-  });
+  if(ipBanned(getIPSocketIO(socket.handshake))) {
+    return next(new Error(GameConstants.Error.BANNED));
+  }
+  
+  next();
 };
 
 io.use(checkBanned);
 
-io.of("/rooms").use(ioCookieParser()).use(checkBanned).on("connection", function(socket) {
-  checkAuthenticationSocket(socket).then(() => {
+io.of("/rooms").use(ioCookieParser()).use(checkBanned).on("connection", async (socket) => {
+  try {
+    await checkAuthenticationSocket(socket);
+
     socket.emit("rooms", {
       rooms: getRoomsData(),
       serverVersion: config.version,
@@ -1421,49 +1611,59 @@ io.of("/rooms").use(ioCookieParser()).use(checkBanned).on("connection", function
         enableAI: config.enableAI
       }
     });
-  }, () => {
-    socket.emit("authent", GameConstants.Error.AUTHENTICATION_REQUIRED);
-  });
+  } catch(e) {
+    emitAuthenticationRequired(socket);
+  }
 });
 
-io.of("/createRoom").use(ioCookieParser()).use(checkBanned).on("connection", function(socket) {
-  socket.on("create", function(data) {
-    checkAuthenticationSocket(socket).then(() => {
-      createRoom(data, socket);
-    }, () => {
-      socket.emit("authent", GameConstants.Error.AUTHENTICATION_REQUIRED);
-    });
+io.of("/createRoom").use(ioCookieParser()).use(checkBanned).on("connection", (socket) => {
+  socket.on("create", async (data) => {
+    try {
+      await checkAuthenticationSocket(socket);
+      await createRoom(data, socket);
+    } catch {
+      emitAuthenticationRequired(socket);
+    }
   });
 });
 
-io.on("connection", function(socket) {
-  checkAuthenticationSocket(socket).then((token) => {
+io.on("connection", async (socket) => {
+  try {
+    const token = await checkAuthenticationSocket(socket);
+    const username = await Player.getUsernameToken(token, jsonWebTokenSecretKey);
+
+    if(!username) return;
+
     socket.emit("authent", GameConstants.GameState.AUTHENTICATION_SUCCESS);
-    tokens.push(token);
+    tokens.set(username.toLowerCase(), token);
 
-    socket.on("join-room", function(data) {
-      const code = data.code;
-      const version = data.version;
+    socket.on("join-room", async (data) => {
+      const { code, version } = data;
       const game = games[code];
-  
-      if(game != null && !Player.containsId(game.players, socket.id) && !Player.containsId(game.spectators, socket.id) && !Player.containsToken(game.players, token) && !Player.containsToken(game.spectators, token) && !Player.containsTokenAllGames(token, games) && !Player.containsIdAllGames(socket.id, games)) {
+
+      if(game != null
+        && !Player.containsId(game.players, socket.id)
+        && !Player.containsId(game.spectators, socket.id)
+        && !Player.containsToken(game.players, token)
+        && !Player.containsToken(game.spectators, token)
+        && !Player.containsTokenAllGames(token, games)
+        && !Player.containsIdAllGames(socket.id, games)
+      ) {
         socket.join("room-" + code);
-  
+
         if(game.players.length + game.numberAIToAdd >= getMaxPlayers(code) || game.started) {
-          game.spectators.push(new Player(token, socket.id, null, false, version));
+          game.spectators.push(new Player(token, username, socket.id, null, false, version));
         } else {
-          game.players.push(new Player(token, socket.id, null, false, version));
+          game.players.push(new Player(token, username, socket.id, null, false, version));
         }
-  
-        socket.emit("join-room", {
-          success: true
-        });
-      
+
+        socket.emit("join-room", { success: true });
+
         socket.once("start", () => {
           if(Player.containsId(game.players, socket.id)) {
             Player.getPlayer(game.players, socket.id).ready = true;
           }
-        
+
           if(game.started) {
             socket.emit("init", {
               "paused": game.gameEngine.paused,
@@ -1485,6 +1685,8 @@ io.on("connection", function(socket) {
               "confirmExit": false,
               "getInfos": false,
               "getInfosGame": false,
+              "getInfosControls": false,
+              "getInfosGoal": false,
               "errorOccurred": game.gameEngine.errorOccurred,
               "timerToDisplay": config.enableMaxTimeGame ? (config.maxTimeGame - (Date.now() - game.timeStart)) / 1000 : -1,
               "countBeforePlay": game.gameEngine.countBeforePlay,
@@ -1502,89 +1704,120 @@ io.on("connection", function(socket) {
               "offsetFrame": game.gameEngine.speed * GameConstants.Setting.TIME_MULTIPLIER
             });
           }
-  
+
           gameMatchmaking(game, code);
-  
+
           socket.on("start", () => {
-            socket.emit("start", {
-              "paused": false
-            });
+            socket.emit("start", { "paused": false });
           });
         });
-      
-        socket.once("exit", () => {
-          exitGame(game, socket, code);
-        });
-      
-        socket.once("kill", () => {
-          exitGame(game, socket, code);
-        });
-      
-        socket.on("key", function(key) {
+
+        socket.once("exit", () => exitGame(game, socket, code));
+        socket.once("kill", () => exitGame(game, socket, code));
+        socket.once("error", () => exitGame(game, socket, code));
+        socket.once("disconnect", () => exitGame(game, socket, code));
+
+        socket.on("key", (key) => {
           if(game != null && Player.containsId(game.players, socket.id) && Player.getPlayer(game.players, socket.id).snake) {
             Player.getPlayer(game.players, socket.id).snake.lastKey = key;
             sendStatus(code);
           }
         });
-  
-        socket.on("pause", () => {
-          socket.emit("pause", {
-            "paused": true
-          });
-        });
-  
+
+        socket.on("pause", () => socket.emit("pause", { "paused": true }));
+
         socket.on("reset", () => {
           if(!game.started) {
             gameMatchmaking(game, code);
-  
-            socket.emit("reset", {
-              "gameOver": false,
-              "gameFinished": false,
-              "scoreMax": false,
-              "gameMazeWin": false
-            });
+            socket.emit("reset", { "gameOver": false, "gameFinished": false, "scoreMax": false, "gameMazeWin": false });
           }
         });
-  
-        socket.once("error", () => {
-          exitGame(game, socket, code);
-        });
-  
-        socket.once("disconnect", () => {
-          exitGame(game, socket, code);
-        });
-  
+
         socket.on("forceStart", () => {
           if(game != null && Player.containsId(game.players, socket.id) && game.players[0].id == socket.id && !game.started) {
             startGame(code);
           }
         });
-  
-        logger.info("join room (code: " + code + ") - username: " + Player.getUsernameSocket(socket) + " - ip: " + getIPSocketIO(socket.handshake) + " - socket: " + socket.id);
+
+        logger.info("join room (code: " + code + ") - username: " + (await Player.getUsernameSocket(socket, jsonWebTokenSecretKey)) + " - ip: " + getIPSocketIO(socket.handshake) + " - socket: " + socket.id);
       } else {
         if(games[code] == null) {
-          socket.emit("join-room", {
-            success: false,
-            errorCode: GameConstants.Error.ROOM_NOT_FOUND
-          });
-        } else if(Player.containsId(game.players, socket.id) || Player.containsId(game.spectators, socket.id) || Player.containsToken(game.players, token) || Player.containsToken(game.spectators, token)) {
-          socket.emit("join-room", {
-            success: false,
-            errorCode: GameConstants.Error.ROOM_ALREADY_JOINED
-          });
+          socket.emit("join-room", { success: false, errorCode: GameConstants.Error.ROOM_NOT_FOUND });
+        } else if(
+          Player.containsId(game.players, socket.id)
+          || Player.containsId(game.spectators, socket.id)
+          || Player.containsToken(game.players, token)
+          || Player.containsToken(game.spectators, token)
+        ) {
+          socket.emit("join-room", { success: false, errorCode: GameConstants.Error.ROOM_ALREADY_JOINED });
         } else if(Player.containsTokenAllGames(token, games) || Player.containsIdAllGames(socket.id, games)) {
-          socket.emit("join-room", {
-            success: false,
-            errorCode: GameConstants.Error.ALREADY_CREATED_ROOM
-          });
+          socket.emit("join-room", { success: false, errorCode: GameConstants.Error.ALREADY_CREATED_ROOM });
         }
       }
     });
-  }, () => {
-    socket.emit("authent", GameConstants.Error.AUTHENTICATION_REQUIRED);
-  });
+  } catch {
+    emitAuthenticationRequired(socket);
+  }
 });
 
+function emitAuthenticationRequired(socket) {
+  const sessionId = socket.request.cookies.sessionId;
+
+  if(sessionId) {
+    socketSessions.set(sessionId, socket.id);
+  }
+
+  socket.on("disconnect", () => {
+    socketSessions.delete(sessionId);
+  });
+
+  socket.emit("authent", GameConstants.Error.AUTHENTICATION_REQUIRED);
+}
+
+function isTokenExpired(token) {
+  try {
+    const decoded = decodeJwt(token);
+    const now = Math.floor(Date.now() / 1000);
+
+    return !decoded?.exp || decoded.exp < now;
+  } catch {
+    return true;
+  }
+}
+
+function cleanMap(map) {
+  for(const [key, token] of map.entries()) {
+    if(isTokenExpired(token)) {
+      map.delete(key);
+    }
+  }
+}
+
+function cleanSet(set) {
+  for(const token of set) {
+    if(isTokenExpired(token)) {
+      set.delete(token);
+    }
+  }
+}
+
+function cleanSocketSessions() {
+  for(const [sessionId, socketId] of socketSessions.entries()) {
+    if(!io.sockets.sockets.get(socketId)) {
+      socketSessions.delete(sessionId);
+    }
+  }
+}
+
+function cleanupTokenMaps() {
+  cleanMap(tokens);
+  cleanSet(invalidatedUserTokens);
+  cleanSet(invalidatedAdminTokens);
+  cleanSocketSessions();
+}
+
 server.listen(config.port, () => {
   console.log("listening on *:" + config.port);
-});
+});
+
+setInterval(cleanupTokenMaps, 60 * 1000);