@agilesoft/ags_authrest2 1.0.0

package/README.md

@@ -0,0 +1 @@
+This version has been deprecated

package/index.js

@@ -0,0 +1,331 @@
+// "use strict";
+const jwt = require("jsonwebtoken");
+const date = require("date-and-time");
+var CryptoJS = require("crypto-js");
+var crypto = require("crypto");
+const { v4: uuidv4 } = require("uuid");
+require("dotenv").config();
+var isBase64 = require("is-base64");
+// default env request_token
+// R_USER = `karan_ags_ci`;
+// R_PASS = `12345678`;
+
+var R_USER = process.env.R_USER || `karan_ags_ci`;
+var R_PASS = process.env.R_PASS || `12345678`;
+var R_PATH = process.env.R_PATH || `/request_token`;
+var R_TOKEN = process.env.SECERT_JWT || `12345678`;
+
+async function SECRET(secretOrKey) {
+  return new Promise(function (resolve, reject) {
+    var dateNow = new Date();
+    var DateString = dateNow.toUTCString();
+    var encrept = CryptoJS.HmacSHA256(
+      date.format(dateNow, "MM/DD"),
+      secretOrKey
+    ).toString();
+    return resolve(encrept);
+  });
+}
+
+var arr = [];
+
+function check(token) {
+  return new Promise(function (resolve, reject) {
+    for (let index = 0; index < arr.length; index++) {
+      const element = arr[index];
+      if (element == token) {
+        return resolve(true);
+      }
+    }
+    return resolve(false);
+  });
+}
+
+async function encrypt(secretRaw, decryptedMessage) {
+  return new Promise(function (resolve, reject) {
+    (async () => {
+      try {
+        var secret = await SECRET(secretRaw);
+        var cipher = crypto.createCipheriv(
+          "AES-256-CBC",
+          secret.substr(0, 32),
+          secret.substr(0, 16)
+        );
+        // console.log(`secert encryp is ${secret}`);
+        let encrypted = cipher.update(decryptedMessage, "utf8", "base64");
+        encrypted += cipher.final("base64");
+        return resolve(encrypted);
+      } catch (err) {
+        console.log("err");
+        console.log(err);
+        return reject(err);
+      }
+    })();
+  });
+}
+
+async function decrypt(encryptedMessage, secretOption) {
+  if (secretOption === "" || secretOption === undefined) {
+    secretOption = R_TOKEN;
+  }
+  return new Promise(function (resolve, reject) {
+    (async () => {
+      try {
+        var secret = await SECRET(secretOption);
+        var decipher = crypto.createDecipheriv(
+          "AES-256-CBC",
+          secret.substr(0, 32),
+          secret.substr(0, 16)
+        );
+        // console.log(`secert decipher is ${secret}`);
+        let decrypted = decipher.update(encryptedMessage, "base64", "utf8");
+        return resolve(decrypted + decipher.final("utf8"));
+      } catch (err) {
+        console.log("err");
+        console.log(err);
+        return reject(err);
+      }
+    })();
+  });
+}
+
+class Auth {
+  constructor() {}
+
+  Middleware(req, res, next) {
+    (async () => {
+      var headersEncrypter = false;
+      var bodyOriginal = req.body;
+      if (req.headers.authorization) {
+        let findSecurity = req.headers.authorization.indexOf("securityAgs");
+        if (findSecurity == -1) {
+          const isb64 = isBase64(bodyOriginal.encrypData);
+          if (isb64) {
+            req.headers.authorization = await decrypt(
+              req.headers.authorization
+            );
+            headersEncrypter = true;
+          }
+        } else {
+          const replaceStr = req.headers.authorization.replace(
+            /securityAgs/g,
+            "/"
+          );
+          const isb64 = isBase64(bodyOriginal.encrypData);
+          // console.log(isb64);
+          // console.log("decrypt header");
+          if (isb64) {
+            req.headers.authorization = await decrypt(replaceStr);
+            headersEncrypter = true;
+          }
+        }
+        jwt.verify(
+          req.headers.authorization,
+          await SECRET(R_TOKEN),
+          (err, payload) => {
+            (async () => {
+              if (err) {
+                console.log(err);
+                return res.sendStatus(400);
+              } else {
+                var isExpiredToken = false;
+
+                var dateNow = new Date();
+
+                if (payload.exp < dateNow.getTime()) {
+                  isExpiredToken = true;
+                }
+                if (payload.sub === R_USER && isExpiredToken === false) {
+                  const chk = await check(req.headers.authorization);
+                  // console.log(chk);
+                  arr.push(req.headers.authorization);
+                  if (
+                    chk == true &&
+                    req.headers.testdev !== true &&
+                    req.headers.testdev !== "true"
+                  ) {
+                    return res.send("duplicate token");
+                  }
+                  if (arr.length > 200) {
+                    arr = [];
+                  }
+                  // console.log(`headersEncrypter ${headersEncrypter}`);
+                  if (headersEncrypter === true) {
+                    if (bodyOriginal.encrypData) {
+                      const isb64 = isBase64(bodyOriginal.encrypData);
+                      if (isb64) {
+                        const result = await decrypt(bodyOriginal.encrypData);
+                        try {
+                          req.body = JSON.parse(result);
+                          next();
+                        } catch (error) {
+                          req.body = error;
+                          next();
+                        }
+                      } else {
+                        req.body = { result: `isb64 false` };
+                        next();
+                      }
+                    } else {
+                      req.body = { result: "no encrypData" };
+                      next();
+                    }
+                  } else {
+                    next();
+                  }
+                } else {
+                  return res.sendStatus(400);
+                }
+              }
+            })();
+          }
+        );
+      } else {
+        // console.log("bypass");
+        // next();
+        return res.sendStatus(400);
+      }
+    })();
+  }
+
+  RequestToken(req, res, next) {
+    // console.log(req.body.username, req.body.password, req.path);
+    // console.log(R_USER, R_PASS, R_PATH);
+    if (
+      req.body.username === R_USER &&
+      req.body.password === R_PASS &&
+      (req.path === R_PATH || req.path === `/${R_PATH}`)
+    ) {
+      (async () => {
+        const payload = {
+          sub: R_USER,
+          iat: new Date().getTime(),
+        };
+        res.send(
+          jwt.sign(payload, await SECRET(R_TOKEN), {
+            expiresIn: "1d",
+            jwtid: uuidv4(),
+          })
+        );
+      })();
+    } else {
+      next();
+    }
+  }
+
+  GenToken(secret, user) {
+    if (secret === "" || secret === undefined) {
+      secret = R_TOKEN;
+    }
+    if (user === "" || user === undefined) {
+      user = R_USER;
+    }
+
+    return new Promise(function (resolve, reject) {
+      (async () => {
+        try {
+          const payload = {
+            sub: user,
+            iat: new Date().getTime(),
+          };
+          return resolve(
+            jwt.sign(payload, await SECRET(secret), {
+              expiresIn: "1d",
+              jwtid: "uuidv4()",
+            })
+          );
+        } catch (error) {
+          reject(error);
+        }
+      })();
+    });
+  }
+
+  genTokenEncryp(secret, user) {
+    if (secret === "" || secret === undefined) {
+      secret = R_TOKEN;
+    }
+    if (user === "" || user === undefined) {
+      user = R_USER;
+    }
+
+    return new Promise(function (resolve, reject) {
+      (async () => {
+        try {
+          const payload = {
+            sub: user,
+            iat: new Date().getTime(),
+          };
+          const token = jwt.sign(payload, await SECRET(secret), {
+            expiresIn: "1d",
+            jwtid: uuidv4(),
+          });
+          // console.log(secret);
+          const encryp = await encrypt(secret, token);
+
+          return resolve(encryp.replace(/\//g, "securityAgs"));
+        } catch (error) {
+          reject(error);
+        }
+      })();
+    });
+  }
+
+  encrypbody(body, secret) {
+    if (secret === "" || secret === undefined) {
+      secret = R_TOKEN;
+    }
+
+    return new Promise(function (resolve, reject) {
+      (async () => {
+        try {
+          const encryp = await encrypt(secret, JSON.stringify(body));
+          const result = { encrypData: encryp };
+          return resolve(result);
+        } catch (error) {
+          console.log(error);
+          reject(error);
+        }
+      })();
+    });
+  }
+
+  // decrypbody(body, secret) {
+  //   if (secret === "" || secret === undefined) {
+  //     secret = R_TOKEN;
+  //   }
+
+  //   return new Promise(function (resolve, reject) {
+  //     (async () => {
+  //       try {
+  //         const result = await decrypt(body, secret);
+  //         return resolve(result);
+  //       } catch (error) {
+  //         console.log(error);
+  //         reject(error);
+  //       }
+  //     })();
+  //   });
+  // }
+
+  test(secret) {
+    if (secret === "" || secret === undefined) {
+      secret = R_TOKEN;
+    }
+    return new Promise(function (resolve, reject) {
+      (async () => {
+        try {
+          const encryp2 = await encrypt(R_TOKEN, "test");
+          console.log(encryp2);
+          const decrypt2 = await decrypt(encryp2);
+          console.log(decrypt2);
+          return resolve(decrypt2);
+        } catch (error) {
+          console.log(error);
+          reject(error);
+        }
+      })();
+    });
+  }
+}
+module.exports = Auth;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@agilesoft/ags_authrest2",
+  "version": "1.0.0",
+  "description": "This version has been deprecated",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "crypto-js": "4.1.1",
+    "date-and-time": "2.1.0",
+    "dotenv": "^16.0.0",
+    "is-base64": "^1.1.0",
+    "jsonwebtoken": "8.5.1",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AGScorp/ags_authrest.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AGScorp/ags_authrest/issues"
+  },
+  "homepage": "https://github.com/AGScorp/ags_authrest#readme"
+}