@photostructure/windows-registry 0.0.1

package/License.txt

@@ -0,0 +1,17 @@
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# @photostructure/windows-registry
+
+> **Fork of [@vscode/windows-registry](https://github.com/microsoft/vscode-windows-registry) with prebuilt binaries.**
+>
+> The upstream package requires a C++ build toolchain at install time. This fork
+> ships prebuilt NAPI binaries for `win32-x64` and `win32-arm64`, so no build
+> tools are needed on the target machine.
+
+Native node module to access the Windows Registry.
+
+## Installing
+
+```sh
+npm install @photostructure/windows-registry
+```
+
+## Using
+
+```javascript
+const { GetStringRegKey } = require('@photostructure/windows-registry');
+console.log(GetStringRegKey('HKEY_LOCAL_MACHINE', 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion', 'ProgramFilesPath'));
+```
+
+## Development
+
+```sh
+npm install
+npm run build:native  # builds the prebuilt binary
+npm test # builds if necessary, then runs tests
+```
+
+## License
+[MIT](https://github.com/photostructure/vscode-windows-registry/blob/main/License.txt)
+
+Upstream copyright Microsoft Corporation.
+

package/SECURITY.md

@@ -0,0 +1,41 @@
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.8 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc). 
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->

package/binding.gyp

@@ -0,0 +1,71 @@
+{
+  "targets": [
+    {
+      "target_name": "winregistry",
+      "conditions": [
+        ["OS=='win'", {
+          "sources": [
+            "src/winregistry.cc"
+          ],
+          "msvs_configuration_attributes": {
+            "SpectreMitigation": "Spectre"
+          },
+          "conditions": [
+            ["target_arch=='x64'", {
+              "defines": [
+                "_M_X64",
+                "_WIN64"
+              ],
+              "msvs_settings": {
+                "VCCLCompilerTool": {
+                  "AdditionalOptions": [
+                    "/Qspectre",
+                    "/guard:cf",
+                    "/sdl",
+                    "/W3",
+                    "/we4146",
+                    "/we4244",
+                    "/we4267",
+                    "/ZH:SHA_256"
+                  ]
+                },
+                "VCLinkerTool": {
+                  "AdditionalOptions": [
+                    "/DYNAMICBASE",
+                    "/guard:cf",
+                    "/CETCOMPAT"
+                  ]
+                }
+              }
+            }],
+            ["target_arch=='arm64'", {
+              "defines": [
+                "_M_ARM64",
+                "_WIN64"
+              ],
+              "msvs_settings": {
+                "VCCLCompilerTool": {
+                  "AdditionalOptions": [
+                    "/guard:cf",
+                    "/sdl",
+                    "/W3",
+                    "/we4146",
+                    "/we4244",
+                    "/we4267",
+                    "/ZH:SHA_256"
+                  ]
+                },
+                "VCLinkerTool": {
+                  "AdditionalOptions": [
+                    "/DYNAMICBASE",
+                    "/guard:cf"
+                  ]
+                }
+              }
+            }]
+          ]
+        }]
+      ]
+    }
+  ]
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type HKEY = "HKEY_CURRENT_USER" | "HKEY_LOCAL_MACHINE" | "HKEY_CLASSES_ROOT" | "HKEY_USERS" | "HKEY_CURRENT_CONFIG";
+export declare function GetStringRegKey(hive: HKEY, path: string, name: string): string | undefined;
+export declare function GetDWORDRegKey(hive: HKEY, path: string, name: string): number | undefined;

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetStringRegKey = GetStringRegKey;
+exports.GetDWORDRegKey = GetDWORDRegKey;
+const path_1 = require("path");
+// Use node-gyp-build to load the prebuilt native binary for the current
+// platform/arch. It checks prebuilds/ first, then falls back to build/Release/.
+// eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any
+const nodeGypBuild = require('node-gyp-build');
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const windowRegistry = process.platform === 'win32'
+    ? nodeGypBuild((0, path_1.join)(__dirname, '..'))
+    : null;
+function GetStringRegKey(hive, path, name) {
+    if (windowRegistry) {
+        return windowRegistry.GetStringRegKey(hive, path, name);
+    }
+    throw new Error('GetStringRegKey is only available on Windows.');
+}
+function GetDWORDRegKey(hive, path, name) {
+    if (windowRegistry) {
+        return windowRegistry.GetDWORDRegKey(hive, path, name);
+    }
+    throw new Error('GetDWORDRegKey is only available on Windows.');
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":";AAAA;;;gGAGgG;;AAehG,0CAMC;AAED,wCAMC;AA3BD,+BAA4B;AAE5B,wEAAwE;AACxE,gFAAgF;AAChF,qGAAqG;AACrG,MAAM,YAAY,GAAyB,OAAO,CAAC,gBAAgB,CAAC,CAAC;AACrE,8DAA8D;AAC9D,MAAM,cAAc,GAAQ,OAAO,CAAC,QAAQ,KAAK,OAAO;IACvD,CAAC,CAAC,YAAY,CAAC,IAAA,WAAI,EAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACrC,CAAC,CAAC,IAAI,CAAC;AAIR,SAAgB,eAAe,CAAC,IAAU,EAAE,IAAY,EAAE,IAAY;IACrE,IAAI,cAAc,EAAE,CAAC;QACpB,OAAO,cAAc,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACzD,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;AAClE,CAAC;AAED,SAAgB,cAAc,CAAC,IAAU,EAAE,IAAY,EAAE,IAAY;IACpE,IAAI,cAAc,EAAE,CAAC;QACpB,OAAO,cAAc,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACxD,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;AACjE,CAAC"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@photostructure/windows-registry",
+  "version": "0.0.1",
+  "description": "Native node module to access the Windows Registry, with prebuilts",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/photostructure/vscode-windows-registry.git"
+  },
+  "author": "Microsoft Corporation",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/photostructure/vscode-windows-registry/issues"
+  },
+  "homepage": "https://github.com/photostructure/vscode-windows-registry#readme",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "install": "node-gyp-build",
+    "compile": "tsc -p ./",
+    "prepare-release": "tsc -p ./",
+    "build:native": "tsx scripts/build-native.ts",
+    "test": "npm run build:native && npm run compile && mocha -r ts-node/register test/**/*.test.ts"
+  },
+  "dependencies": {
+    "node-gyp-build": "^4.8.4"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^25.3.0",
+    "mocha": "^11.7.5",
+    "node-gyp": "^12.2.0",
+    "prebuildify": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/scripts/build-native.ts

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * Cross-platform native build script that checks for existing builds before rebuilding.
+ * Adapted from @photostructure/node-sqlite.
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Check if a valid native module exists (>2kB — enough to confirm it's not
+ * an empty stub, but well under any real winregistry.node build output).
+ */
+function findValidNativeModule(dir: string): boolean {
+  if (!existsSync(dir)) return false;
+
+  try {
+    const files = readdirSync(dir, {
+      recursive: true,
+      encoding: "utf8",
+      withFileTypes: false,
+    });
+    for (const file of files) {
+      if (file.endsWith(".node")) {
+        const fullPath = join(dir, file as string);
+        const stats = statSync(fullPath);
+        if (stats.size > 2 * 1024) {
+          return true;
+        }
+      }
+    }
+  } catch {
+    // Directory might not exist or be accessible
+  }
+  return false;
+}
+
+// Check for existing builds
+if (findValidNativeModule("prebuilds")) {
+  console.log(
+    "Native module already built (found .node file > 2kB), skipping rebuild",
+  );
+  process.exit(0);
+}
+
+if (findValidNativeModule("build/Release")) {
+  console.log("Native module already built in build/Release, skipping rebuild");
+  process.exit(0);
+}
+
+// No existing build found, run prebuildify
+console.log("Building native module...");
+
+try {
+  // Extra args (e.g. --target, --arch) are forwarded to prebuildify for
+  // cross-compilation: `npm run build:native -- --arch arm64`
+  const args = process.argv.slice(2);
+  const prebuildifyArgs = [
+    "prebuildify",
+    "--napi",
+    "--tag-libc",
+    "--strip",
+    ...args,
+  ];
+
+  execFileSync("npx", prebuildifyArgs, {
+    stdio: "inherit",
+    shell: process.platform === "win32",
+  });
+
+  if (!findValidNativeModule("prebuilds")) {
+    console.error(
+      "Build failed: No valid native module found (expected .node file > 2kB)",
+    );
+    process.exit(1);
+  }
+
+  console.log("Native module built successfully");
+} catch (error) {
+  console.error("Build failed:", (error as Error).message);
+  process.exit(1);
+}

package/src/winregistry.cc

@@ -0,0 +1,215 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for
+ *license information.
+ *--------------------------------------------------------------------------------------------*/
+
+#include <string>
+#include <windows.h>
+
+#include <node_api.h>
+
+namespace {
+
+HKEY GetHive(std::string hkey) {
+  if (hkey == "HKEY_CURRENT_USER") {
+    return HKEY_CURRENT_USER;
+  }
+
+  if (hkey == "HKEY_LOCAL_MACHINE") {
+    return HKEY_LOCAL_MACHINE;
+  }
+
+  if (hkey == "HKEY_CLASSES_ROOT") {
+    return HKEY_CLASSES_ROOT;
+  }
+
+  if (hkey == "HKEY_USERS") {
+    return HKEY_USERS;
+  }
+
+  if (hkey == "HKEY_CURRENT_CONFIG") {
+    return HKEY_CURRENT_CONFIG;
+  }
+
+  return NULL;
+}
+
+napi_value GetStringRegKey(napi_env env, napi_callback_info info) {
+  napi_value argv[3];
+  size_t argc = 3;
+
+  napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
+
+  // Check that we have 3 arguments - Hive, Path, Name
+  if (argc < 3) {
+    napi_throw_error(env, "EINVAL", "Wrong number of arguments");
+    return nullptr;
+  }
+
+  // Retrieve the 3 arguments
+  for (int i = 0; i < 3; i++) {
+    napi_valuetype value_type;
+    napi_typeof(env, argv[i], &value_type);
+    if (value_type != napi_string) {
+      napi_throw_error(env, "EINVAL", "Expected string");
+      return nullptr;
+    }
+  }
+
+  size_t str_len = 0;
+  const int MAX_LEN = 16383;
+
+  napi_get_value_string_utf8(env, argv[0], nullptr, 0, &str_len);
+  if (str_len + 1 > MAX_LEN) {
+    napi_throw_error(env, "EINVAL", "Arguments too long");
+  }
+  std::string hive_arg;
+  hive_arg.reserve(str_len + 1);
+  hive_arg.resize(str_len);
+  napi_get_value_string_utf8(env, argv[0], &hive_arg[0], hive_arg.capacity(), nullptr);
+  HKEY hive = GetHive(hive_arg);
+
+  napi_get_value_string_utf8(env, argv[1], nullptr, 0, &str_len);
+  if (str_len + 1 > MAX_LEN) {
+    napi_throw_error(env, "EINVAL", "Arguments too long");
+  }
+  std::string path;
+  path.reserve(str_len + 1);
+  path.resize(str_len);
+  napi_get_value_string_utf8(env, argv[1], &path[0], path.capacity(), nullptr);
+
+  napi_get_value_string_utf8(env, argv[2], nullptr, 0, &str_len);
+  if (str_len + 1 > MAX_LEN) {
+    napi_throw_error(env, "EINVAL", "Arguments too long");
+  }
+  std::string name;
+  name.reserve(str_len + 1);
+  name.resize(str_len);
+  napi_get_value_string_utf8(env, argv[2], &name[0], name.capacity(), nullptr);
+  
+  if (hive == NULL) {
+    napi_throw_error(env, nullptr, "Unable to open registry hive");
+    return nullptr;
+  }
+
+  std::string result;
+  HKEY hKey;
+  if (ERROR_SUCCESS != RegOpenKeyEx(hive, path.c_str(), 0, KEY_READ, &hKey)) {
+    napi_throw_error(env, nullptr, "Unable to open registry key");
+    return nullptr;
+  }
+
+  char szBuffer[512];
+  DWORD dwBufferSize = sizeof(szBuffer);
+
+  if (ERROR_SUCCESS == RegQueryValueEx(hKey, name.c_str(), 0, NULL,
+                                       (LPBYTE)szBuffer, &dwBufferSize)) {
+    result = szBuffer;
+  }
+
+  RegCloseKey(hKey);
+
+  napi_value napi_result;
+  napi_create_string_utf8(env, result.c_str(), result.length(), &napi_result);
+
+  return napi_result;
+}
+
+napi_value GetDWORDRegKey(napi_env env, napi_callback_info info) {
+  napi_value argv[3];
+  size_t argc = 3;
+
+  napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
+
+  // Check that we have 3 arguments - Hive, Path, Name
+  if (argc < 3) {
+    napi_throw_error(env, "EINVAL", "Wrong number of arguments");
+    return nullptr;
+  }
+
+  // Retrieve the 3 arguments
+  for (int i = 0; i < 3; i++) {
+    napi_valuetype value_type;
+    napi_typeof(env, argv[i], &value_type);
+    if (value_type != napi_string) {
+      napi_throw_error(env, "EINVAL", "Expected string");
+      return nullptr;
+    }
+  }
+
+  size_t str_len = 0;
+  const int MAX_LEN = 16383;
+
+  napi_get_value_string_utf8(env, argv[0], nullptr, 0, &str_len);
+  if (str_len + 1 > MAX_LEN) {
+    napi_throw_error(env, "EINVAL", "Arguments too long");
+  }
+  std::string hive_arg;
+  hive_arg.reserve(str_len + 1);
+  hive_arg.resize(str_len);
+  napi_get_value_string_utf8(env, argv[0], &hive_arg[0], hive_arg.capacity(), nullptr);
+  HKEY hive = GetHive(hive_arg);
+
+  napi_get_value_string_utf8(env, argv[1], nullptr, 0, &str_len);
+  if (str_len + 1 > MAX_LEN) {
+    napi_throw_error(env, "EINVAL", "Arguments too long");
+  }
+  std::string path;
+  path.reserve(str_len + 1);
+  path.resize(str_len);
+  napi_get_value_string_utf8(env, argv[1], &path[0], path.capacity(), nullptr);
+
+  napi_get_value_string_utf8(env, argv[2], nullptr, 0, &str_len);
+  if (str_len + 1 > MAX_LEN) {
+    napi_throw_error(env, "EINVAL", "Arguments too long");
+  }
+  std::string name;
+  name.reserve(str_len + 1);
+  name.resize(str_len);
+  napi_get_value_string_utf8(env, argv[2], &name[0], name.capacity(), nullptr);
+
+  if (hive == NULL) {
+    napi_throw_error(env, nullptr, "Unable to open registry hive");
+    return nullptr;
+  }
+
+  HKEY hKey;
+  if (ERROR_SUCCESS != RegOpenKeyEx(hive, path.c_str(), 0, KEY_READ, &hKey)) {
+    napi_throw_error(env, nullptr, "Unable to open registry key");
+    return nullptr;
+  }
+
+  DWORD dwValue = 0;
+  DWORD dwBufferSize = sizeof(dwValue);
+  DWORD dwType = 0;
+  LONG result = RegQueryValueEx(hKey, name.c_str(), 0, &dwType,
+                                (LPBYTE)&dwValue, &dwBufferSize);
+  RegCloseKey(hKey);
+
+  if (result != ERROR_SUCCESS || dwType != REG_DWORD) {
+    return nullptr;
+  }
+
+  napi_value napi_result;
+  napi_create_uint32(env, dwValue, &napi_result);
+
+  return napi_result;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_value getStringRegKey;
+  napi_create_function(env, "GetStringRegKey", NAPI_AUTO_LENGTH,
+                       GetStringRegKey, NULL, &getStringRegKey);
+  napi_set_named_property(env, exports, "GetStringRegKey", getStringRegKey);
+
+  napi_value getDWORDRegKey;
+  napi_create_function(env, "GetDWORDRegKey", NAPI_AUTO_LENGTH,
+                       GetDWORDRegKey, NULL, &getDWORDRegKey);
+  napi_set_named_property(env, exports, "GetDWORDRegKey", getDWORDRegKey);
+
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init);
+} // namespace