serverpreconfigured 1.0.2 → 1.0.5

package/dist/database/models/WSAuth.d.ts

@@ -0,0 +1,7 @@
+import { Model } from "sequelize";
+export declare class WebSocketAuth extends Model {
+    token: string;
+    expiration: Date;
+    auth_connection_token: string;
+    static init(sequelize: any): void;
+}

package/dist/database/models/WSAuth.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const sequelize_2 = require("sequelize");
+class WebSocketAuth extends sequelize_1.Model {
+    static init(sequelize) {
+        super.init({
+            token: sequelize_2.DataTypes.STRING,
+            expiration: sequelize_2.DataTypes.DATE,
+            user_id: sequelize_2.DataTypes.INTEGER,
+            is_active: sequelize_2.DataTypes.BOOLEAN,
+            auth_connection_token: sequelize_2.DataTypes.STRING,
+        }, {
+            sequelize: sequelize,
+            tableName: 'spc_wsauth'
+        });
+    }
+}
+exports.WebSocketAuth = WebSocketAuth;

package/dist/expressServer.d.ts

@@ -2,9 +2,11 @@ export default class ExpressServer {
     app: any;
     authBaseUrl: string;
     usePort: number;
+    wsAuthBaseUrl: string;
     constructor();
     listen(port?: any): void;
     initModules(): void;
     initAuthSystem(baseUrl?: string): void;
+    initWSAuthSystem(wsBaseUrl?: string): void;
     getApp(): any;
 }

package/dist/expressServer.js

@@ -8,10 +8,12 @@ const sessions_1 = require("./modules/sessions");
 const postreader_1 = require("./modules/postreader");
 const initcors_1 = require("./modules/initcors");
 const env_1 = __importDefault(require("./settings/env"));
