@bom-pi/core 0.2.1 → 0.2.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +2 -1
- package/src/connector-store.ts +12 -6
- package/src/pairing-storage.ts +30 -10
- package/src/windows-native.ps1 +326 -0
- package/src/windows-native.ts +453 -0
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@bom-pi/core",
|
|
3
|
-
"version": "0.2.
|
|
3
|
+
"version": "0.2.2",
|
|
4
4
|
"description": "Core pairing machinery for Bom Pi: ceremonies, transports, durable stores",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"license": "MIT",
|
|
@@ -15,6 +15,7 @@
|
|
|
15
15
|
"./ingress-receiver.ts": "./src/ingress-receiver.ts",
|
|
16
16
|
"./lan-pairing.ts": "./src/lan-pairing.ts",
|
|
17
17
|
"./pairing-storage.ts": "./src/pairing-storage.ts",
|
|
18
|
+
"./windows-native.ts": "./src/windows-native.ts",
|
|
18
19
|
"./relay-boundary.ts": "./src/relay-boundary.ts",
|
|
19
20
|
"./relay-mux-wire.ts": "./src/relay-mux-wire.ts",
|
|
20
21
|
"./relay-remote-channel.ts": "./src/relay-remote-channel.ts",
|
package/src/connector-store.ts
CHANGED
|
@@ -10,12 +10,12 @@ import {
|
|
|
10
10
|
mkdir,
|
|
11
11
|
open,
|
|
12
12
|
readFile,
|
|
13
|
-
rename,
|
|
14
13
|
rm,
|
|
15
14
|
unlink,
|
|
16
15
|
type FileHandle,
|
|
17
16
|
} from "node:fs/promises";
|
|
18
17
|
import { dirname, join } from "node:path";
|
|
18
|
+
import { assertWindowsPrivatePath, durableRename } from "./windows-native.ts";
|
|
19
19
|
import {
|
|
20
20
|
CLEANUP_RESERVE,
|
|
21
21
|
type ConnectorSnapshot,
|
|
@@ -288,7 +288,9 @@ function parseRecord(text: string, pinned: PinnedIdentity): ConnectorSnapshot {
|
|
|
288
288
|
return { ...snapshot, pinnedCloudPublicSpki: snapshot.pinnedCloudPublicSpki ?? null };
|
|
289
289
|
}
|
|
290
290
|
|
|
291
|
-
function assertRecordFile(stat: Stats): void {
|
|
291
|
+
async function assertRecordFile(stat: Stats, path: string): Promise<void> {
|
|
292
|
+
await assertWindowsPrivatePath(path, "file");
|
|
293
|
+
|
|
292
294
|
if (
|
|
293
295
|
!stat.isFile() ||
|
|
294
296
|
!privateMode(stat, 0o600) ||
|
|
@@ -302,6 +304,8 @@ function assertRecordFile(stat: Stats): void {
|
|
|
302
304
|
async function checkDirectory(directory: string): Promise<void> {
|
|
303
305
|
const stat = await lstat(directory).catch(() => fail("missing store directory"));
|
|
304
306
|
|
|
307
|
+
await assertWindowsPrivatePath(directory, "directory");
|
|
308
|
+
|
|
305
309
|
if (!stat.isDirectory() || !privateMode(stat, 0o700)) {
|
|
306
310
|
fail("store directory must be private (0700) and not a symlink");
|
|
307
311
|
}
|
|
@@ -397,6 +401,8 @@ async function assertLock(directory: string, lockPath: string, lock: LockLease):
|
|
|
397
401
|
const owned = await lock.handle.stat();
|
|
398
402
|
const present = await lstat(lockPath);
|
|
399
403
|
|
|
404
|
+
await assertWindowsPrivatePath(lockPath, "file");
|
|
405
|
+
|
|
400
406
|
if (
|
|
401
407
|
!owned.isFile() ||
|
|
402
408
|
!present.isFile() ||
|
|
@@ -615,7 +621,7 @@ export class FileConnectorStore implements ConnectorStore {
|
|
|
615
621
|
throw error;
|
|
616
622
|
});
|
|
617
623
|
|
|
618
|
-
assertRecordFile(stat);
|
|
624
|
+
await assertRecordFile(stat, slot.recordPath);
|
|
619
625
|
|
|
620
626
|
const text = await readFile(slot.recordPath, "utf8").catch(() =>
|
|
621
627
|
fail("unreadable record"),
|
|
@@ -662,7 +668,7 @@ export class FileConnectorStore implements ConnectorStore {
|
|
|
662
668
|
return null;
|
|
663
669
|
}
|
|
664
670
|
|
|
665
|
-
assertRecordFile(stat);
|
|
671
|
+
await assertRecordFile(stat, this.recordPath);
|
|
666
672
|
|
|
667
673
|
const text = await readFile(this.recordPath, "utf8").catch(() => fail("unreadable record"));
|
|
668
674
|
|
|
@@ -752,7 +758,7 @@ export class FileConnectorStore implements ConnectorStore {
|
|
|
752
758
|
fail("record disappeared under the writer; explicit recovery required");
|
|
753
759
|
}
|
|
754
760
|
|
|
755
|
-
assertRecordFile(stat);
|
|
761
|
+
await assertRecordFile(stat, this.recordPath);
|
|
756
762
|
|
|
757
763
|
const text = await readFile(this.recordPath, "utf8").catch(() => fail("unreadable record"));
|
|
758
764
|
|
|
@@ -794,7 +800,7 @@ export class FileConnectorStore implements ConnectorStore {
|
|
|
794
800
|
await assertLock(this.directory, this.lockPath, this.lock);
|
|
795
801
|
// rename() replaces the directory entry itself: it never writes THROUGH a symlink
|
|
796
802
|
// planted at the record path.
|
|
797
|
-
await
|
|
803
|
+
await durableRename(temp, this.recordPath);
|
|
798
804
|
this.fault?.("beforeDirSync");
|
|
799
805
|
// Past this rename the outcome is already committed on disk. A failure in the parent
|
|
800
806
|
// fsync is AMBIGUOUS: it is rethrown below — never swallowed, never undone, never
|
package/src/pairing-storage.ts
CHANGED
|
@@ -2,7 +2,8 @@
|
|
|
2
2
|
* It also hosts the owner's M4 relay activation record: a durable off-by-default switch with the
|
|
3
3
|
* same single-writer, atomic, fail-closed discipline as the pairing record itself. */
|
|
4
4
|
import { randomUUID } from "node:crypto";
|
|
5
|
-
import { lstat, mkdir, open, readFile,
|
|
5
|
+
import { lstat, mkdir, open, readFile, unlink, type FileHandle } from "node:fs/promises";
|
|
6
|
+
import { assertWindowsPrivatePath, durableRename } from "./windows-native.ts";
|
|
6
7
|
import { join } from "node:path";
|
|
7
8
|
|
|
8
9
|
const FILE = "pairing-storage.json";
|
|
@@ -83,9 +84,10 @@ function parse(text: string, limit: number): StorageSnapshot {
|
|
|
83
84
|
async function checkDirectory(directory: string): Promise<void> {
|
|
84
85
|
const stat = await lstat(directory);
|
|
85
86
|
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
//
|
|
87
|
+
await assertWindowsPrivatePath(directory, "directory");
|
|
88
|
+
|
|
89
|
+
// Windows privacy is proved above with the native owner/DACL check, not POSIX bits.
|
|
90
|
+
// Keep the strict POSIX mode proof on platforms that actually implement those bits.
|
|
89
91
|
const modeOk = process.platform === "win32" || (stat.mode & 0o777) === 0o700;
|
|
90
92
|
|
|
91
93
|
if (!stat.isDirectory() || !modeOk) {
|
|
@@ -94,6 +96,12 @@ async function checkDirectory(directory: string): Promise<void> {
|
|
|
94
96
|
}
|
|
95
97
|
|
|
96
98
|
async function syncDirectory(directory: string): Promise<void> {
|
|
99
|
+
// Windows commits use MoveFileExW(REPLACE_EXISTING | WRITE_THROUGH) after file fsync.
|
|
100
|
+
// No directory-handle flush is attempted or claimed there.
|
|
101
|
+
if (process.platform === "win32") {
|
|
102
|
+
return;
|
|
103
|
+
}
|
|
104
|
+
|
|
97
105
|
const handle = await open(directory, "r");
|
|
98
106
|
|
|
99
107
|
try {
|
|
@@ -137,10 +145,12 @@ async function assertLock(directory: string, lockFile: string, lock: LockLease):
|
|
|
137
145
|
const owned = await lock.handle.stat();
|
|
138
146
|
const present = await lstat(join(directory, lockFile));
|
|
139
147
|
|
|
148
|
+
await assertWindowsPrivatePath(join(directory, lockFile), "file");
|
|
149
|
+
|
|
140
150
|
if (
|
|
141
151
|
!owned.isFile() ||
|
|
142
152
|
!present.isFile() ||
|
|
143
|
-
(present.mode & 0o777) !== 0o600 ||
|
|
153
|
+
(process.platform !== "win32" && (present.mode & 0o777) !== 0o600) ||
|
|
144
154
|
owned.dev !== present.dev ||
|
|
145
155
|
owned.ino !== present.ino ||
|
|
146
156
|
owned.nlink !== 1 ||
|
|
@@ -263,7 +273,7 @@ export class RelaySwitchStore {
|
|
|
263
273
|
fail("missing or unreadable relay switch record"),
|
|
264
274
|
);
|
|
265
275
|
|
|
266
|
-
if (!stat.isFile() || (stat.mode & 0o777) !== 0o600) {
|
|
276
|
+
if (!stat.isFile() || (process.platform !== "win32" && (stat.mode & 0o777) !== 0o600)) {
|
|
267
277
|
fail("relay switch record must be a private (0600) regular file");
|
|
268
278
|
}
|
|
269
279
|
|
|
@@ -272,6 +282,8 @@ export class RelaySwitchStore {
|
|
|
272
282
|
fail("relay switch record must be owned by the current user");
|
|
273
283
|
}
|
|
274
284
|
|
|
285
|
+
await assertWindowsPrivatePath(file, "file");
|
|
286
|
+
|
|
275
287
|
const record = parseRelaySwitch(
|
|
276
288
|
await readFile(file, "utf8").catch(() => fail("unreadable relay switch record")),
|
|
277
289
|
);
|
|
@@ -358,7 +370,7 @@ export class RelaySwitchStore {
|
|
|
358
370
|
await handle.close();
|
|
359
371
|
handle = undefined;
|
|
360
372
|
await assertLock(this.directory, RELAY_LOCK, this.lock);
|
|
361
|
-
await
|
|
373
|
+
await durableRename(temp, join(this.directory, RELAY_FILE));
|
|
362
374
|
await assertLock(this.directory, RELAY_LOCK, this.lock);
|
|
363
375
|
await syncDirectory(this.directory);
|
|
364
376
|
await assertLock(this.directory, RELAY_LOCK, this.lock);
|
|
@@ -464,7 +476,7 @@ export class PairingStorage {
|
|
|
464
476
|
const file = join(directory, FILE);
|
|
465
477
|
const stat = await lstat(file).catch(() => fail("missing or unreadable record"));
|
|
466
478
|
|
|
467
|
-
if (!stat.isFile() || (stat.mode & 0o777) !== 0o600) {
|
|
479
|
+
if (!stat.isFile() || (process.platform !== "win32" && (stat.mode & 0o777) !== 0o600)) {
|
|
468
480
|
fail("record must be a private (0600) regular file");
|
|
469
481
|
}
|
|
470
482
|
|
|
@@ -474,6 +486,8 @@ export class PairingStorage {
|
|
|
474
486
|
fail("record must be owned by the current user");
|
|
475
487
|
}
|
|
476
488
|
|
|
489
|
+
await assertWindowsPrivatePath(file, "file");
|
|
490
|
+
|
|
477
491
|
const state = parse(
|
|
478
492
|
await readFile(file, "utf8").catch(() => fail("unreadable record")),
|
|
479
493
|
capacity,
|
|
@@ -619,10 +633,16 @@ export class PairingStorage {
|
|
|
619
633
|
fail("record revision changed or unreadable");
|
|
620
634
|
}
|
|
621
635
|
|
|
622
|
-
if (
|
|
636
|
+
if (
|
|
637
|
+
expected === null ||
|
|
638
|
+
!stat.isFile() ||
|
|
639
|
+
(process.platform !== "win32" && (stat.mode & 0o777) !== 0o600)
|
|
640
|
+
) {
|
|
623
641
|
fail("record revision changed or unreadable");
|
|
624
642
|
}
|
|
625
643
|
|
|
644
|
+
await assertWindowsPrivatePath(file, "file");
|
|
645
|
+
|
|
626
646
|
const text = await readFile(file, "utf8").catch(() => fail("record revision changed"));
|
|
627
647
|
const disk = parse(text, this.capacity);
|
|
628
648
|
|
|
@@ -655,7 +675,7 @@ export class PairingStorage {
|
|
|
655
675
|
await assertLock(this.directory, LOCK, this.lock);
|
|
656
676
|
await this.assertRecord(expected);
|
|
657
677
|
await assertLock(this.directory, LOCK, this.lock);
|
|
658
|
-
await
|
|
678
|
+
await durableRename(temp, join(this.directory, FILE));
|
|
659
679
|
this.fault?.("beforeDirSync");
|
|
660
680
|
await assertLock(this.directory, LOCK, this.lock);
|
|
661
681
|
await syncDirectory(this.directory);
|
|
@@ -0,0 +1,326 @@
|
|
|
1
|
+
# Trusted, transport/filesystem-only Win32 bridge. No pairing decisions or credentials in argv.
|
|
2
|
+
param([ValidateSet('worker', 'server')][string]$Mode, [string]$PipeName = '')
|
|
3
|
+
$ErrorActionPreference = 'Stop'
|
|
4
|
+
# A Node process launched from pwsh 7 can inherit incompatible Core-only module paths.
|
|
5
|
+
# Load only the trusted Windows PowerShell built-ins this bridge was compiled against.
|
|
6
|
+
$env:PSModulePath = "$PSHOME\Modules"
|
|
7
|
+
[Console]::InputEncoding = New-Object System.Text.UTF8Encoding($false)
|
|
8
|
+
[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
|
|
9
|
+
$source = @'
|
|
10
|
+
using System;
|
|
11
|
+
using System.IO;
|
|
12
|
+
using System.IO.Pipes;
|
|
13
|
+
using System.Text;
|
|
14
|
+
using System.Threading;
|
|
15
|
+
using System.Threading.Tasks;
|
|
16
|
+
using System.Collections.Concurrent;
|
|
17
|
+
using System.ComponentModel;
|
|
18
|
+
using System.Runtime.InteropServices;
|
|
19
|
+
using System.Security.AccessControl;
|
|
20
|
+
using System.Security.Principal;
|
|
21
|
+
using Microsoft.Win32.SafeHandles;
|
|
22
|
+
|
|
23
|
+
public static class BomWindowsNative {
|
|
24
|
+
const int RequestLimit = 4096, ResponseLimit = 65536;
|
|
25
|
+
static readonly object OutputLock = new object();
|
|
26
|
+
static readonly WindowsIdentity Identity = WindowsIdentity.GetCurrent();
|
|
27
|
+
static readonly SecurityIdentifier User = Identity.User;
|
|
28
|
+
static readonly ConcurrentDictionary<string, TaskCompletionSource<byte[]>> Replies = new ConcurrentDictionary<string, TaskCompletionSource<byte[]>>();
|
|
29
|
+
static readonly ConcurrentDictionary<string, CancellationTokenSource> Deadlines = new ConcurrentDictionary<string, CancellationTokenSource>();
|
|
30
|
+
static readonly ConcurrentDictionary<string, NamedPipeServerStream> Connections = new ConcurrentDictionary<string, NamedPipeServerStream>();
|
|
31
|
+
static volatile bool Stopping;
|
|
32
|
+
static NamedPipeServerStream Listener;
|
|
33
|
+
static int Active;
|
|
34
|
+
|
|
35
|
+
[StructLayout(LayoutKind.Sequential)]
|
|
36
|
+
struct SecurityAttributes {
|
|
37
|
+
public int Length;
|
|
38
|
+
public IntPtr Descriptor;
|
|
39
|
+
[MarshalAs(UnmanagedType.Bool)] public bool Inherit;
|
|
40
|
+
}
|
|
41
|
+
[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
|
|
42
|
+
static extern SafePipeHandle CreateNamedPipe(string name, uint openMode, uint pipeMode, uint instances, uint outSize, uint inSize, uint timeout, ref SecurityAttributes security);
|
|
43
|
+
[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
|
|
44
|
+
static extern bool WaitNamedPipe(string name, uint timeout);
|
|
45
|
+
[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
|
|
46
|
+
static extern bool MoveFileEx(string source, string destination, uint flags);
|
|
47
|
+
|
|
48
|
+
static void Emit(string line) {
|
|
49
|
+
lock (OutputLock) { Console.WriteLine(line); Console.Out.Flush(); }
|
|
50
|
+
}
|
|
51
|
+
static string Encode(string value) { return Convert.ToBase64String(Encoding.UTF8.GetBytes(value)); }
|
|
52
|
+
static string Decode(string value) {
|
|
53
|
+
if (value.Length > 100000) throw new InvalidOperationException("size-bound");
|
|
54
|
+
return Encoding.UTF8.GetString(Convert.FromBase64String(value));
|
|
55
|
+
}
|
|
56
|
+
static string ErrorCode(Exception error) {
|
|
57
|
+
if (error is AggregateException) error = error.GetBaseException();
|
|
58
|
+
if (error is OperationCanceledException || error is TimeoutException) return "timeout";
|
|
59
|
+
if (error is UnauthorizedAccessException) return "access-denied";
|
|
60
|
+
if (error is InvalidOperationException) return error.Message;
|
|
61
|
+
if (error is Win32Exception) return "win32-" + ((Win32Exception)error).NativeErrorCode;
|
|
62
|
+
return "native-io";
|
|
63
|
+
}
|
|
64
|
+
static bool TrustedFilePrincipal(string sid) {
|
|
65
|
+
return sid == User.Value || sid == "S-1-5-18" || sid == "S-1-5-32-544"
|
|
66
|
+
|| sid == "S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464";
|
|
67
|
+
}
|
|
68
|
+
static void CheckAncestors(string path) {
|
|
69
|
+
string current = Path.GetDirectoryName(Path.GetFullPath(path));
|
|
70
|
+
const FileSystemRights unsafeRights = FileSystemRights.Delete | FileSystemRights.DeleteSubdirectoriesAndFiles | FileSystemRights.ChangePermissions | FileSystemRights.TakeOwnership;
|
|
71
|
+
while (!String.IsNullOrEmpty(current)) {
|
|
72
|
+
if ((File.GetAttributes(current) & FileAttributes.ReparsePoint) != 0) throw new InvalidOperationException("reparse-path");
|
|
73
|
+
DirectorySecurity security = Directory.GetAccessControl(current, AccessControlSections.Owner | AccessControlSections.Access);
|
|
74
|
+
string owner = security.GetOwner(typeof(SecurityIdentifier)).Value;
|
|
75
|
+
// TrustedInstaller is a privileged Windows system owner (like SYSTEM), not a peer user.
|
|
76
|
+
bool installer = owner == "S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464";
|
|
77
|
+
if (!TrustedFilePrincipal(owner) && owner != Identity.Owner.Value && !installer) throw new InvalidOperationException("unsafe-ancestor");
|
|
78
|
+
foreach (FileSystemAccessRule rule in security.GetAccessRules(true, true, typeof(SecurityIdentifier))) {
|
|
79
|
+
if (rule.AccessControlType == AccessControlType.Allow && (rule.PropagationFlags & PropagationFlags.InheritOnly) == 0
|
|
80
|
+
&& !TrustedFilePrincipal(rule.IdentityReference.Value) && (rule.FileSystemRights & unsafeRights) != 0)
|
|
81
|
+
throw new InvalidOperationException("unsafe-ancestor");
|
|
82
|
+
}
|
|
83
|
+
DirectoryInfo parent = Directory.GetParent(current);
|
|
84
|
+
current = parent == null ? null : parent.FullName;
|
|
85
|
+
}
|
|
86
|
+
}
|
|
87
|
+
public static void CheckPrivate(string path, bool directory) {
|
|
88
|
+
FileAttributes attributes = File.GetAttributes(path);
|
|
89
|
+
if ((attributes & FileAttributes.ReparsePoint) != 0) throw new InvalidOperationException("reparse-path");
|
|
90
|
+
if (((attributes & FileAttributes.Directory) != 0) != directory) throw new InvalidOperationException("path-type");
|
|
91
|
+
FileSystemSecurity security = directory
|
|
92
|
+
? (FileSystemSecurity)Directory.GetAccessControl(path, AccessControlSections.Owner | AccessControlSections.Access)
|
|
93
|
+
: (FileSystemSecurity)File.GetAccessControl(path, AccessControlSections.Owner | AccessControlSections.Access);
|
|
94
|
+
string owner = security.GetOwner(typeof(SecurityIdentifier)).Value;
|
|
95
|
+
// Privileged system owners are trusted like POSIX root. Still require this account's
|
|
96
|
+
// actual access below; a different ordinary owner can rewrite the DACL and is refused.
|
|
97
|
+
if (!TrustedFilePrincipal(owner) && owner != Identity.Owner.Value) throw new InvalidOperationException("foreign-owner");
|
|
98
|
+
bool ownAccess = false;
|
|
99
|
+
foreach (FileSystemAccessRule rule in security.GetAccessRules(true, true, typeof(SecurityIdentifier))) {
|
|
100
|
+
if ((rule.PropagationFlags & PropagationFlags.InheritOnly) != 0 || rule.AccessControlType != AccessControlType.Allow) continue;
|
|
101
|
+
string sid = rule.IdentityReference.Value;
|
|
102
|
+
if (!TrustedFilePrincipal(sid)) throw new InvalidOperationException("private-acl");
|
|
103
|
+
if (sid == User.Value || sid == Identity.Owner.Value) ownAccess = true;
|
|
104
|
+
}
|
|
105
|
+
if (!ownAccess) throw new InvalidOperationException("private-acl");
|
|
106
|
+
CheckAncestors(path);
|
|
107
|
+
}
|
|
108
|
+
static void DurableMove(string source, string destination) {
|
|
109
|
+
CheckPrivate(source, false);
|
|
110
|
+
CheckPrivate(Path.GetDirectoryName(destination), true);
|
|
111
|
+
if (File.Exists(destination) || Directory.Exists(destination)) CheckPrivate(destination, false);
|
|
112
|
+
// MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH. File bytes were flushed by Node
|
|
113
|
+
// first. This is the Win32 replacement contract, not a pretend directory fsync.
|
|
114
|
+
if (!MoveFileEx(source, destination, 0x1 | 0x8)) throw new Win32Exception(Marshal.GetLastWin32Error());
|
|
115
|
+
}
|
|
116
|
+
static void VerifyPipe(PipeStream pipe) {
|
|
117
|
+
PipeSecurity security = pipe.GetAccessControl();
|
|
118
|
+
if (security.GetOwner(typeof(SecurityIdentifier)).Value != User.Value || !security.AreAccessRulesProtected)
|
|
119
|
+
throw new InvalidOperationException("pipe-identity");
|
|
120
|
+
bool ownerAllowed = false;
|
|
121
|
+
foreach (PipeAccessRule rule in security.GetAccessRules(true, true, typeof(SecurityIdentifier))) {
|
|
122
|
+
if (rule.AccessControlType != AccessControlType.Allow) continue;
|
|
123
|
+
if (rule.IdentityReference.Value != User.Value) throw new InvalidOperationException("pipe-acl");
|
|
124
|
+
if ((rule.PipeAccessRights & PipeAccessRights.FullControl) == PipeAccessRights.FullControl) ownerAllowed = true;
|
|
125
|
+
}
|
|
126
|
+
if (!ownerAllowed) throw new InvalidOperationException("pipe-acl");
|
|
127
|
+
}
|
|
128
|
+
static bool WaitForPipe(string name, int milliseconds) {
|
|
129
|
+
DateTime deadline = DateTime.UtcNow.AddMilliseconds(milliseconds);
|
|
130
|
+
while (true) {
|
|
131
|
+
if (WaitNamedPipe("\\\\.\\pipe\\" + name, 1)) return true;
|
|
132
|
+
int code = Marshal.GetLastWin32Error();
|
|
133
|
+
if (code == 231) return true; // ERROR_PIPE_BUSY: exists, all busy
|
|
134
|
+
if (code == 5) throw new UnauthorizedAccessException(); // exists, this user denied
|
|
135
|
+
if (code != 2) return false; // not FILE_NOT_FOUND: not ours
|
|
136
|
+
// A serving instance can be missing for a moment between accept and re-arm.
|
|
137
|
+
if (DateTime.UtcNow >= deadline) return false;
|
|
138
|
+
System.Threading.Thread.Sleep(10);
|
|
139
|
+
}
|
|
140
|
+
}
|
|
141
|
+
static void ValidateName(string name) {
|
|
142
|
+
if (!System.Text.RegularExpressions.Regex.IsMatch(name, "^bom-pi-admin-[a-f0-9]{64}$"))
|
|
143
|
+
throw new InvalidOperationException("pipe-name");
|
|
144
|
+
}
|
|
145
|
+
static NamedPipeServerStream NewPipe(string name, bool first) {
|
|
146
|
+
// Install the protected, owner-only DACL AT CREATION, never after accepting clients.
|
|
147
|
+
PipeSecurity acl = new PipeSecurity();
|
|
148
|
+
acl.SetOwner(User);
|
|
149
|
+
acl.SetAccessRuleProtection(true, false);
|
|
150
|
+
acl.AddAccessRule(new PipeAccessRule(new SecurityIdentifier("S-1-5-2"), PipeAccessRights.FullControl, AccessControlType.Deny));
|
|
151
|
+
acl.AddAccessRule(new PipeAccessRule(User, PipeAccessRights.FullControl, AccessControlType.Allow));
|
|
152
|
+
byte[] binary = acl.GetSecurityDescriptorBinaryForm();
|
|
153
|
+
IntPtr descriptor = Marshal.AllocHGlobal(binary.Length);
|
|
154
|
+
Marshal.Copy(binary, 0, descriptor, binary.Length);
|
|
155
|
+
try {
|
|
156
|
+
SecurityAttributes security = new SecurityAttributes();
|
|
157
|
+
security.Length = Marshal.SizeOf(typeof(SecurityAttributes));
|
|
158
|
+
security.Descriptor = descriptor;
|
|
159
|
+
security.Inherit = false;
|
|
160
|
+
uint flags = 0x3u | 0x40000000u | (first ? 0x80000u : 0u);
|
|
161
|
+
// PIPE_REJECT_REMOTE_CLIENTS, byte mode. First instance is exclusive, atomically.
|
|
162
|
+
SafePipeHandle handle = CreateNamedPipe("\\\\.\\pipe\\" + name, flags, 0x8, 255, 65537, 4096, 0, ref security);
|
|
163
|
+
if (handle.IsInvalid) { int code = Marshal.GetLastWin32Error(); handle.Dispose(); throw new Win32Exception(code); }
|
|
164
|
+
NamedPipeServerStream pipe = new NamedPipeServerStream(PipeDirection.InOut, true, false, handle);
|
|
165
|
+
try { VerifyPipe(pipe); return pipe; } catch { pipe.Dispose(); throw; }
|
|
166
|
+
} finally { Marshal.FreeHGlobal(descriptor); }
|
|
167
|
+
}
|
|
168
|
+
static async Task<byte[]> ReadLine(Stream stream, int limit, CancellationToken token) {
|
|
169
|
+
byte[] buffer = new byte[1024];
|
|
170
|
+
using (MemoryStream body = new MemoryStream()) {
|
|
171
|
+
while (true) {
|
|
172
|
+
int count = await stream.ReadAsync(buffer, 0, buffer.Length, token).ConfigureAwait(false);
|
|
173
|
+
if (count == 0) throw new EndOfStreamException();
|
|
174
|
+
if (body.Length + count > limit) throw new InvalidOperationException("too-large");
|
|
175
|
+
int newline = Array.IndexOf(buffer, (byte)10, 0, count);
|
|
176
|
+
if (newline >= 0) {
|
|
177
|
+
if (newline != count - 1) throw new InvalidOperationException("malformed");
|
|
178
|
+
body.Write(buffer, 0, newline);
|
|
179
|
+
return body.ToArray();
|
|
180
|
+
}
|
|
181
|
+
body.Write(buffer, 0, count);
|
|
182
|
+
}
|
|
183
|
+
}
|
|
184
|
+
}
|
|
185
|
+
static async Task WriteLine(Stream stream, byte[] body) {
|
|
186
|
+
if (body.Length > ResponseLimit) throw new InvalidOperationException("too-large");
|
|
187
|
+
await stream.WriteAsync(body, 0, body.Length).ConfigureAwait(false);
|
|
188
|
+
await stream.WriteAsync(new byte[] { 10 }, 0, 1).ConfigureAwait(false);
|
|
189
|
+
await stream.FlushAsync().ConfigureAwait(false);
|
|
190
|
+
}
|
|
191
|
+
static async Task Handle(NamedPipeServerStream pipe, string id) {
|
|
192
|
+
TaskCompletionSource<byte[]> reply = new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
193
|
+
CancellationTokenSource deadline = new CancellationTokenSource(10000);
|
|
194
|
+
Replies[id] = reply;
|
|
195
|
+
Deadlines[id] = deadline;
|
|
196
|
+
try {
|
|
197
|
+
byte[] request = await ReadLine(pipe, RequestLimit, deadline.Token).ConfigureAwait(false);
|
|
198
|
+
using (deadline.Token.Register(() => reply.TrySetCanceled())) {
|
|
199
|
+
Emit("REQUEST\t" + id + "\t" + Convert.ToBase64String(request));
|
|
200
|
+
byte[] response = await reply.Task.ConfigureAwait(false);
|
|
201
|
+
await WriteLine(pipe, response).ConfigureAwait(false);
|
|
202
|
+
}
|
|
203
|
+
} catch (InvalidOperationException error) {
|
|
204
|
+
string code = error.Message == "too-large" ? "too-large" : "malformed";
|
|
205
|
+
// Windows PowerShell 5.1 compiles C# 5, which cannot await inside catch.
|
|
206
|
+
try { WriteLine(pipe, Encoding.UTF8.GetBytes("{\"ok\":false,\"op\":null,\"error\":\"" + code + "\",\"message\":\"Invalid bounded request line\"}")).GetAwaiter().GetResult(); } catch { }
|
|
207
|
+
} catch { /* Closed, timed-out, or disconnected transport: never run another request. */ }
|
|
208
|
+
finally {
|
|
209
|
+
TaskCompletionSource<byte[]> removedReply;
|
|
210
|
+
CancellationTokenSource removedDeadline;
|
|
211
|
+
NamedPipeServerStream removedConnection;
|
|
212
|
+
Replies.TryRemove(id, out removedReply);
|
|
213
|
+
Deadlines.TryRemove(id, out removedDeadline);
|
|
214
|
+
Connections.TryRemove(id, out removedConnection);
|
|
215
|
+
deadline.Dispose();
|
|
216
|
+
pipe.Dispose();
|
|
217
|
+
Interlocked.Decrement(ref Active);
|
|
218
|
+
}
|
|
219
|
+
}
|
|
220
|
+
static void Stop() {
|
|
221
|
+
Stopping = true;
|
|
222
|
+
if (Listener != null) Listener.Dispose();
|
|
223
|
+
foreach (var connection in Connections.Values) connection.Dispose();
|
|
224
|
+
foreach (var reply in Replies.Values) reply.TrySetCanceled();
|
|
225
|
+
}
|
|
226
|
+
public static void Server(string name) {
|
|
227
|
+
ValidateName(name);
|
|
228
|
+
Listener = NewPipe(name, true);
|
|
229
|
+
Emit("READY");
|
|
230
|
+
Task.Factory.StartNew(() => {
|
|
231
|
+
try {
|
|
232
|
+
string line;
|
|
233
|
+
while ((line = Console.ReadLine()) != null) {
|
|
234
|
+
if (line == "CLOSE") break;
|
|
235
|
+
if (line.Length > 100000) break;
|
|
236
|
+
string[] fields = line.Split('\t');
|
|
237
|
+
if (fields.Length != 3) break;
|
|
238
|
+
if (fields[0] == "REPLY") {
|
|
239
|
+
TaskCompletionSource<byte[]> pending;
|
|
240
|
+
byte[] bytes = Convert.FromBase64String(fields[2]);
|
|
241
|
+
if (bytes.Length <= ResponseLimit && Replies.TryGetValue(fields[1], out pending)) pending.TrySetResult(bytes);
|
|
242
|
+
} else if (fields[0] == "WAIT" && fields[2] == "1200000") {
|
|
243
|
+
CancellationTokenSource deadline;
|
|
244
|
+
if (Deadlines.TryGetValue(fields[1], out deadline)) {
|
|
245
|
+
try { deadline.CancelAfter(1200000); } catch (ObjectDisposedException) { }
|
|
246
|
+
}
|
|
247
|
+
} else break;
|
|
248
|
+
}
|
|
249
|
+
} catch { } finally { Stop(); }
|
|
250
|
+
}, TaskCreationOptions.LongRunning);
|
|
251
|
+
try {
|
|
252
|
+
while (!Stopping) {
|
|
253
|
+
Listener.WaitForConnection();
|
|
254
|
+
NamedPipeServerStream connected = Listener;
|
|
255
|
+
if (Interlocked.Increment(ref Active) > 4) {
|
|
256
|
+
try { WriteLine(connected, Encoding.UTF8.GetBytes("{\"ok\":false,\"op\":null,\"error\":\"busy\",\"message\":\"Too many concurrent admin connections\"}")).GetAwaiter().GetResult(); } catch { }
|
|
257
|
+
connected.Dispose();
|
|
258
|
+
Interlocked.Decrement(ref Active);
|
|
259
|
+
Listener = NewPipe(name, false);
|
|
260
|
+
continue;
|
|
261
|
+
}
|
|
262
|
+
// Keep an owner-only instance alive before the connected instance can close.
|
|
263
|
+
Listener = NewPipe(name, false);
|
|
264
|
+
string id = Guid.NewGuid().ToString("N");
|
|
265
|
+
Connections[id] = connected;
|
|
266
|
+
Task.Run(() => Handle(connected, id));
|
|
267
|
+
}
|
|
268
|
+
} catch { if (!Stopping) throw; } finally { Stop(); }
|
|
269
|
+
}
|
|
270
|
+
static async Task<string> Client(string name, string request, int timeout) {
|
|
271
|
+
ValidateName(name);
|
|
272
|
+
// Distinguish "no daemon" (absent/denied) from "daemon too slow" (busy) so callers
|
|
273
|
+
// can report the honest state instead of waiting out the request deadline.
|
|
274
|
+
if (!WaitForPipe(name, 500)) throw new InvalidOperationException("pipe-unavailable");
|
|
275
|
+
byte[] bytes = Encoding.UTF8.GetBytes(request);
|
|
276
|
+
if (bytes.Length + 1 > RequestLimit) throw new InvalidOperationException("too-large");
|
|
277
|
+
using (NamedPipeClientStream pipe = new NamedPipeClientStream(".", name,
|
|
278
|
+
PipeAccessRights.ReadWrite | PipeAccessRights.ReadPermissions, PipeOptions.Asynchronous,
|
|
279
|
+
TokenImpersonationLevel.Identification, HandleInheritability.None)) {
|
|
280
|
+
using (CancellationTokenSource deadline = new CancellationTokenSource(timeout)) {
|
|
281
|
+
await pipe.ConnectAsync(timeout, deadline.Token).ConfigureAwait(false);
|
|
282
|
+
// Verify THIS connected handle, not a pathname that an attacker can replace.
|
|
283
|
+
VerifyPipe(pipe);
|
|
284
|
+
await pipe.WriteAsync(bytes, 0, bytes.Length, deadline.Token).ConfigureAwait(false);
|
|
285
|
+
await pipe.WriteAsync(new byte[] { 10 }, 0, 1, deadline.Token).ConfigureAwait(false);
|
|
286
|
+
byte[] response = await ReadLine(pipe, ResponseLimit + 1, deadline.Token).ConfigureAwait(false);
|
|
287
|
+
return Encoding.UTF8.GetString(response);
|
|
288
|
+
}
|
|
289
|
+
}
|
|
290
|
+
}
|
|
291
|
+
static async Task Command(string[] fields) {
|
|
292
|
+
string id = fields[1];
|
|
293
|
+
try {
|
|
294
|
+
string result = "";
|
|
295
|
+
if (fields[0] == "DIR" && fields.Length == 3) CheckPrivate(Decode(fields[2]), true);
|
|
296
|
+
else if (fields[0] == "FILE" && fields.Length == 3) CheckPrivate(Decode(fields[2]), false);
|
|
297
|
+
else if (fields[0] == "MOVE" && fields.Length == 4) DurableMove(Decode(fields[2]), Decode(fields[3]));
|
|
298
|
+
else if (fields[0] == "CLIENT" && fields.Length == 5)
|
|
299
|
+
result = await Client(Decode(fields[2]), Decode(fields[3]), Int32.Parse(fields[4])).ConfigureAwait(false);
|
|
300
|
+
else throw new InvalidOperationException("command");
|
|
301
|
+
Emit("OK\t" + id + "\t" + Encode(result));
|
|
302
|
+
} catch (Exception error) { Emit("ERROR\t" + id + "\t" + ErrorCode(error)); }
|
|
303
|
+
}
|
|
304
|
+
public static void Worker() {
|
|
305
|
+
Emit("READY");
|
|
306
|
+
string line;
|
|
307
|
+
while ((line = Console.ReadLine()) != null) {
|
|
308
|
+
if (line.Length > 100000) throw new InvalidOperationException("size-bound");
|
|
309
|
+
string[] fields = line.Split('\t');
|
|
310
|
+
if (fields.Length < 3 || !System.Text.RegularExpressions.Regex.IsMatch(fields[1], "^[a-f0-9]{32}$"))
|
|
311
|
+
throw new InvalidOperationException("command");
|
|
312
|
+
// IPC clients may wait for approval; do not block unrelated filesystem commands.
|
|
313
|
+
Task.Run(() => Command(fields));
|
|
314
|
+
}
|
|
315
|
+
}
|
|
316
|
+
}
|
|
317
|
+
'@
|
|
318
|
+
try {
|
|
319
|
+
Add-Type -TypeDefinition $source -ReferencedAssemblies System.dll,System.Core.dll,System.Security.dll
|
|
320
|
+
if ($Mode -eq 'server') { [BomWindowsNative]::Server($PipeName) }
|
|
321
|
+
else { [BomWindowsNative]::Worker() }
|
|
322
|
+
} catch {
|
|
323
|
+
# Startup contains only static code and the public pipe name, never a request/receipt.
|
|
324
|
+
[Console]::Error.WriteLine('WINDOWS_NATIVE_START_FAILED: ' + $_.Exception.GetBaseException().Message)
|
|
325
|
+
exit 1
|
|
326
|
+
}
|
|
@@ -0,0 +1,453 @@
|
|
|
1
|
+
/** Native Windows IPC/ACL and durable-replace adapter. The PowerShell bridge hosts only
|
|
2
|
+
* Win32 transport/filesystem primitives; the core remains the sole pairing dispatcher/writer.
|
|
3
|
+
* No secret, request or receipt travels in argv, environment variables or diagnostic output. */
|
|
4
|
+
import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
|
|
5
|
+
import { randomBytes } from "node:crypto";
|
|
6
|
+
import { rename } from "node:fs/promises";
|
|
7
|
+
import { join, resolve } from "node:path";
|
|
8
|
+
import { fileURLToPath } from "node:url";
|
|
9
|
+
|
|
10
|
+
const SCRIPT = fileURLToPath(new URL("./windows-native.ps1", import.meta.url));
|
|
11
|
+
const MAX_FRAME = 100_000;
|
|
12
|
+
const START_TIMEOUT = 30_000;
|
|
13
|
+
|
|
14
|
+
export class WindowsNativeError extends Error {
|
|
15
|
+
readonly code: string;
|
|
16
|
+
|
|
17
|
+
constructor(code: string) {
|
|
18
|
+
super(`Windows native operation refused (${code})`);
|
|
19
|
+
this.code = code;
|
|
20
|
+
}
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
function launch(mode: "worker" | "server", pipeName?: string): ChildProcessWithoutNullStreams {
|
|
24
|
+
if (process.platform !== "win32") {
|
|
25
|
+
throw new WindowsNativeError("not-windows");
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
const executable = join(
|
|
29
|
+
process.env.SystemRoot ?? "C:\\Windows",
|
|
30
|
+
"System32",
|
|
31
|
+
"WindowsPowerShell",
|
|
32
|
+
"v1.0",
|
|
33
|
+
"powershell.exe",
|
|
34
|
+
);
|
|
35
|
+
|
|
36
|
+
return spawn(
|
|
37
|
+
executable,
|
|
38
|
+
[
|
|
39
|
+
"-NoLogo",
|
|
40
|
+
"-NoProfile",
|
|
41
|
+
"-NonInteractive",
|
|
42
|
+
"-ExecutionPolicy",
|
|
43
|
+
"Bypass",
|
|
44
|
+
"-File",
|
|
45
|
+
SCRIPT,
|
|
46
|
+
"-Mode",
|
|
47
|
+
mode,
|
|
48
|
+
...(pipeName ? ["-PipeName", pipeName] : []),
|
|
49
|
+
],
|
|
50
|
+
{ windowsHide: true, stdio: ["pipe", "pipe", "pipe"] },
|
|
51
|
+
);
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
function reference(child: ChildProcessWithoutNullStreams, active: boolean): void {
|
|
55
|
+
const operation = active ? "ref" : "unref";
|
|
56
|
+
|
|
57
|
+
child[operation]();
|
|
58
|
+
|
|
59
|
+
for (const stream of [child.stdin, child.stdout, child.stderr]) {
|
|
60
|
+
const handle = stream as unknown as { ref?: () => void; unref?: () => void };
|
|
61
|
+
|
|
62
|
+
handle[operation]?.();
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
/** Bounded private inherited-channel framing. Never echo malformed frames: they may contain
|
|
67
|
+
* receipt bytes. stderr is drained with a hard bound but is never copied into errors/logs. */
|
|
68
|
+
function lines(
|
|
69
|
+
child: ChildProcessWithoutNullStreams,
|
|
70
|
+
receive: (line: string) => void,
|
|
71
|
+
fail: (error: WindowsNativeError) => void,
|
|
72
|
+
): void {
|
|
73
|
+
let buffered = "";
|
|
74
|
+
let stderrBytes = 0;
|
|
75
|
+
|
|
76
|
+
child.stdout.setEncoding("utf8");
|
|
77
|
+
child.stdout.on("data", (chunk: string) => {
|
|
78
|
+
buffered += chunk;
|
|
79
|
+
|
|
80
|
+
while (true) {
|
|
81
|
+
const newline = buffered.indexOf("\n");
|
|
82
|
+
|
|
83
|
+
if (newline === -1) {
|
|
84
|
+
break;
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
if (newline > MAX_FRAME) {
|
|
88
|
+
fail(new WindowsNativeError("frame-bound"));
|
|
89
|
+
|
|
90
|
+
return;
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
const line = buffered.slice(0, newline).replace(/\r$/, "");
|
|
94
|
+
|
|
95
|
+
buffered = buffered.slice(newline + 1);
|
|
96
|
+
receive(line);
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
if (buffered.length > MAX_FRAME) {
|
|
100
|
+
fail(new WindowsNativeError("frame-bound"));
|
|
101
|
+
}
|
|
102
|
+
});
|
|
103
|
+
child.stderr.on("data", (chunk: Buffer) => {
|
|
104
|
+
stderrBytes += chunk.byteLength;
|
|
105
|
+
|
|
106
|
+
if (stderrBytes > 16_384) {
|
|
107
|
+
fail(new WindowsNativeError("diagnostic-bound"));
|
|
108
|
+
}
|
|
109
|
+
});
|
|
110
|
+
child.on("error", () => fail(new WindowsNativeError("helper-start")));
|
|
111
|
+
child.stdin.on("error", () => fail(new WindowsNativeError("helper-channel")));
|
|
112
|
+
child.on("exit", () => fail(new WindowsNativeError("helper-exit")));
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
type Pending = {
|
|
116
|
+
resolve(value: string): void;
|
|
117
|
+
reject(error: WindowsNativeError): void;
|
|
118
|
+
timer: ReturnType<typeof setTimeout>;
|
|
119
|
+
};
|
|
120
|
+
|
|
121
|
+
let worker: NativeWorker | undefined;
|
|
122
|
+
|
|
123
|
+
class NativeWorker {
|
|
124
|
+
readonly child: ChildProcessWithoutNullStreams;
|
|
125
|
+
readonly ready: Promise<void>;
|
|
126
|
+
readonly pending = new Map<string, Pending>();
|
|
127
|
+
failed: WindowsNativeError | undefined;
|
|
128
|
+
|
|
129
|
+
constructor() {
|
|
130
|
+
this.child = launch("worker");
|
|
131
|
+
let resolveReady!: () => void;
|
|
132
|
+
let rejectReady!: (error: WindowsNativeError) => void;
|
|
133
|
+
let started = false;
|
|
134
|
+
|
|
135
|
+
this.ready = new Promise((resolve, reject) => {
|
|
136
|
+
resolveReady = resolve;
|
|
137
|
+
rejectReady = reject;
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
const timer = setTimeout(
|
|
141
|
+
() => this.fail(new WindowsNativeError("helper-deadline")),
|
|
142
|
+
START_TIMEOUT,
|
|
143
|
+
);
|
|
144
|
+
|
|
145
|
+
// Captured by the fail path; ready errors never become unhandled rejections.
|
|
146
|
+
void this.ready.catch(() => undefined);
|
|
147
|
+
this.ready.then(
|
|
148
|
+
() => clearTimeout(timer),
|
|
149
|
+
() => clearTimeout(timer),
|
|
150
|
+
);
|
|
151
|
+
lines(
|
|
152
|
+
this.child,
|
|
153
|
+
(line) => {
|
|
154
|
+
if (line === "READY" && !started) {
|
|
155
|
+
started = true;
|
|
156
|
+
resolveReady();
|
|
157
|
+
reference(this.child, false);
|
|
158
|
+
|
|
159
|
+
return;
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
const [kind, id, payload, extra] = line.split("\t");
|
|
163
|
+
const pending = id ? this.pending.get(id) : undefined;
|
|
164
|
+
|
|
165
|
+
if (
|
|
166
|
+
!started ||
|
|
167
|
+
!id ||
|
|
168
|
+
payload === undefined ||
|
|
169
|
+
extra !== undefined ||
|
|
170
|
+
(kind !== "OK" && kind !== "ERROR")
|
|
171
|
+
) {
|
|
172
|
+
this.fail(new WindowsNativeError("helper-protocol"));
|
|
173
|
+
|
|
174
|
+
return;
|
|
175
|
+
}
|
|
176
|
+
|
|
177
|
+
if (!pending) {
|
|
178
|
+
// A deadline can expire while the native operation is still finishing. Never replay.
|
|
179
|
+
return;
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
this.pending.delete(id);
|
|
183
|
+
clearTimeout(pending.timer);
|
|
184
|
+
|
|
185
|
+
if (kind === "OK") {
|
|
186
|
+
pending.resolve(Buffer.from(payload, "base64").toString("utf8"));
|
|
187
|
+
} else {
|
|
188
|
+
pending.reject(
|
|
189
|
+
new WindowsNativeError(
|
|
190
|
+
/^[a-z0-9-]{1,64}$/.test(payload) ? payload : "native-io",
|
|
191
|
+
),
|
|
192
|
+
);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
if (this.pending.size === 0) {
|
|
196
|
+
reference(this.child, false);
|
|
197
|
+
}
|
|
198
|
+
},
|
|
199
|
+
(error) => {
|
|
200
|
+
rejectReady(error);
|
|
201
|
+
this.fail(error);
|
|
202
|
+
},
|
|
203
|
+
);
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
fail(error: WindowsNativeError): void {
|
|
207
|
+
if (this.failed) {
|
|
208
|
+
return;
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
this.failed = error;
|
|
212
|
+
|
|
213
|
+
if (worker === this) {
|
|
214
|
+
worker = undefined;
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
for (const pending of this.pending.values()) {
|
|
218
|
+
clearTimeout(pending.timer);
|
|
219
|
+
pending.reject(error);
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
this.pending.clear();
|
|
223
|
+
this.child.kill();
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
async call(operation: string, arguments_: string[], timeoutMs: number): Promise<string> {
|
|
227
|
+
await this.ready;
|
|
228
|
+
|
|
229
|
+
if (this.failed) {
|
|
230
|
+
throw this.failed;
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
if (this.pending.size >= 128) {
|
|
234
|
+
throw new WindowsNativeError("busy");
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
const id = randomBytes(16).toString("hex");
|
|
238
|
+
const frame = [operation, id, ...arguments_].join("\t");
|
|
239
|
+
|
|
240
|
+
if (frame.length > MAX_FRAME || arguments_.some((value) => /[\r\n\t]/.test(value))) {
|
|
241
|
+
throw new WindowsNativeError("frame-bound");
|
|
242
|
+
}
|
|
243
|
+
|
|
244
|
+
reference(this.child, true);
|
|
245
|
+
|
|
246
|
+
return new Promise((resolve, reject) => {
|
|
247
|
+
const timer = setTimeout(() => {
|
|
248
|
+
this.pending.delete(id);
|
|
249
|
+
reject(new WindowsNativeError("timeout"));
|
|
250
|
+
|
|
251
|
+
if (this.pending.size === 0) {
|
|
252
|
+
reference(this.child, false);
|
|
253
|
+
}
|
|
254
|
+
}, timeoutMs);
|
|
255
|
+
|
|
256
|
+
this.pending.set(id, { resolve, reject, timer });
|
|
257
|
+
this.child.stdin.write(`${frame}\n`);
|
|
258
|
+
});
|
|
259
|
+
}
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
const encode = (value: string): string => Buffer.from(value, "utf8").toString("base64");
|
|
263
|
+
const getWorker = (): NativeWorker => (worker ??= new NativeWorker());
|
|
264
|
+
|
|
265
|
+
/** Windows ACL proof, including owner and reparse-point refusal; never chmod an existing path. */
|
|
266
|
+
export async function assertWindowsPrivatePath(
|
|
267
|
+
path: string,
|
|
268
|
+
kind: "file" | "directory",
|
|
269
|
+
): Promise<void> {
|
|
270
|
+
if (process.platform === "win32") {
|
|
271
|
+
await getWorker().call(
|
|
272
|
+
kind === "file" ? "FILE" : "DIR",
|
|
273
|
+
[encode(resolve(path))],
|
|
274
|
+
START_TIMEOUT,
|
|
275
|
+
);
|
|
276
|
+
}
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
/** Regular-file fsync must precede this call. Windows uses native write-through replacement. */
|
|
280
|
+
export async function durableRename(source: string, destination: string): Promise<void> {
|
|
281
|
+
if (process.platform === "win32") {
|
|
282
|
+
await getWorker().call(
|
|
283
|
+
"MOVE",
|
|
284
|
+
[encode(resolve(source)), encode(resolve(destination))],
|
|
285
|
+
START_TIMEOUT,
|
|
286
|
+
);
|
|
287
|
+
} else {
|
|
288
|
+
await rename(source, destination);
|
|
289
|
+
}
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
function pipeName(path: string): string {
|
|
293
|
+
const prefix = "\\\\.\\pipe\\";
|
|
294
|
+
const name = path.slice(prefix.length);
|
|
295
|
+
|
|
296
|
+
if (!path.startsWith(prefix) || !/^bom-pi-admin-[a-f0-9]{64}$/.test(name)) {
|
|
297
|
+
throw new WindowsNativeError("pipe-name");
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
return name;
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
/** The native client verifies the connected handle's owner/DACL before sending the request. */
|
|
304
|
+
export async function requestWindowsPipe(
|
|
305
|
+
path: string,
|
|
306
|
+
request: string,
|
|
307
|
+
timeoutMs: number,
|
|
308
|
+
): Promise<string> {
|
|
309
|
+
if (Buffer.byteLength(request) + 1 > 4096) {
|
|
310
|
+
throw new WindowsNativeError("too-large");
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 20 * 60_000) {
|
|
314
|
+
throw new WindowsNativeError("timeout-bound");
|
|
315
|
+
}
|
|
316
|
+
|
|
317
|
+
const deadline = Date.now() + timeoutMs;
|
|
318
|
+
let timer: ReturnType<typeof setTimeout> | undefined;
|
|
319
|
+
|
|
320
|
+
const operation = async () => {
|
|
321
|
+
const bridge = getWorker();
|
|
322
|
+
|
|
323
|
+
await bridge.ready;
|
|
324
|
+
|
|
325
|
+
const remaining = deadline - Date.now();
|
|
326
|
+
|
|
327
|
+
if (remaining <= 0) {
|
|
328
|
+
throw new WindowsNativeError("timeout");
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
return bridge.call(
|
|
332
|
+
"CLIENT",
|
|
333
|
+
[encode(pipeName(path)), encode(request), String(remaining)],
|
|
334
|
+
remaining,
|
|
335
|
+
);
|
|
336
|
+
};
|
|
337
|
+
|
|
338
|
+
try {
|
|
339
|
+
return await Promise.race([
|
|
340
|
+
operation(),
|
|
341
|
+
new Promise<never>((_resolve, reject) => {
|
|
342
|
+
timer = setTimeout(() => reject(new WindowsNativeError("timeout")), timeoutMs);
|
|
343
|
+
}),
|
|
344
|
+
]);
|
|
345
|
+
} finally {
|
|
346
|
+
clearTimeout(timer);
|
|
347
|
+
}
|
|
348
|
+
}
|
|
349
|
+
|
|
350
|
+
/** Atomically creates the first pipe instance with owner-only ACL; later instances have the
|
|
351
|
+
* same explicit ACL. The private inherited channel transports bytes to the ONE core handler. */
|
|
352
|
+
export async function startWindowsPipe(
|
|
353
|
+
path: string,
|
|
354
|
+
dispatch: (line: string, extendDeadline: () => void) => Promise<string>,
|
|
355
|
+
failed: () => void,
|
|
356
|
+
): Promise<{ close(): Promise<void> }> {
|
|
357
|
+
const child = launch("server", pipeName(path));
|
|
358
|
+
let closed = false;
|
|
359
|
+
let ready = false;
|
|
360
|
+
let resolveReady!: () => void;
|
|
361
|
+
let rejectReady!: (error: WindowsNativeError) => void;
|
|
362
|
+
const started = new Promise<void>((resolve, reject) => {
|
|
363
|
+
resolveReady = resolve;
|
|
364
|
+
rejectReady = reject;
|
|
365
|
+
});
|
|
366
|
+
const exited = new Promise<void>((resolve) => child.once("exit", () => resolve()));
|
|
367
|
+
const timer = setTimeout(() => abort(new WindowsNativeError("helper-deadline")), START_TIMEOUT);
|
|
368
|
+
|
|
369
|
+
const abort = (error: WindowsNativeError) => {
|
|
370
|
+
if (closed) {
|
|
371
|
+
return;
|
|
372
|
+
}
|
|
373
|
+
|
|
374
|
+
rejectReady(error);
|
|
375
|
+
|
|
376
|
+
if (ready) {
|
|
377
|
+
failed();
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
closed = true;
|
|
381
|
+
child.kill();
|
|
382
|
+
};
|
|
383
|
+
|
|
384
|
+
lines(
|
|
385
|
+
child,
|
|
386
|
+
(line) => {
|
|
387
|
+
if (line === "READY" && !ready) {
|
|
388
|
+
ready = true;
|
|
389
|
+
resolveReady();
|
|
390
|
+
|
|
391
|
+
return;
|
|
392
|
+
}
|
|
393
|
+
|
|
394
|
+
const [kind, id, payload, extra] = line.split("\t");
|
|
395
|
+
|
|
396
|
+
if (
|
|
397
|
+
!ready ||
|
|
398
|
+
kind !== "REQUEST" ||
|
|
399
|
+
!id ||
|
|
400
|
+
!/^[a-f0-9]{32}$/.test(id) ||
|
|
401
|
+
payload === undefined ||
|
|
402
|
+
extra !== undefined
|
|
403
|
+
) {
|
|
404
|
+
abort(new WindowsNativeError("helper-protocol"));
|
|
405
|
+
|
|
406
|
+
return;
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
const bytes = Buffer.from(payload, "base64");
|
|
410
|
+
|
|
411
|
+
if (bytes.length + 1 > 4096) {
|
|
412
|
+
abort(new WindowsNativeError("frame-bound"));
|
|
413
|
+
|
|
414
|
+
return;
|
|
415
|
+
}
|
|
416
|
+
|
|
417
|
+
void dispatch(bytes.toString("utf8"), () =>
|
|
418
|
+
child.stdin.write(`WAIT\t${id}\t1200000\n`),
|
|
419
|
+
).then(
|
|
420
|
+
(response) => {
|
|
421
|
+
if (!closed && child.stdin.writable) {
|
|
422
|
+
child.stdin.write(`REPLY\t${id}\t${encode(response)}\n`);
|
|
423
|
+
}
|
|
424
|
+
},
|
|
425
|
+
() => abort(new WindowsNativeError("dispatch-failed")),
|
|
426
|
+
);
|
|
427
|
+
},
|
|
428
|
+
abort,
|
|
429
|
+
);
|
|
430
|
+
|
|
431
|
+
try {
|
|
432
|
+
await started;
|
|
433
|
+
} finally {
|
|
434
|
+
clearTimeout(timer);
|
|
435
|
+
}
|
|
436
|
+
|
|
437
|
+
return {
|
|
438
|
+
async close() {
|
|
439
|
+
if (!closed) {
|
|
440
|
+
closed = true;
|
|
441
|
+
child.stdin.end("CLOSE\n");
|
|
442
|
+
}
|
|
443
|
+
|
|
444
|
+
const kill = setTimeout(() => child.kill(), 5000);
|
|
445
|
+
|
|
446
|
+
try {
|
|
447
|
+
await exited;
|
|
448
|
+
} finally {
|
|
449
|
+
clearTimeout(kill);
|
|
450
|
+
}
|
|
451
|
+
},
|
|
452
|
+
};
|
|
453
|
+
}
|