manageos 2.3.1 → 2.3.4

package/packages/windows/src/PsExec/psgetsid.ts

@@ -0,0 +1,111 @@
+import { spawn, spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const ARCH = process.arch;
+const PSGETSID_PATH = path.join(
+  __dirname,
+  "dependencies",
+  ARCH === "x64" ? "PsGetSid64.exe" : "PsGetSid.exe"
+);
+
+export type PsGetSidOptions = {
+  computer?: string; // \\computer[,computer,...] o @file
+  user?: string; // -u username
+  password?: string; // -p password
+  account?: string; // account para ver SID
+  windowsHide?: boolean;
+  timeout?: number;
+};
+
+class Async {
+  static run(
+    options?: PsGetSidOptions
+  ): Promise<{ stdout: string; stderr: string }> {
+    return new Promise((resolve, reject) => {
+      try {
+        const args = Async.buildArgs(options);
+
+        const child = spawn(PSGETSID_PATH, args, {
+          shell: true,
+          windowsHide: options?.windowsHide ?? true,
+        });
+
+        let stdout = "";
+        let stderr = "";
+
+        child.stdout.on("data", (data) => (stdout += data.toString()));
+        child.stderr.on("data", (data) => (stderr += data.toString()));
+
+        if (options?.timeout) {
+          setTimeout(() => {
+            child.kill();
+            reject(new Error("PsGetSid timeout reached"));
+          }, options.timeout * 1000);
+        }
+
+        child.on("close", (code) => {
+          if (code === 0) resolve({ stdout, stderr });
+          else reject(new Error(stderr || `PsGetSid exited with code ${code}`));
+        });
+
+        child.on("error", reject);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  private static buildArgs(options?: PsGetSidOptions): string[] {
+    const args: string[] = [];
+
+    if (options?.computer) args.push(options.computer);
+    if (options?.user) args.push("-u", options.user);
+    if (options?.password) args.push("-p", options.password);
+    if (options?.account) args.push(options.account);
+
+    return args;
+  }
+}
+
+class Sync {
+  static run(options?: PsGetSidOptions): {
+    stdout: string;
+    stderr: string;
+    status: number | null;
+  } {
+    const args = Sync.buildArgs(options);
+
+    const child = spawnSync(PSGETSID_PATH, args, {
+      shell: true,
+      stdio: "pipe",
+      windowsHide: options?.windowsHide ?? true,
+      timeout: options?.timeout ? options.timeout * 1000 : undefined,
+    });
+
+    return {
+      stdout: child.stdout?.toString() || "",
+      stderr: child.stderr?.toString() || "",
+      status: child.status,
+    };
+  }
+
+  private static buildArgs(options?: PsGetSidOptions): string[] {
+    const args: string[] = [];
+
+    if (options?.computer) args.push(options.computer);
+    if (options?.user) args.push("-u", options.user);
+    if (options?.password) args.push("-p", options.password);
+    if (options?.account) args.push(options.account);
+
+    return args;
+  }
+}
+
+export default class PsGetSid {
+  public static readonly Async = Async;
+  public static readonly Sync = Sync;
+}

package/packages/windows/src/PsExec/psinfo.ts

@@ -0,0 +1,123 @@
+import { spawn, spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const ARCH = process.arch;
+const PSINFO_PATH = path.join(
+  __dirname,
+  "dependencies",
+  ARCH === "x64" ? "PsInfo64.exe" : "PsInfo.exe"
+);
+
+export type PsInfoOptions = {
+  computer?: string; // \\computer[,computer,...] o @file
+  user?: string; // -u username
+  password?: string; // -p password
+  showHotfixes?: boolean; // -h
+  showSoftware?: boolean; // -s
+  showDisk?: boolean; // -d
+  csv?: boolean; // -c
+  delimiter?: string; // -t
+  windowsHide?: boolean;
+  timeout?: number;
+};
+
+class Async {
+  static run(
+    options?: PsInfoOptions
+  ): Promise<{ stdout: string; stderr: string }> {
+    return new Promise((resolve, reject) => {
+      try {
+        const args = Async.buildArgs(options);
+
+        const child = spawn(PSINFO_PATH, args, {
+          shell: true,
+          windowsHide: options?.windowsHide ?? true,
+        });
+
+        let stdout = "";
+        let stderr = "";
+
+        child.stdout.on("data", (data) => (stdout += data.toString()));
+        child.stderr.on("data", (data) => (stderr += data.toString()));
+
+        if (options?.timeout) {
+          setTimeout(() => {
+            child.kill();
+            reject(new Error("PsInfo timeout reached"));
+          }, options.timeout * 1000);
+        }
+
+        child.on("close", (code) => {
+          if (code === 0) resolve({ stdout, stderr });
+          else reject(new Error(stderr || `PsInfo exited with code ${code}`));
+        });
+
+        child.on("error", reject);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  private static buildArgs(options?: PsInfoOptions): string[] {
+    const args: string[] = [];
+
+    if (options?.computer) args.push(options.computer);
+    if (options?.user) args.push("-u", options.user);
+    if (options?.password) args.push("-p", options.password);
+    if (options?.showHotfixes) args.push("-h");
+    if (options?.showSoftware) args.push("-s");
+    if (options?.showDisk) args.push("-d");
+    if (options?.csv) args.push("-c");
+    if (options?.delimiter) args.push("-t", options.delimiter);
+
+    return args;
+  }
+}
+
+class Sync {
+  static run(options?: PsInfoOptions): {
+    stdout: string;
+    stderr: string;
+    status: number | null;
+  } {
+    const args = Sync.buildArgs(options);
+
+    const child = spawnSync(PSINFO_PATH, args, {
+      shell: true,
+      stdio: "pipe",
+      windowsHide: options?.windowsHide ?? true,
+      timeout: options?.timeout ? options.timeout * 1000 : undefined,
+    });
+
+    return {
+      stdout: child.stdout?.toString() || "",
+      stderr: child.stderr?.toString() || "",
+      status: child.status,
+    };
+  }
+
+  private static buildArgs(options?: PsInfoOptions): string[] {
+    const args: string[] = [];
+
+    if (options?.computer) args.push(options.computer);
+    if (options?.user) args.push("-u", options.user);
+    if (options?.password) args.push("-p", options.password);
+    if (options?.showHotfixes) args.push("-h");
+    if (options?.showSoftware) args.push("-s");
+    if (options?.showDisk) args.push("-d");
+    if (options?.csv) args.push("-c");
+    if (options?.delimiter) args.push("-t", options.delimiter);
+
+    return args;
+  }
+}
+
+export default class PsInfo {
+  public static readonly Async = Async;
+  public static readonly Sync = Sync;
+}

package/packages/windows/src/Server/FTP.ts

@@ -0,0 +1,165 @@
+import FtpServer, { FtpServerOptions } from "ftp-srv";
+
+export interface FTPOptions {
+  url?: string;
+  port?: number;
+  host?: string;
+  folder: string;
+  username?: string; // Usuario por defecto
+  password?: string; // Contraseña por defecto
+  pasvUrl?: string; // URL para conexiones pasivas
+  anonymous?: boolean; // Permitir login anónimo
+
+  // Callbacks personalizables
+  onLogin?: (username: string, password: string) => boolean | Promise<boolean>;
+  onStart?: (server: FtpServer) => void;
+  onError?: (error: Error) => void;
+  onConnection?: (username: string, address: string) => void;
+
+  // Opciones de configuración FTP extra
+  ftpOptions?: Partial<FtpServerOptions>;
+}
+
+// Definimos LoginDetails manualmente
+interface LoginDetails {
+  username: string;
+  password: string;
+}
+
+class Async {
+  static start(options: FTPOptions): Promise<FtpServer> {
+    return new Promise((resolve, reject) => {
+      try {
+        const url =
+          options.url ??
+          `ftp://${options.host ?? "0.0.0.0"}:${options.port ?? 21}`;
+
+        const server = new FtpServer({
+          url,
+          anonymous: options.anonymous ?? false,
+          pasv_url: options.pasvUrl ?? options.host ?? "127.0.0.1",
+          ...options.ftpOptions,
+        });
+
+        server.on(
+          "login",
+          async (data: LoginDetails, resolveLogin, rejectLogin) => {
+            try {
+              let authorized = false;
+
+              if (typeof options.onLogin === "function") {
+                authorized = await options.onLogin(
+                  data.username,
+                  data.password
+                );
+              } else {
+                authorized =
+                  data.username === options.username &&
+                  data.password === options.password;
+              }
+
+              if (authorized) {
+                resolveLogin({ root: options.folder });
+              } else {
+                rejectLogin(new Error("Invalid credentials"));
+              }
+            } catch (err) {
+              rejectLogin(err as Error);
+            }
+          }
+        );
+
+        server.on("login", (connection) => {
+          if (options.onConnection) {
+            options.onConnection(
+              connection.username ?? "unknown",
+              connection.connection.ip
+            );
+          }
+        });
+
+        server
+          .listen()
+          .then(() => {
+            if (options.onStart) options.onStart(server);
+            resolve(server);
+          })
+          .catch((err: any) => {
+            if (options.onError) options.onError(err);
+            reject(err);
+          });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+}
+
+class Sync {
+  static start(options: FTPOptions): FtpServer | null {
+    try {
+      const url =
+        options.url ??
+        `ftp://${options.host ?? "0.0.0.0"}:${options.port ?? 21}`;
+
+      const server = new FtpServer({
+        url,
+        anonymous: options.anonymous ?? false,
+        pasv_url: options.pasvUrl ?? options.host ?? "127.0.0.1",
+        ...options.ftpOptions,
+      });
+
+      server.on(
+        "login",
+        async (data: LoginDetails, resolveLogin, rejectLogin) => {
+          try {
+            let authorized = false;
+
+            if (typeof options.onLogin === "function") {
+              authorized = await options.onLogin(data.username, data.password);
+            } else {
+              authorized =
+                data.username === options.username &&
+                data.password === options.password;
+            }
+
+            if (authorized) {
+              resolveLogin({ root: options.folder });
+            } else {
+              rejectLogin(new Error("Invalid credentials"));
+            }
+          } catch (err) {
+            rejectLogin(err as Error);
+          }
+        }
+      );
+
+      server.on("login", (connection) => {
+        if (options.onConnection) {
+          options.onConnection(
+            connection.username ?? "unknown",
+            connection.connection.ip
+          );
+        }
+      });
+
+      server
+        .listen()
+        .then(() => {
+          if (options.onStart) options.onStart(server);
+        })
+        .catch((err: any) => {
+          if (options.onError) options.onError(err);
+        });
+
+      return server;
+    } catch {
+      return null;
+    }
+  }
+}
+
+export default class FTP {
+  public static readonly Async = Async;
+  public static readonly Sync = Sync;
+}

package/packages/windows/src/Server/HTTP/http.c

@@ -0,0 +1,226 @@
+#include <winsock2.h>
+#include <windows.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <dirent.h>
+
+#pragma comment(lib, "ws2_32.lib")
+
+#define BUF_SIZE 8192
+
+typedef struct
+{
+    int port;
+    char folder[MAX_PATH];
+    char **blocked_ext;
+    int blocked_count;
+} ServerConfig;
+
+ServerConfig config;
+
+void send_response(SOCKET client, const char *content, const char *type, int length)
+{
+    char header[BUF_SIZE];
+    snprintf(header, sizeof(header),
+             "HTTP/1.1 200 OK\r\n"
+             "Content-Type: %s\r\n"
+             "Content-Length: %d\r\n"
+             "Connection: close\r\n"
+             "\r\n",
+             type, length);
+    send(client, header, (int)strlen(header), 0);
+    send(client, content, length, 0);
+}
+
+void send_error(SOCKET client, int code)
+{
+    char resp[64];
+    snprintf(resp, sizeof(resp), "{\"status\":false,\"code\":%d}", code);
+    send_response(client, resp, "application/json", (int)strlen(resp));
+}
+
+int has_blocked_extension(const char *filename)
+{
+    if (config.blocked_count == 0)
+        return 0;
+    const char *ext = strrchr(filename, '.');
+    if (!ext)
+        return 0;
+    for (int i = 0; i < config.blocked_count; i++)
+    {
+        if (_stricmp(ext, config.blocked_ext[i]) == 0)
+            return 1;
+    }
+    return 0;
+}
+
+void list_folder(const char *path, char *output, size_t size)
+{
+    DIR *dir;
+    struct dirent *entry;
+    int first = 1;
+    snprintf(output, size, "{\"status\":true,\"data\":[");
+    dir = opendir(path);
+    if (!dir)
+    {
+        snprintf(output, size, "{\"status\":false,\"data\":[]}");
+        return;
+    }
+    while ((entry = readdir(dir)) != NULL)
+    {
+        if (entry->d_type != DT_REG && entry->d_type != DT_DIR)
+            continue;
+        if (has_blocked_extension(entry->d_name))
+            continue;
+        if (!first)
+            strncat(output, ",", size - strlen(output) - 1);
+        strncat(output, "\"", size - strlen(output) - 1);
+        strncat(output, entry->d_name, size - strlen(output) - 1);
+        strncat(output, "\"", size - strlen(output) - 1);
+        first = 0;
+    }
+    closedir(dir);
+    strncat(output, "]}", size - strlen(output) - 1);
+}
+
+const char *get_content_type(const char *filename)
+{
+    const char *ext = strrchr(filename, '.');
+    if (!ext)
+        return "application/octet-stream";
+
+    if (_stricmp(ext, ".html") == 0)
+        return "text/html";
+    if (_stricmp(ext, ".css") == 0)
+        return "text/css";
+    if (_stricmp(ext, ".js") == 0)
+        return "application/javascript";
+    if (_stricmp(ext, ".json") == 0)
+        return "application/json";
+    if (_stricmp(ext, ".png") == 0)
+        return "image/png";
+    if (_stricmp(ext, ".jpg") == 0 || _stricmp(ext, ".jpeg") == 0)
+        return "image/jpeg";
+    if (_stricmp(ext, ".gif") == 0)
+        return "image/gif";
+    return "application/octet-stream";
+}
+
+void send_file(SOCKET client, const char *filepath)
+{
+    FILE *f = fopen(filepath, "rb");
+    if (!f)
+    {
+        send_error(client, 404);
+        return;
+    }
+
+    fseek(f, 0, SEEK_END);
+    long length = ftell(f);
+    rewind(f);
+
+    char *buffer = malloc(length);
+    if (!buffer)
+    {
+        fclose(f);
+        send_error(client, 500);
+        return;
+    }
+
+    fread(buffer, 1, length, f);
+    fclose(f);
+
+    const char *type = get_content_type(filepath);
+    send_response(client, buffer, type, (int)length);
+
+    free(buffer);
+}
+
+int start_server()
+{
+    WSADATA w;
+    SOCKET server, client;
+    struct sockaddr_in addr, caddr;
+    int addrlen = sizeof(caddr);
+
+    if (WSAStartup(MAKEWORD(2, 2), &w))
+        return 0;
+
+    server = socket(AF_INET, SOCK_STREAM, 0);
+    if (server == INVALID_SOCKET)
+        return 0;
+
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = INADDR_ANY;
+    addr.sin_port = htons(config.port);
+
+    if (bind(server, (struct sockaddr *)&addr, sizeof(addr)))
+        return 0;
+    if (listen(server, 5))
+        return 0;
+
+    while ((client = accept(server, (struct sockaddr *)&caddr, &addrlen)) != INVALID_SOCKET)
+    {
+        char req[BUF_SIZE];
+        int r = recv(client, req, BUF_SIZE - 1, 0);
+        if (r > 0)
+            req[r] = 0;
+
+        char method[8], path[512];
+        sscanf(req, "%s %s", method, path);
+
+        if (path[0] == '/')
+            memmove(path, path + 1, strlen(path));
+
+        char full_path[MAX_PATH];
+        snprintf(full_path, sizeof(full_path), "%s\\%s", config.folder, path);
+
+        if (strlen(path) == 0 || path[strlen(path) - 1] == '\\')
+        {
+            char json[BUF_SIZE];
+            list_folder(config.folder, json, sizeof(json));
+            send_response(client, json, "application/json", (int)strlen(json));
+        }
+        else
+        {
+            if (has_blocked_extension(path))
+            {
+                send_error(client, 403);
+            }
+            else
+            {
+                send_file(client, full_path);
+            }
+        }
+        closesocket(client);
+    }
+
+    closesocket(server);
+    WSACleanup();
+    return 1;
+}
+
+int main(int argc, char *argv[])
+{
+    if (argc < 3)
+        return 0;
+
+    config.port = atoi(argv[1]);
+    strncpy(config.folder, argv[2], sizeof(config.folder) - 1);
+
+    // blocked extensions
+    config.blocked_count = argc - 3;
+    config.blocked_ext = &argv[3];
+
+    if (start_server())
+    {
+        printf("{\"status\":true}\n");
+        return 0;
+    }
+    else
+    {
+        printf("{\"status\":false}\n");
+        return 1;
+    }
+}

package/packages/windows/src/Server/HTTP/index.ts

@@ -0,0 +1,51 @@
+import { exec, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const serverExe = path.join(__dirname, "http.exe");
+
+function parseJSON(stdout: string) {
+  try {
+    return JSON.parse(stdout);
+  } catch (e) {}
+}
+
+interface ServerOptions {
+  port: number;
+  folder: string;
+  blockedExt?: string[];
+}
+
+class Async {
+  static start(options: ServerOptions): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      const args = [options.port, options.folder, ...(options.blockedExt || [])]
+        .map((a) => `"${a}"`)
+        .join(" ");
+      exec(`"${serverExe}" ${args}`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.status || false);
+      });
+    });
+  }
+}
+
+class Sync {
+  static start(options: ServerOptions): boolean {
+    const args = [options.port, options.folder, ...(options.blockedExt || [])]
+      .map((a) => `"${a}"`)
+      .join(" ");
+    const stdout = execSync(`"${serverExe}" ${args}`).toString();
+    const result = parseJSON(stdout);
+    return result.status || false;
+  }
+}
+
+export default class HTTP {
+  public static readonly Async = Async;
+  public static readonly Sync = Sync;
+}

package/packages/windows/src/Server/index.ts

@@ -0,0 +1,7 @@
+import HTTP from "./HTTP";
+import FTP from "./FTP";
+
+export default class Server {
+  public static readonly HTTP = HTTP;
+  public static readonly FTP = FTP;
+}