-const auth_1 = __importDefault(require("./routes/auth"));
+const users_1 = __importDefault(require("./routes/users"));
+const wsauth_1 = require("./routes/wsauth");
 class ExpressServer {
     constructor() {
         this.authBaseUrl = "";
+        this.wsAuthBaseUrl = "";
         this.usePort = env_1.default.PORT;
         this.app = express_1.default();
         this.initModules();
@@ -28,7 +30,11 @@ class ExpressServer {
     }
     initAuthSystem(baseUrl = '/user') {
         this.authBaseUrl = baseUrl;
-        this.app.use(this.authBaseUrl, auth_1.default);
+        this.app.use(this.authBaseUrl, users_1.default);
+    }
+    initWSAuthSystem(wsBaseUrl = '/ws') {
+        this.wsAuthBaseUrl = wsBaseUrl;
+        this.app.use(this.wsAuthBaseUrl, wsauth_1.router);
     }
     getApp() {
         return this.app;

package/dist/routes/users.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/users.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const secureset_1 = require("../sessions/secureset");
+const config_1 = require("../auth/config");
+const response_1 = require("../utils/response");
+const auth_1 = require("../auth/auth");
+const meta_sanitizer_1 = __importDefault(require("meta-sanitizer"));
+const users_1 = require("../users/users");
+const users_2 = require("../users/users");
+var LoginErrorCode;
+(function (LoginErrorCode) {
+    LoginErrorCode[LoginErrorCode["NoError"] = 0] = "NoError";
+    LoginErrorCode[LoginErrorCode["InvalidParams"] = 1] = "InvalidParams";
+    LoginErrorCode[LoginErrorCode["InvalidPassword"] = 2] = "InvalidPassword";
+})(LoginErrorCode || (LoginErrorCode = {}));
+var RegisterUserErrorCode;
+(function (RegisterUserErrorCode) {
+    RegisterUserErrorCode[RegisterUserErrorCode["NoError"] = 0] = "NoError";
+    RegisterUserErrorCode[RegisterUserErrorCode["InvalidParams"] = 1] = "InvalidParams";
+    RegisterUserErrorCode[RegisterUserErrorCode["UserExist"] = 2] = "UserExist";
+    RegisterUserErrorCode[RegisterUserErrorCode["InternalError"] = 3] = "InternalError";
+})(RegisterUserErrorCode || (RegisterUserErrorCode = {}));
+const router = express_1.default.Router();
+router.post('/logout', (req, res) => {
+    let is_ok = false;
+    if (auth_1.userIsLogged(req)) {
+        secureset_1.deleteSessionValue(req, config_1.SESSION_LOGGED_DATA);
+        is_ok = true;
+    }
+    res.send(response_1.JSONResponse(is_ok, 0, is_ok ? "" : "User Must be logged", {}));
+});
+router.post('/login', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    let email = "";
+    let password = "";
+    try {
+        email = meta_sanitizer_1.default.sanitizeEmail(req.body.email);
+        password = meta_sanitizer_1.default.queryProtector(req.body.password);
+    }
+    catch (e) {
+        return res.send(response_1.JSONResponse(false, LoginErrorCode.InvalidParams, "Must have 'email' and 'password' params"));
+    }
+    if (password == "" || email == "")
+        return res.send(response_1.JSONResponse(false, LoginErrorCode.InvalidParams, "Must have 'email' and 'password' params"));
+    const checkPass = yield users_1.checkUserPassword(email, password);
+    if (checkPass) {
+        secureset_1.setSessionValue(req, config_1.SESSION_LOGGED_DATA, email);
+        return res.send(response_1.JSONResponse(true, LoginErrorCode.NoError, "Login Ok"));
+    }
+    return res.send(response_1.JSONResponse(false, LoginErrorCode.InvalidPassword, "Invalid Password"));
+}));
+router.post('/register', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let email = meta_sanitizer_1.default.sanitizeEmail(req.body.email || '');
+        let password = meta_sanitizer_1.default.queryProtector(req.body.password || '');
+        let name = meta_sanitizer_1.default.SanitizerEngine(req.body.name || '', true, false, [' ']).sanitizedData;
+        if (email == "" || password == "" || name == "")
+            return res.send(response_1.JSONResponse(false, RegisterUserErrorCode.InvalidParams, "Invalid params"));
+        yield users_2.createUser({ first_name: name, email: email, password_string: password });
+        return res.send(response_1.JSONResponse(true, RegisterUserErrorCode.NoError, "", "REGISTER OK"));
+    }
+    catch (e) {
+        if (e === "User exist")
+            return res.send(response_1.JSONResponse(false, RegisterUserErrorCode.UserExist, "User Exist"));
+        return res.send(response_1.JSONResponse(false, RegisterUserErrorCode.InternalError, "I-Error"));
+    }
+}));
+exports.default = router;

package/dist/routes/wsauth.d.ts

@@ -0,0 +1 @@
+export declare const router: import("express-serve-static-core").Router;

package/dist/routes/wsauth.js

@@ -0,0 +1,45 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const response_1 = require("../utils/response");
+const auth_1 = require("../auth/auth");
+const wsauth_1 = require("../wsauth/wsauth");
+const users_1 = require("../users/users");
+const server_1 = require("../server");
+const config_1 = require("../auth/config");
+exports.router = express_1.default.Router();
+var GenerateTokenError;
+(function (GenerateTokenError) {
+    GenerateTokenError[GenerateTokenError["UserMustBeLogged"] = 1] = "UserMustBeLogged";
+    GenerateTokenError[GenerateTokenError["GetUserError"] = 2] = "GetUserError";
+    GenerateTokenError[GenerateTokenError["InternalError"] = 3] = "InternalError";
+})(GenerateTokenError || (GenerateTokenError = {}));
+;
+exports.router.post('/gettoken', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!auth_1.userIsLogged(req))
+        return res.send(response_1.JSONResponse(false, GenerateTokenError.UserMustBeLogged, "User Must Be Logged"));
+    try {
+        let userId = yield users_1.getUserIdByUserEmail(server_1.getSessionValue(req, config_1.SESSION_LOGGED_DATA));
+        if (userId == NaN)
+            return res.send(response_1.JSONResponse(false, GenerateTokenError.GetUserError, "Get user error"));
+        let n = yield wsauth_1.setWSAuthDataNewToken(userId);
+        return res.send(response_1.JSONResponse(true, 0, "", { token: n.dataValues.token,
+            expiration: n.dataValues.expiration,
+            userId: userId
+        }));
+    }
+    catch (e) {
+    }
+}));

package/dist/server.d.ts

@@ -4,5 +4,9 @@ export { dataBase } from "./database/database";
 export { setSessionValue, deleteSessionValue } from "./sessions/secureset";
 export { getSessionValue } from "./sessions/secureget";
 export { checkUserPassword } from "./users/users";
+export { WebSocketAuth } from "./database/models/WSAuth";
+export { checkWSAuthToken, authenticateWS, checkConnectionAuth } from "./wsauth/wsauth";
+export { randomString } from "./utils/string/random";
+export { JSONResponse } from "./utils/response";
 import ExpressServer from "./expressServer";
 export default ExpressServer;

package/dist/server.js

@@ -17,5 +17,15 @@ var secureget_1 = require("./sessions/secureget");
 exports.getSessionValue = secureget_1.getSessionValue;
 var users_1 = require("./users/users");
 exports.checkUserPassword = users_1.checkUserPassword;
+var WSAuth_1 = require("./database/models/WSAuth");
+exports.WebSocketAuth = WSAuth_1.WebSocketAuth;
+var wsauth_1 = require("./wsauth/wsauth");
+exports.checkWSAuthToken = wsauth_1.checkWSAuthToken;
+exports.authenticateWS = wsauth_1.authenticateWS;
+exports.checkConnectionAuth = wsauth_1.checkConnectionAuth;
+var random_1 = require("./utils/string/random");
+exports.randomString = random_1.randomString;
+var response_1 = require("./utils/response");
+exports.JSONResponse = response_1.JSONResponse;
 const expressServer_1 = __importDefault(require("./expressServer"));
 exports.default = expressServer_1.default;

package/dist/users/password.d.ts

@@ -1,2 +1,3 @@
+import { PasswordVerifyResult } from './types';
 export declare function createArgon2Hash(password_string: string): Promise<string | false>;
-export declare function checkArgon2Password(password_hash: string, password_string: string): Promise<"Match" | "Dont Match">;
+export declare function checkArgon2Password(password_hash: string, password_string: string): Promise<PasswordVerifyResult>;

package/dist/users/users.d.ts

@@ -1,6 +1,7 @@
 import { UserCreateInterface } from "./types";
 export declare function getUserById(id: Number): Promise<any>;
 export declare function getUserByEmail(email: string): Promise<any>;
+export declare function getUserIdByUserEmail(email: string): Promise<number>;
 export declare function deleteUserById(id: Number): Promise<any>;
 export declare function isUserExist(email: string): Promise<boolean>;
 export declare function createUser(data: UserCreateInterface): Promise<any>;

package/dist/users/users.js

@@ -27,6 +27,20 @@ function getUserByEmail(email) {
     });
 }
 exports.getUserByEmail = getUserByEmail;
+function getUserIdByUserEmail(email) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let u = yield getUserByEmail(email);
+            if (!Boolean(u))
+                return NaN;
+            return u.dataValues.id;
+        }
+        catch (e) {
+            return NaN;
+        }
+    });
+}
+exports.getUserIdByUserEmail = getUserIdByUserEmail;
 function deleteUserById(id) {
     return __awaiter(this, void 0, void 0, function* () {
         let result = yield User_1.User.destroy({ where: { id: id.toString() } });

package/dist/utils/string/random.d.ts

@@ -0,0 +1 @@
+export declare function randomString(length: number): string;

package/dist/utils/string/random.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function randomString(length) {
+    var result = '';
+    var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    var charactersLength = characters.length;
+    for (var i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() *
+            charactersLength));
+    }
+    return result;
+}
+exports.randomString = randomString;

package/dist/wsauth/types.d.ts

@@ -0,0 +1,4 @@
+export declare enum AuthenticateWSResult {
+    OK = 1,
+    InvalidToken = 2
+}

package/dist/wsauth/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AuthenticateWSResult;
+(function (AuthenticateWSResult) {
+    AuthenticateWSResult[AuthenticateWSResult["OK"] = 1] = "OK";
+    AuthenticateWSResult[AuthenticateWSResult["InvalidToken"] = 2] = "InvalidToken";
+})(AuthenticateWSResult = exports.AuthenticateWSResult || (exports.AuthenticateWSResult = {}));

package/dist/wsauth/wsauth.d.ts

@@ -0,0 +1,6 @@
+import { AuthenticateWSResult } from "./types";
+export declare function getWSAuthDataByUserId(userId: number): Promise<any>;
+export declare function setWSAuthDataNewToken(userId: number, expiration_hours?: number): Promise<any>;
+export declare function checkWSAuthToken(userId: number, token: string): Promise<boolean>;
+export declare function authenticateWS(userId: number, token: string, connection_token: string): Promise<AuthenticateWSResult>;
+export declare function checkConnectionAuth(userId: number, connection_token: string): Promise<boolean>;

package/dist/wsauth/wsauth.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = require("../server");
+const server_2 = require("../server");
+const random_1 = require("./../utils/string/random");
+const types_1 = require("./types");
+server_1.WebSocketAuth.init(server_2.dataBase);
+function getWSAuthDataByUserId(userId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let u = yield server_1.WebSocketAuth.findOne({ where: { user_id: userId.toString() } });
+            return u;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.getWSAuthDataByUserId = getWSAuthDataByUserId;
+function setWSAuthDataNewToken(userId, expiration_hours = 72) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let ws = yield getWSAuthDataByUserId(userId);
+            let token = random_1.randomString(50);
+            let expiration = new Date();
+            expiration.setTime(expiration.getTime() + expiration_hours * 60 * 60 * 1000);
+            if (!Boolean(ws)) {
+                return yield server_1.WebSocketAuth.create({ user_id: userId.toString(),
+                    token: token,
+                    expiration: expiration,
+                    is_active: true,
+                    auth_connection_token: "",
+                });
+            }
+            else {
+                ws.token = token;
+                ws.expiration = expiration;
+                ws.is_active = true;
+                ws.auth_connection_token = "";
+                return yield ws.save();
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.setWSAuthDataNewToken = setWSAuthDataNewToken;
+function checkWSAuthToken(userId, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let ws = yield getWSAuthDataByUserId(userId);
+            if (!Boolean(ws))
+                return false;
+            if (!ws.dataValues.is_active)
+                return false;
+            if (ws.dataValues.token != token)
+                return false;
+            if (Date.now() > ws.dataValues.expiration.getTime())
+                return false;
+            return true;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.checkWSAuthToken = checkWSAuthToken;
+function authenticateWS(userId, token, connection_token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (!(yield checkWSAuthToken(userId, token)))
+                return types_1.AuthenticateWSResult.InvalidToken;
+            let ws = yield getWSAuthDataByUserId(userId);
+            ws.auth_connection_token = connection_token;
+            yield ws.save();
+            return types_1.AuthenticateWSResult.OK;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.authenticateWS = authenticateWS;
+function checkConnectionAuth(userId, connection_token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let ws = yield getWSAuthDataByUserId(userId);
+            if (!Boolean(ws))
+                return false;
+            if (!ws.dataValues.is_active)
+                return false;
+            if (Date.now() > ws.dataValues.expiration.getTime())
+                return false;
+            if (ws.dataValues.auth_connection_token !== connection_token)
+                return false;
+            return true;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.checkConnectionAuth = checkConnectionAuth;

package/migrations/20220320173911-serverpreconfigured-startwsauth.js

@@ -0,0 +1,50 @@
+'use strict';
+
+module.exports = {
+  async up (queryInterface, Sequelize) {
+     return await queryInterface.createTable('spc_wsauth', 
+     { id: {
+          type:Sequelize.INTEGER,
+          primaryKey:true,
+          autoIncrement:true,
+          allowNull:false 
+       } ,
+       user_id:{
+          type:Sequelize.INTEGER,
+          references:{model:'spc_users',key:'id'}
+       },
+       token:{
+         type:Sequelize.STRING,
+         allowNull:false,
+       },
+       expiration:{
+         type:Sequelize.DATE,
+         allowNull:false,
+       },
+       is_active:{
+         type:Sequelize.BOOLEAN,
+         allowNull:false,
+         defaultValue:true,
+       },
+       auth_connection_token:{
+         type:Sequelize.STRING,
+         allowNull:true,
+         defaultValue:"",
+       },
+       created_at:{
+        type:Sequelize.DATE,
+        allowNull:false,
+      },
+      updated_at:{
+        type:Sequelize.DATE,
+        allowNull:false,
+      },
+     }
+     
+     );
+  },
+
+  async down (queryInterface, Sequelize) {
+     return await queryInterface.dropTable('spc_wsauth');
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serverpreconfigured",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "\"Pre-configured server with authentication system and database integration\"",
   "main": "dist/server.js",
   "keywords": ["server","pre configured","database","authentication"],

package/src/database/models/WSAuth.ts

@@ -0,0 +1,19 @@
+import { Model } from "sequelize";
+import { DataTypes } from "sequelize";
+export class WebSocketAuth extends Model{
+    declare token:string;
+    declare expiration:Date;
+    declare auth_connection_token:string;
+    static init(sequelize:any){
+        super.init({
+          token:DataTypes.STRING,
+          expiration:DataTypes.DATE,
+          user_id:DataTypes.INTEGER, 
+          is_active:DataTypes.BOOLEAN,
+          auth_connection_token:DataTypes.STRING,
+        },{
+          sequelize:sequelize,
+          tableName:'spc_wsauth'
+        });
+    }
+} 

package/src/expressServer.ts

@@ -3,13 +3,16 @@ import { initSessions } from "./modules/sessions";
 import { initPostReader } from "./modules/postreader";
 import { initCors } from "./modules/initcors";
 import  ENV  from "./settings/env";
-import authRouter from "./routes/auth";
+import authRouter from "./routes/users";
+import { router as wsAuthRoter } from "./routes/wsauth";
 export default class ExpressServer{
     app:any;
     authBaseUrl:string;
     usePort:number;
+    wsAuthBaseUrl:string;
     constructor(){
        this.authBaseUrl="";
+       this.wsAuthBaseUrl="";
        this.usePort=ENV.PORT;
        this.app=express();
        this.initModules();
@@ -29,6 +32,10 @@ export default class ExpressServer{
        this.authBaseUrl=baseUrl;
        this.app.use(this.authBaseUrl,authRouter);
     }
+    initWSAuthSystem(wsBaseUrl:string='/ws'){
+       this.wsAuthBaseUrl=wsBaseUrl;
+       this.app.use(this.wsAuthBaseUrl,wsAuthRoter);
+    }
 
     getApp(){
       return this.app;

package/src/routes/{auth.ts → users.ts}

@@ -5,12 +5,19 @@ import { JSONResponse } from "../utils/response";
 import { userIsLogged } from "../auth/auth";
 import meta_sanitizer from 'meta-sanitizer';
 import { checkUserPassword } from "../users/users";
+import { createUser } from "../users/users";
 enum LoginErrorCode{
     NoError=0,
     InvalidParams,
     InvalidPassword,
 
 }
+enum RegisterUserErrorCode{
+   NoError=0,
+   InvalidParams,
+   UserExist,
+   InternalError
+}
 const router=express.Router();
 router.post('/logout',(req,res)=>{
    let is_ok=false;
@@ -38,5 +45,20 @@ router.post('/login',async (req,res)=>{
     }
     return res.send(JSONResponse(false,LoginErrorCode.InvalidPassword,"Invalid Password"));
 });
+router.post('/register',async (req,res)=>{
+    try{
+      let email=meta_sanitizer.sanitizeEmail(req.body.email||'');
+      let password=meta_sanitizer.queryProtector(req.body.password||'');
+      let name=meta_sanitizer.SanitizerEngine(req.body.name||'',true,false,[' ']).sanitizedData;
+      if(email=="" || password=="" || name=="")
+        return res.send(JSONResponse(false,RegisterUserErrorCode.InvalidParams,"Invalid params"));
+      await createUser({first_name:name,email:email,password_string:password});
+      return res.send(JSONResponse(true,RegisterUserErrorCode.NoError,"","REGISTER OK"));
+    }catch(e){
+       if(e==="User exist")
+         return res.send(JSONResponse(false,RegisterUserErrorCode.UserExist,"User Exist"));
+       return res.send(JSONResponse(false,RegisterUserErrorCode.InternalError,"I-Error"));  
+    }
+});
 
 export default router;

package/src/routes/wsauth.ts

@@ -0,0 +1,29 @@
+import  express  from "express";
+import { JSONResponse } from "../utils/response";
+import { userIsLogged } from "../auth/auth";
+import { setWSAuthDataNewToken } from "../wsauth/wsauth";
+import { getUserIdByUserEmail } from "../users/users";
+import { getSessionValue } from "../server";
+import { SESSION_LOGGED_DATA } from "../auth/config";
+export const router=express.Router();
+enum GenerateTokenError{
+   UserMustBeLogged=1,
+   GetUserError,
+   InternalError,
+};
+router.post('/gettoken',async (req,res)=>{
+   if(!userIsLogged(req))
+       return res.send(JSONResponse(false,GenerateTokenError.UserMustBeLogged,"User Must Be Logged"));
+   try{
+       let userId=await getUserIdByUserEmail(getSessionValue(req,SESSION_LOGGED_DATA));
+       if(userId==NaN)
+         return res.send(JSONResponse(false,GenerateTokenError.GetUserError,"Get user error"));
+       let n=await setWSAuthDataNewToken(userId);
+       return res.send(JSONResponse(true,0,"",{token:n.dataValues.token,
+                                               expiration:n.dataValues.expiration,
+                                               userId:userId
+                                               }));
+   }catch(e){
+
+   }
+});

package/src/server.ts

@@ -4,5 +4,9 @@ export { dataBase } from "./database/database";
 export { setSessionValue,deleteSessionValue } from "./sessions/secureset";
 export { getSessionValue } from "./sessions/secureget";
 export { checkUserPassword } from "./users/users";
+export { WebSocketAuth } from "./database/models/WSAuth";
+export { checkWSAuthToken ,authenticateWS,checkConnectionAuth} from "./wsauth/wsauth";
+export { randomString } from "./utils/string/random";
+export { JSONResponse } from "./utils/response";
 import ExpressServer from "./expressServer";
-export default ExpressServer;
+export default ExpressServer;

package/src/users/password.ts

@@ -9,7 +9,7 @@ export async function createArgon2Hash(password_string:string){
    }
 }
 
-export async function checkArgon2Password(password_hash:string,password_string:string){
+export async function checkArgon2Password(password_hash:string,password_string:string):Promise<PasswordVerifyResult>{
   try{
      if(await argon2.verify(password_hash,password_string))
         return "Match";

package/src/users/users.ts

@@ -12,6 +12,16 @@ export async function getUserByEmail(email:string){
      let result=await User.findOne({where:{email:email}});
      return (result);
 }
+export async function getUserIdByUserEmail(email:string):Promise<number>{
+     try{
+        let u=await getUserByEmail(email);
+        if(!Boolean(u))
+          return NaN;
+        return u.dataValues.id;
+     }catch(e){
+        return NaN;
+     }
+}
 
 export async function deleteUserById(id:Number){
      let result=await User.destroy({where:{id:id.toString()}});

package/src/utils/string/random.ts

@@ -0,0 +1,10 @@
+export function randomString(length:number):string {
+    var result           = '';
+    var characters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    var charactersLength = characters.length;
+    for ( var i = 0; i < length; i++ ) {
+      result += characters.charAt(Math.floor(Math.random() * 
+ charactersLength));
+   }
+   return result;
+}

package/src/wsauth/types.ts

@@ -0,0 +1,4 @@
+export enum AuthenticateWSResult{
+    OK=1,
+    InvalidToken,
+}

package/src/wsauth/wsauth.ts

@@ -0,0 +1,85 @@
+import { WebSocketAuth } from "../server";
+import { dataBase } from "../server";
+import {randomString} from "./../utils/string/random";
+import {AuthenticateWSResult} from "./types";
+WebSocketAuth.init(dataBase);
+export async function getWSAuthDataByUserId(userId:number):Promise<any>{
+   try{
+      let u=await WebSocketAuth.findOne({where:{user_id:userId.toString()}});
+      return u;
+   }catch(e){
+       throw e;
+   }
+}
+
+export async function setWSAuthDataNewToken(userId:number,expiration_hours:number=72){
+   try{
+      let ws=await getWSAuthDataByUserId(userId);
+      let token=randomString(50);
+      let expiration=new Date();
+      expiration.setTime(expiration.getTime()+expiration_hours*60*60*1000);
+      if(!Boolean(ws)){
+          return await WebSocketAuth.create({user_id:userId.toString(),
+                                             token:token,
+                                             expiration:expiration,
+                                             is_active:true,
+                                             auth_connection_token:"",
+                                             });
+      }else{
+         ws.token=token;
+         ws.expiration=expiration;
+         ws.is_active=true;
+         ws.auth_connection_token="";
+         return await ws.save();
+      }
+   }catch(e){
+       throw e;
+   }
+}
+
+export async function checkWSAuthToken(userId:number,token:string):Promise<boolean>{
+    try{
+       let ws=await getWSAuthDataByUserId(userId);
+       if(!Boolean(ws))
+         return false;
+       if(!ws.dataValues.is_active)
+         return false;  
+       if(ws.dataValues.token!=token)  
+          return false;
+       if(Date.now()>ws.dataValues.expiration.getTime())   
+          return false;
+       return true;   
+    }catch(e){
+       throw e;
+    }
+}
+
+export async function authenticateWS(userId:number,token:string,connection_token:string):Promise<AuthenticateWSResult>{
+    try{
+      if(!(await checkWSAuthToken(userId,token)))
+         return AuthenticateWSResult.InvalidToken; 
+      let ws=await getWSAuthDataByUserId(userId);  
+      ws.auth_connection_token=connection_token;
+      await ws.save();
+      return AuthenticateWSResult.OK;
+    }catch(e){
+       throw e;
+    } 
+}
+
+export async function checkConnectionAuth(userId:number,connection_token:string):Promise<boolean>{
+   try{
+     let ws=await getWSAuthDataByUserId(userId);
+     if(!Boolean(ws))
+        return false;
+     if(!ws.dataValues.is_active)
+        return false;
+     if(Date.now()>ws.dataValues.expiration.getTime())   
+        return false;   
+     if(ws.dataValues.auth_connection_token!==connection_token)
+        return false;   
+     return true;
+   }catch(e){
+      throw e;
+   }
+}