@bitkyc08/opencodex 2.99.0 → 2.100.0
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/AGENTS_INSTALL.md +19 -1
- package/README.md +37 -33
- package/SPONSORS.md +5 -1
- package/bin/ocx.mjs +1 -1
- package/gui/dist/assets/{App-C1hGwaN1.css → App-COo8Yopd.css} +1 -1
- package/gui/dist/assets/App-CitvEefy.js +59 -0
- package/gui/dist/assets/Tray-CeKVWQyB.js +1 -0
- package/gui/dist/assets/{brand-mark-wzPe3R-J.js → brand-mark-M92UnxX2.js} +1 -1
- package/gui/dist/assets/index-BP47do6-.js +94 -0
- package/gui/dist/assets/index-DmDooSAG.css +2 -0
- package/gui/dist/assets/{segment-thumb-features-fYEMxBaW.js → segment-thumb-features-CcxZBnxv.js} +1 -1
- package/gui/dist/classic/assets/App-aYgIQMxI.js +58 -0
- package/gui/dist/classic/assets/{Tray-BqZueZOx.js → Tray-D8jfUXpQ.js} +1 -1
- package/gui/dist/classic/assets/index-CfGqHooN.js +94 -0
- package/gui/dist/classic/assets/quota-summary-R-ih7OlS.js +1 -0
- package/gui/dist/classic/index.html +1 -1
- package/gui/dist/index.html +2 -2
- package/native/ocx-child/Cargo.lock +215 -0
- package/native/ocx-child/Cargo.toml +31 -0
- package/native/ocx-child/src/cli.rs +1901 -0
- package/native/ocx-child/src/codex_home.rs +429 -0
- package/native/ocx-child/src/codex_settings.rs +231 -0
- package/native/ocx-child/src/daemon.rs +363 -0
- package/native/ocx-child/src/http_wire.rs +619 -0
- package/native/ocx-child/src/journal.rs +977 -0
- package/native/ocx-child/src/lib.rs +22 -0
- package/native/ocx-child/src/main.rs +9 -0
- package/native/ocx-child/src/parity.rs +102 -0
- package/native/ocx-child/src/platform.rs +1487 -0
- package/native/ocx-child/src/relay.rs +1288 -0
- package/native/ocx-child/src/relay_auth.rs +166 -0
- package/native/ocx-child/src/routes.rs +236 -0
- package/native/ocx-child/src/state.rs +190 -0
- package/native/ocx-child/src/test_hooks.rs +58 -0
- package/native/ocx-child/src/toml_surgeon.rs +1156 -0
- package/package.json +8 -2
- package/src/adapters/anthropic.ts +28 -2
- package/src/adapters/claude-cli/adapter.ts +5 -25
- package/src/adapters/claude-cli/instruction-images.ts +31 -0
- package/src/adapters/claude-cli/stable-replay.ts +42 -14
- package/src/adapters/claude-cli/usage-admission.ts +53 -64
- package/src/adapters/coding-agent/protocol.ts +1 -1
- package/src/adapters/devin/live-models.ts +3 -0
- package/src/adapters/google-http.ts +3 -0
- package/src/adapters/google-vertex-key-project.ts +10 -2
- package/src/adapters/google.ts +40 -8
- package/src/adapters/kiro/usage.ts +3 -13
- package/src/adapters/openai-responses/passthrough.ts +5 -2
- package/src/adapters/openai-responses/request-strips.ts +32 -0
- package/src/adapters/openai-responses/tool-schema.ts +9 -4
- package/src/chat/inbound.ts +1 -1
- package/src/claude/auth-detect.ts +26 -8
- package/src/claude/inbound-content-options.ts +18 -3
- package/src/claude/inbound.ts +5 -2
- package/src/cli/bundled-bun-diagnostic.ts +91 -0
- package/src/cli/capabilities-agents-routing.ts +2 -2
- package/src/cli/capabilities-observe-system.ts +60 -0
- package/src/cli/combo-input.ts +6 -0
- package/src/cli/combo-result.ts +1 -1
- package/src/cli/combo.ts +4 -0
- package/src/cli/config-command.ts +16 -2
- package/src/cli/connect.ts +12 -10
- package/src/cli/dispatch.ts +4 -0
- package/src/cli/doctor.ts +11 -0
- package/src/cli/help.ts +1 -0
- package/src/cli/init.ts +4 -0
- package/src/cli/link-enrollment.ts +152 -25
- package/src/cli/link-local-control.ts +49 -0
- package/src/cli/link.ts +37 -10
- package/src/cli/provider-lifecycle-runtime.ts +4 -2
- package/src/cli/registry.ts +13 -0
- package/src/cli/star-prompt.ts +2 -0
- package/src/cli/status.ts +1 -1
- package/src/cli/telemetry-profile.ts +206 -0
- package/src/cli/telemetry.ts +260 -0
- package/src/client/hub-relay.ts +26 -0
- package/src/client/machine-api.ts +3 -0
- package/src/clients/config-export/t3code.ts +44 -5
- package/src/clients/omo-role-models.ts +1 -1
- package/src/codex/catalog/bundled.ts +44 -2
- package/src/codex/runtime.ts +12 -0
- package/src/codex/shim-restore-lock.ts +67 -30
- package/src/combos/types.ts +21 -1
- package/src/config/atomic-write.ts +24 -1
- package/src/config/diagnostics.ts +15 -0
- package/src/config/live-reconcile.ts +17 -0
- package/src/config/load-degrade.ts +16 -0
- package/src/config/provider-validation.ts +29 -0
- package/src/config/schema/config-schema.ts +24 -0
- package/src/config/schema/leaf-validators.ts +17 -0
- package/src/config/telemetry-carry.ts +30 -0
- package/src/config.ts +13 -1
- package/src/generated/compatibility-version.json +405 -153
- package/src/generated/model-metadata.ts +3 -3
- package/src/integrations/aside-profiles.ts +7 -1
- package/src/integrations/owned-refresh.ts +9 -2
- package/src/lab/artifacts/secure-fs.ts +12 -11
- package/src/lab/fabric/scratch.ts +11 -9
- package/src/lab/public/community.ts +2 -3
- package/src/lab/public/file-safety.ts +18 -20
- package/src/lab/public/mutation-lock.ts +109 -337
- package/src/lab/public/private-file.ts +4 -3
- package/src/lib/bun-runtime-preflight.ts +1 -1
- package/src/lib/codex-catalog-read-only.ts +122 -0
- package/src/lib/config-ownership.ts +49 -18
- package/src/lib/errors.ts +11 -0
- package/src/lib/gcp-adc.ts +167 -48
- package/src/lib/jsonc.ts +4 -2
- package/src/lib/local-control-socket.ts +88 -0
- package/src/lib/privacy.ts +15 -0
- package/src/lib/provider-client-headers.ts +3 -0
- package/src/lib/token-estimate.ts +13 -2
- package/src/link/child-binary-source.ts +228 -0
- package/src/link/ephemeral-child.ts +45 -0
- package/src/link/remote-plant.ts +306 -0
- package/src/link/remote-windows.ts +59 -5
- package/src/link/ssh-argv.ts +71 -8
- package/src/link/status-projection.ts +2 -0
- package/src/link/store.ts +5 -1
- package/src/oauth/claude-keychain-read.ts +165 -0
- package/src/oauth/local-token-detect.ts +14 -17
- package/src/protocols/envelope.ts +20 -2
- package/src/providers/api-key-selection.ts +8 -2
- package/src/providers/claude-cli-usage-state.ts +93 -0
- package/src/providers/github-copilot-auto.ts +25 -5
- package/src/providers/meta-muse-plan-refusal.ts +94 -0
- package/src/providers/model-rename-fields.ts +3 -0
- package/src/providers/quota/vendor-probes-key.ts +23 -4
- package/src/providers/quota/vendor-probes-oauth.ts +59 -0
- package/src/providers/quota/workbuddy.ts +2 -2
- package/src/providers/quota.ts +25 -18
- package/src/providers/registry/entries-core.ts +7 -4
- package/src/providers/registry/entries-extended.ts +39 -7
- package/src/providers/registry/model-seeds.ts +10 -2
- package/src/providers/resolved-model-policy.ts +4 -0
- package/src/providers/routed-config.ts +30 -3
- package/src/providers/stale-no-vision-seed-migration.ts +7 -0
- package/src/providers/vertex-environment-authority.ts +50 -0
- package/src/providers/workbuddy-credit-balance.ts +38 -6
- package/src/quota-pool/assemble.ts +14 -6
- package/src/router.ts +1 -0
- package/src/server/adapter-resolve.ts +11 -6
- package/src/server/audio-dictation.ts +21 -7
- package/src/server/auth-cors.ts +19 -0
- package/src/server/background-lifecycle.ts +71 -0
- package/src/server/chat-completions.ts +2 -0
- package/src/server/claude-messages.ts +30 -3
- package/src/server/index/live-sideband.ts +15 -1
- package/src/server/index/local-control-listener.ts +515 -0
- package/src/server/index/optional-listeners.ts +21 -1
- package/src/server/index/serve-options.ts +4 -3
- package/src/server/index/websocket-handler.ts +2 -0
- package/src/server/index.ts +3 -0
- package/src/server/management/combo-routes.ts +6 -1
- package/src/server/management/context.ts +1 -0
- package/src/server/management/link-child-preflight.ts +74 -0
- package/src/server/management/link-enrollment.ts +190 -25
- package/src/server/management/link-route-state.ts +6 -1
- package/src/server/management/link-routes.ts +27 -9
- package/src/server/management/model-rows.ts +4 -0
- package/src/server/management/oauth-account-routes.ts +9 -4
- package/src/server/management/provider-overwrite-carry.ts +9 -2
- package/src/server/management/provider-routes.ts +14 -0
- package/src/server/management/provider-thinking-display-patch.ts +54 -0
- package/src/server/management/route-registry.ts +7 -0
- package/src/server/management/session-routes.ts +4 -1
- package/src/server/management/telemetry-routes.ts +37 -0
- package/src/server/management/usage-aggregate-cache.ts +290 -67
- package/src/server/management-api.ts +11 -2
- package/src/server/messages-native-preflight.ts +166 -0
- package/src/server/messages-native.ts +143 -43
- package/src/server/messages-shared.ts +14 -0
- package/src/server/proxy-liveness.ts +99 -6
- package/src/server/request-log-conversation.ts +18 -2
- package/src/server/request-log.ts +7 -2
- package/src/server/responses/adapter-continuation.ts +1 -0
- package/src/server/responses/adapter-dispatch.ts +11 -28
- package/src/server/responses/adapter-failure-message.ts +68 -0
- package/src/server/responses/combo-stream-preflight.ts +14 -2
- package/src/server/responses/core-auth.ts +26 -5
- package/src/server/responses/core-codex-account.ts +8 -1
- package/src/server/responses/core-combo-failure.ts +6 -1
- package/src/server/responses/core-combo-native.ts +150 -37
- package/src/server/responses/core-combo.ts +15 -9
- package/src/server/responses/core-normalize.ts +1 -0
- package/src/server/responses/core-options.ts +7 -1
- package/src/server/responses/core-pipeline.ts +21 -1
- package/src/server/responses/fetch-helpers.ts +5 -0
- package/src/server/responses/opengateway-completion-guard.ts +7 -3
- package/src/server/responses/passthrough-delivery.ts +8 -1
- package/src/server/responses/passthrough-error.ts +22 -0
- package/src/server/responses/request-prepare.ts +7 -1
- package/src/server/responses/request-transport.ts +28 -5
- package/src/server/responses/run-turn-execution.ts +13 -0
- package/src/server/sse-frame-buffer.ts +5 -0
- package/src/server/ws-bridge.ts +10 -0
- package/src/service/launchd.ts +78 -4
- package/src/telemetry/aggregate.ts +348 -0
- package/src/telemetry/consent.ts +128 -0
- package/src/telemetry/contract.ts +403 -0
- package/src/telemetry/disclosure.ts +19 -0
- package/src/telemetry/install-id.ts +226 -0
- package/src/telemetry/payload.ts +129 -0
- package/src/telemetry/profile/client.ts +150 -0
- package/src/telemetry/profile/contract.ts +288 -0
- package/src/telemetry/profile/disclosure.ts +14 -0
- package/src/telemetry/profile/paths.ts +13 -0
- package/src/telemetry/profile/routes.ts +99 -0
- package/src/telemetry/profile/service.ts +234 -0
- package/src/telemetry/profile/state.ts +189 -0
- package/src/telemetry/profile/sync.ts +276 -0
- package/src/telemetry/routes.ts +183 -0
- package/src/telemetry/scheduler.ts +386 -0
- package/src/telemetry/sender.ts +97 -0
- package/src/telemetry/state.ts +334 -0
- package/src/types/combo-jev-effort-mode.ts +11 -0
- package/src/types/config.ts +3 -0
- package/src/types/provider.ts +11 -1
- package/src/types/request.ts +2 -0
- package/src/types/telemetry.ts +15 -0
- package/src/types/wire.ts +10 -0
- package/src/types.ts +5 -0
- package/src/update/index.ts +7 -1
- package/src/update/minisign.d.mts +17 -0
- package/src/update/minisign.mjs +88 -0
- package/src/update/signed-supply.d.mts +59 -0
- package/src/update/signed-supply.mjs +289 -0
- package/src/update/trust-root.json +38 -0
- package/src/update/update-bounded-json.d.mts +4 -0
- package/src/update/update-bounded-json.mjs +113 -0
- package/src/update/update-bytes.d.mts +2 -0
- package/src/update/update-bytes.mjs +23 -0
- package/src/update/update-candidate-id.d.mts +2 -0
- package/src/update/update-candidate-id.mjs +23 -0
- package/src/update/update-checkpoint-codec.d.mts +33 -0
- package/src/update/update-checkpoint-codec.mjs +217 -0
- package/src/update/update-contracts.d.mts +24 -0
- package/src/update/update-contracts.mjs +207 -0
- package/src/update/update-signature-threshold.d.mts +12 -0
- package/src/update/update-signature-threshold.mjs +47 -0
- package/src/update/update-signed-version.d.mts +5 -0
- package/src/update/update-signed-version.mjs +25 -0
- package/src/update/update-trust-anchor.d.mts +2 -0
- package/src/update/update-trust-anchor.mjs +2 -0
- package/src/usage/cache-diagnostic.ts +195 -50
- package/src/usage/expected-prices.ts +20 -2
- package/src/usage/filter-index.ts +1469 -0
- package/src/usage/ledger-scanner.ts +245 -4
- package/src/usage/source-filter.ts +10 -2
- package/src/usage/summary.ts +16 -0
- package/src/web-search/parse.ts +244 -38
- package/gui/dist/assets/App-BepstgEN.js +0 -59
- package/gui/dist/assets/Tray-BinxbEZo.js +0 -1
- package/gui/dist/assets/index-C-9X2yaI.js +0 -94
- package/gui/dist/assets/index-bnUWypyz.css +0 -2
- package/gui/dist/classic/assets/App-DX88_GCW.js +0 -58
- package/gui/dist/classic/assets/index-fSP71pLB.js +0 -94
- package/gui/dist/classic/assets/quota-summary-y2fl0WBv.js +0 -1
|
@@ -0,0 +1,1487 @@
|
|
|
1
|
+
use std::fs::{self, File, OpenOptions};
|
|
2
|
+
#[cfg(unix)]
|
|
3
|
+
use std::io::Read;
|
|
4
|
+
use std::io::Write;
|
|
5
|
+
use std::path::{Path, PathBuf};
|
|
6
|
+
use std::process::{Command, Stdio};
|
|
7
|
+
use std::sync::atomic::{Ordering, compiler_fence};
|
|
8
|
+
use std::time::{SystemTime, UNIX_EPOCH};
|
|
9
|
+
|
|
10
|
+
use serde::{Deserialize, Serialize};
|
|
11
|
+
use sha2::{Digest, Sha256};
|
|
12
|
+
|
|
13
|
+
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
14
|
+
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
|
15
|
+
pub struct DirectoryIdentity {
|
|
16
|
+
pub volume: u64,
|
|
17
|
+
pub file_id: [u8; 16],
|
|
18
|
+
}
|
|
19
|
+
|
|
20
|
+
pub fn directory_identity(path: &Path) -> Result<DirectoryIdentity, String> {
|
|
21
|
+
#[cfg(unix)]
|
|
22
|
+
{
|
|
23
|
+
use std::os::unix::fs::MetadataExt;
|
|
24
|
+
let directory = File::open(path).map_err(|e| format!("cannot open directory: {e}"))?;
|
|
25
|
+
let metadata = directory
|
|
26
|
+
.metadata()
|
|
27
|
+
.map_err(|e| format!("cannot inspect directory: {e}"))?;
|
|
28
|
+
if !metadata.is_dir() {
|
|
29
|
+
return Err("expected a directory".to_owned());
|
|
30
|
+
}
|
|
31
|
+
let mut file_id = [0u8; 16];
|
|
32
|
+
file_id[..8].copy_from_slice(&metadata.ino().to_le_bytes());
|
|
33
|
+
Ok(DirectoryIdentity {
|
|
34
|
+
volume: metadata.dev(),
|
|
35
|
+
file_id,
|
|
36
|
+
})
|
|
37
|
+
}
|
|
38
|
+
#[cfg(windows)]
|
|
39
|
+
{
|
|
40
|
+
use std::os::windows::fs::{MetadataExt, OpenOptionsExt};
|
|
41
|
+
use std::os::windows::io::AsRawHandle;
|
|
42
|
+
#[repr(C)]
|
|
43
|
+
struct FileIdInfo {
|
|
44
|
+
volume: u64,
|
|
45
|
+
file_id: [u8; 16],
|
|
46
|
+
}
|
|
47
|
+
#[link(name = "kernel32")]
|
|
48
|
+
unsafe extern "system" {
|
|
49
|
+
fn GetFileInformationByHandleEx(
|
|
50
|
+
file: *mut std::ffi::c_void,
|
|
51
|
+
class: u32,
|
|
52
|
+
info: *mut std::ffi::c_void,
|
|
53
|
+
size: u32,
|
|
54
|
+
) -> i32;
|
|
55
|
+
}
|
|
56
|
+
let directory = OpenOptions::new()
|
|
57
|
+
.read(true)
|
|
58
|
+
.custom_flags(0x02000000 | 0x00200000)
|
|
59
|
+
.open(path)
|
|
60
|
+
.map_err(|e| format!("cannot open directory: {e}"))?;
|
|
61
|
+
let metadata = directory
|
|
62
|
+
.metadata()
|
|
63
|
+
.map_err(|e| format!("cannot inspect directory: {e}"))?;
|
|
64
|
+
if !metadata.is_dir() || metadata.file_attributes() & 0x400 != 0 {
|
|
65
|
+
return Err("expected a directory".to_owned());
|
|
66
|
+
}
|
|
67
|
+
let mut info = FileIdInfo {
|
|
68
|
+
volume: 0,
|
|
69
|
+
file_id: [0; 16],
|
|
70
|
+
};
|
|
71
|
+
// SAFETY: The open directory handle and output buffer remain valid for the call.
|
|
72
|
+
if unsafe {
|
|
73
|
+
GetFileInformationByHandleEx(
|
|
74
|
+
directory.as_raw_handle(),
|
|
75
|
+
18,
|
|
76
|
+
(&mut info as *mut FileIdInfo).cast(),
|
|
77
|
+
std::mem::size_of::<FileIdInfo>() as u32,
|
|
78
|
+
)
|
|
79
|
+
} == 0
|
|
80
|
+
{
|
|
81
|
+
return Err(format!(
|
|
82
|
+
"cannot inspect directory identity: {}",
|
|
83
|
+
std::io::Error::last_os_error()
|
|
84
|
+
));
|
|
85
|
+
}
|
|
86
|
+
Ok(DirectoryIdentity {
|
|
87
|
+
volume: info.volume,
|
|
88
|
+
file_id: info.file_id,
|
|
89
|
+
})
|
|
90
|
+
}
|
|
91
|
+
#[cfg(not(any(unix, windows)))]
|
|
92
|
+
{
|
|
93
|
+
let _ = path;
|
|
94
|
+
Err("directory identity is unavailable on this platform".to_owned())
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
/// Zeroes sensitive heap bytes on drop using volatile writes so the compiler cannot elide scrubbing.
|
|
99
|
+
pub struct SecretBytes(Vec<u8>);
|
|
100
|
+
|
|
101
|
+
impl SecretBytes {
|
|
102
|
+
pub fn new(bytes: Vec<u8>) -> Self {
|
|
103
|
+
Self(bytes)
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
pub fn as_slice(&self) -> &[u8] {
|
|
107
|
+
&self.0
|
|
108
|
+
}
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
impl Drop for SecretBytes {
|
|
112
|
+
fn drop(&mut self) {
|
|
113
|
+
volatile_zero_bytes(&mut self.0);
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
/// A secret string that is wiped on drop, so every copy of it (a clone, or a state read that is
|
|
118
|
+
/// dropped) is scrubbed. Serialized as a plain string; `Debug` never prints it.
|
|
119
|
+
#[derive(Clone, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
|
120
|
+
#[serde(transparent)]
|
|
121
|
+
pub struct SecretString(String);
|
|
122
|
+
|
|
123
|
+
impl SecretString {
|
|
124
|
+
pub fn new(value: String) -> Self {
|
|
125
|
+
Self(value)
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
pub fn as_str(&self) -> &str {
|
|
129
|
+
&self.0
|
|
130
|
+
}
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
impl From<String> for SecretString {
|
|
134
|
+
fn from(value: String) -> Self {
|
|
135
|
+
Self(value)
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
impl std::ops::Deref for SecretString {
|
|
140
|
+
type Target = str;
|
|
141
|
+
|
|
142
|
+
fn deref(&self) -> &str {
|
|
143
|
+
&self.0
|
|
144
|
+
}
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
impl std::fmt::Debug for SecretString {
|
|
148
|
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
149
|
+
f.write_str("SecretString(<redacted>)")
|
|
150
|
+
}
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
impl Drop for SecretString {
|
|
154
|
+
fn drop(&mut self) {
|
|
155
|
+
// SAFETY: Zero bytes are valid UTF-8, so the string stays valid while it is wiped.
|
|
156
|
+
volatile_zero_bytes(unsafe { self.0.as_bytes_mut() });
|
|
157
|
+
}
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
pub fn volatile_zero_bytes(buf: &mut [u8]) {
|
|
161
|
+
for byte in buf.iter_mut() {
|
|
162
|
+
// SAFETY: `byte` is a valid mutable reference to an initialized `u8` inside `buf`.
|
|
163
|
+
unsafe { std::ptr::write_volatile(byte, 0) };
|
|
164
|
+
}
|
|
165
|
+
compiler_fence(Ordering::SeqCst);
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
pub fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
|
|
169
|
+
if a.len() != b.len() {
|
|
170
|
+
return false;
|
|
171
|
+
}
|
|
172
|
+
let mut diff = 0u8;
|
|
173
|
+
for (&x, &y) in a.iter().zip(b.iter()) {
|
|
174
|
+
diff |= x ^ y;
|
|
175
|
+
}
|
|
176
|
+
diff == 0
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
pub fn sha256_bytes(data: &[u8]) -> [u8; 32] {
|
|
180
|
+
let mut hasher = Sha256::new();
|
|
181
|
+
hasher.update(data);
|
|
182
|
+
hasher.finalize().into()
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
pub fn sha256_hex(data: &[u8]) -> String {
|
|
186
|
+
hex_encode(&sha256_bytes(data))
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
pub fn hex_encode(bytes: &[u8]) -> String {
|
|
190
|
+
const LUT: &[u8; 16] = b"0123456789abcdef";
|
|
191
|
+
let mut out = String::with_capacity(bytes.len() * 2);
|
|
192
|
+
for &b in bytes {
|
|
193
|
+
out.push(LUT[(b >> 4) as usize] as char);
|
|
194
|
+
out.push(LUT[(b & 0x0f) as usize] as char);
|
|
195
|
+
}
|
|
196
|
+
out
|
|
197
|
+
}
|
|
198
|
+
|
|
199
|
+
pub fn hex_decode_lower(input: &str) -> Option<Vec<u8>> {
|
|
200
|
+
if !input.len().is_multiple_of(2) {
|
|
201
|
+
return None;
|
|
202
|
+
}
|
|
203
|
+
let mut out = Vec::with_capacity(input.len() / 2);
|
|
204
|
+
let bytes = input.as_bytes();
|
|
205
|
+
let mut i = 0;
|
|
206
|
+
while i < bytes.len() {
|
|
207
|
+
let hi = hex_nibble_lower(bytes[i])?;
|
|
208
|
+
let lo = hex_nibble_lower(bytes[i + 1])?;
|
|
209
|
+
out.push((hi << 4) | lo);
|
|
210
|
+
i += 2;
|
|
211
|
+
}
|
|
212
|
+
Some(out)
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
fn hex_nibble_lower(b: u8) -> Option<u8> {
|
|
216
|
+
match b {
|
|
217
|
+
b'0'..=b'9' => Some(b - b'0'),
|
|
218
|
+
b'a'..=b'f' => Some(b - b'a' + 10),
|
|
219
|
+
_ => None,
|
|
220
|
+
}
|
|
221
|
+
}
|
|
222
|
+
|
|
223
|
+
pub fn now_epoch_ms() -> u64 {
|
|
224
|
+
SystemTime::now()
|
|
225
|
+
.duration_since(UNIX_EPOCH)
|
|
226
|
+
.map(|d| d.as_millis() as u64)
|
|
227
|
+
.unwrap_or(1_760_000_000_000)
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
/// Formats epoch milliseconds as ISO-8601 UTC (`YYYY-MM-DDTHH:MM:SS.mmmZ`).
|
|
231
|
+
pub fn format_iso8601_utc(epoch_ms: u64) -> String {
|
|
232
|
+
let total_secs = (epoch_ms / 1000) as i64;
|
|
233
|
+
let millis = epoch_ms % 1000;
|
|
234
|
+
let days = total_secs.div_euclid(86_400);
|
|
235
|
+
let secs_of_day = total_secs.rem_euclid(86_400) as u32;
|
|
236
|
+
let hour = secs_of_day / 3600;
|
|
237
|
+
let minute = (secs_of_day % 3600) / 60;
|
|
238
|
+
let second = secs_of_day % 60;
|
|
239
|
+
// Howard Hinnant civil_from_days algorithm
|
|
240
|
+
let z = days + 719_468;
|
|
241
|
+
let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
|
|
242
|
+
let doe = (z - era * 146_097) as u32;
|
|
243
|
+
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
|
|
244
|
+
let y = yoe as i64 + era * 400;
|
|
245
|
+
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
|
|
246
|
+
let mp = (5 * doy + 2) / 153;
|
|
247
|
+
let d = doy - (153 * mp + 2) / 5 + 1;
|
|
248
|
+
let m = if mp < 10 { mp + 3 } else { mp - 9 };
|
|
249
|
+
let year = if m <= 2 { y + 1 } else { y };
|
|
250
|
+
format!("{year:04}-{m:02}-{d:02}T{hour:02}:{minute:02}:{second:02}.{millis:03}Z")
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
#[cfg(unix)]
|
|
254
|
+
unsafe extern "C" {
|
|
255
|
+
fn flock(fd: i32, operation: i32) -> i32;
|
|
256
|
+
fn setsid() -> i32;
|
|
257
|
+
fn kill(pid: i32, sig: i32) -> i32;
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
#[cfg(windows)]
|
|
261
|
+
#[repr(C)]
|
|
262
|
+
struct Overlapped {
|
|
263
|
+
internal: usize,
|
|
264
|
+
internal_high: usize,
|
|
265
|
+
offset: u32,
|
|
266
|
+
offset_high: u32,
|
|
267
|
+
event: *mut std::ffi::c_void,
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
#[cfg(windows)]
|
|
271
|
+
#[link(name = "kernel32")]
|
|
272
|
+
unsafe extern "system" {
|
|
273
|
+
fn LockFileEx(
|
|
274
|
+
file: *mut std::ffi::c_void,
|
|
275
|
+
flags: u32,
|
|
276
|
+
reserved: u32,
|
|
277
|
+
bytes_low: u32,
|
|
278
|
+
bytes_high: u32,
|
|
279
|
+
overlapped: *mut Overlapped,
|
|
280
|
+
) -> i32;
|
|
281
|
+
fn UnlockFileEx(
|
|
282
|
+
file: *mut std::ffi::c_void,
|
|
283
|
+
reserved: u32,
|
|
284
|
+
bytes_low: u32,
|
|
285
|
+
bytes_high: u32,
|
|
286
|
+
overlapped: *mut Overlapped,
|
|
287
|
+
) -> i32;
|
|
288
|
+
fn OpenProcess(
|
|
289
|
+
desired_access: u32,
|
|
290
|
+
inherit_handle: i32,
|
|
291
|
+
process_id: u32,
|
|
292
|
+
) -> *mut std::ffi::c_void;
|
|
293
|
+
fn WaitForSingleObject(handle: *mut std::ffi::c_void, milliseconds: u32) -> u32;
|
|
294
|
+
fn CloseHandle(object: *mut std::ffi::c_void) -> i32;
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
#[cfg(windows)]
|
|
298
|
+
#[link(name = "bcrypt")]
|
|
299
|
+
unsafe extern "system" {
|
|
300
|
+
fn BCryptGenRandom(
|
|
301
|
+
algorithm: *mut std::ffi::c_void,
|
|
302
|
+
buffer: *mut u8,
|
|
303
|
+
bytes: u32,
|
|
304
|
+
flags: u32,
|
|
305
|
+
) -> i32;
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
pub fn fill_random_bytes(dest: &mut [u8]) -> Result<(), String> {
|
|
309
|
+
#[cfg(unix)]
|
|
310
|
+
{
|
|
311
|
+
let mut f =
|
|
312
|
+
File::open("/dev/urandom").map_err(|e| format!("failed to open /dev/urandom: {e}"))?;
|
|
313
|
+
f.read_exact(dest)
|
|
314
|
+
.map_err(|e| format!("failed to read /dev/urandom: {e}"))?;
|
|
315
|
+
Ok(())
|
|
316
|
+
}
|
|
317
|
+
#[cfg(windows)]
|
|
318
|
+
{
|
|
319
|
+
const BCRYPT_USE_SYSTEM_PREFERRED_RNG: u32 = 0x0000_0002;
|
|
320
|
+
// SAFETY: `dest` is a valid mutable slice of `dest.len()` bytes.
|
|
321
|
+
let status = unsafe {
|
|
322
|
+
BCryptGenRandom(
|
|
323
|
+
std::ptr::null_mut(),
|
|
324
|
+
dest.as_mut_ptr(),
|
|
325
|
+
dest.len() as u32,
|
|
326
|
+
BCRYPT_USE_SYSTEM_PREFERRED_RNG,
|
|
327
|
+
)
|
|
328
|
+
};
|
|
329
|
+
if status != 0 {
|
|
330
|
+
return Err(format!(
|
|
331
|
+
"BCryptGenRandom failed with NTSTATUS 0x{status:08x}"
|
|
332
|
+
));
|
|
333
|
+
}
|
|
334
|
+
Ok(())
|
|
335
|
+
}
|
|
336
|
+
}
|
|
337
|
+
|
|
338
|
+
pub fn random_hex(byte_len: usize) -> Result<String, String> {
|
|
339
|
+
let mut buf = vec![0u8; byte_len];
|
|
340
|
+
fill_random_bytes(&mut buf)?;
|
|
341
|
+
Ok(hex_encode(&buf))
|
|
342
|
+
}
|
|
343
|
+
|
|
344
|
+
/// `O_NOFOLLOW` for the open(2) flags of this target, from the libc crate's definitions.
|
|
345
|
+
#[cfg(any(
|
|
346
|
+
target_os = "macos",
|
|
347
|
+
target_os = "ios",
|
|
348
|
+
target_os = "freebsd",
|
|
349
|
+
target_os = "netbsd",
|
|
350
|
+
target_os = "openbsd",
|
|
351
|
+
target_os = "dragonfly"
|
|
352
|
+
))]
|
|
353
|
+
const O_NOFOLLOW: i32 = 0x0100;
|
|
354
|
+
#[cfg(all(
|
|
355
|
+
any(target_os = "linux", target_os = "android"),
|
|
356
|
+
any(
|
|
357
|
+
target_arch = "aarch64",
|
|
358
|
+
target_arch = "arm",
|
|
359
|
+
target_arch = "powerpc",
|
|
360
|
+
target_arch = "powerpc64",
|
|
361
|
+
target_arch = "m68k"
|
|
362
|
+
)
|
|
363
|
+
))]
|
|
364
|
+
const O_NOFOLLOW: i32 = 0x8000;
|
|
365
|
+
#[cfg(any(
|
|
366
|
+
all(
|
|
367
|
+
any(target_os = "linux", target_os = "android"),
|
|
368
|
+
not(any(
|
|
369
|
+
target_arch = "aarch64",
|
|
370
|
+
target_arch = "arm",
|
|
371
|
+
target_arch = "powerpc",
|
|
372
|
+
target_arch = "powerpc64",
|
|
373
|
+
target_arch = "m68k"
|
|
374
|
+
))
|
|
375
|
+
),
|
|
376
|
+
target_os = "solaris",
|
|
377
|
+
target_os = "illumos"
|
|
378
|
+
))]
|
|
379
|
+
const O_NOFOLLOW: i32 = 0x2_0000;
|
|
380
|
+
|
|
381
|
+
pub fn reject_symlink(path: &Path) -> Result<(), String> {
|
|
382
|
+
match fs::symlink_metadata(path) {
|
|
383
|
+
Ok(meta) if meta.file_type().is_symlink() => {
|
|
384
|
+
Err(format!("refusing symlinked path: {}", path.display()))
|
|
385
|
+
}
|
|
386
|
+
#[cfg(windows)]
|
|
387
|
+
Ok(meta) => {
|
|
388
|
+
use std::os::windows::fs::MetadataExt;
|
|
389
|
+
if meta.file_attributes() & 0x400 != 0 {
|
|
390
|
+
return Err(format!("refusing reparse point: {}", path.display()));
|
|
391
|
+
}
|
|
392
|
+
Ok(())
|
|
393
|
+
}
|
|
394
|
+
#[cfg(not(windows))]
|
|
395
|
+
Ok(_) => Ok(()),
|
|
396
|
+
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
|
|
397
|
+
Err(e) => Err(format!("failed to inspect {}: {e}", path.display())),
|
|
398
|
+
}
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
#[cfg(windows)]
|
|
402
|
+
mod windows_private_acl {
|
|
403
|
+
use std::ffi::c_void;
|
|
404
|
+
use std::fs::File;
|
|
405
|
+
use std::os::windows::ffi::OsStrExt;
|
|
406
|
+
use std::os::windows::io::FromRawHandle;
|
|
407
|
+
use std::path::Path;
|
|
408
|
+
use std::ptr;
|
|
409
|
+
|
|
410
|
+
type Ptr = *mut c_void;
|
|
411
|
+
const ACL_REVISION: u32 = 2;
|
|
412
|
+
const FULL_CONTROL: u32 = 0x1f01ff;
|
|
413
|
+
const OBJECT_INHERIT_ACE: u32 = 0x1;
|
|
414
|
+
const CONTAINER_INHERIT_ACE: u32 = 0x2;
|
|
415
|
+
const SE_FILE_OBJECT: u32 = 1;
|
|
416
|
+
const DACL_SECURITY_INFORMATION: u32 = 4;
|
|
417
|
+
const PROTECTED_DACL_SECURITY_INFORMATION: u32 = 0x80000000;
|
|
418
|
+
|
|
419
|
+
#[repr(C)]
|
|
420
|
+
struct Acl {
|
|
421
|
+
revision: u8,
|
|
422
|
+
reserved: u8,
|
|
423
|
+
size: u16,
|
|
424
|
+
count: u16,
|
|
425
|
+
reserved2: u16,
|
|
426
|
+
}
|
|
427
|
+
|
|
428
|
+
#[repr(C)]
|
|
429
|
+
struct AceHeader {
|
|
430
|
+
kind: u8,
|
|
431
|
+
flags: u8,
|
|
432
|
+
size: u16,
|
|
433
|
+
}
|
|
434
|
+
|
|
435
|
+
#[repr(C)]
|
|
436
|
+
struct SecurityDescriptor {
|
|
437
|
+
revision: u8,
|
|
438
|
+
reserved: u8,
|
|
439
|
+
control: u16,
|
|
440
|
+
owner: Ptr,
|
|
441
|
+
group: Ptr,
|
|
442
|
+
sacl: Ptr,
|
|
443
|
+
dacl: Ptr,
|
|
444
|
+
}
|
|
445
|
+
|
|
446
|
+
#[repr(C)]
|
|
447
|
+
struct SecurityAttributes {
|
|
448
|
+
length: u32,
|
|
449
|
+
descriptor: Ptr,
|
|
450
|
+
inherit_handle: i32,
|
|
451
|
+
}
|
|
452
|
+
|
|
453
|
+
#[link(name = "advapi32")]
|
|
454
|
+
unsafe extern "system" {
|
|
455
|
+
fn OpenProcessToken(process: Ptr, access: u32, token: *mut Ptr) -> i32;
|
|
456
|
+
fn GetTokenInformation(
|
|
457
|
+
token: Ptr,
|
|
458
|
+
class: u32,
|
|
459
|
+
info: Ptr,
|
|
460
|
+
size: u32,
|
|
461
|
+
needed: *mut u32,
|
|
462
|
+
) -> i32;
|
|
463
|
+
fn CreateWellKnownSid(kind: u32, domain: Ptr, sid: Ptr, size: *mut u32) -> i32;
|
|
464
|
+
fn InitializeAcl(acl: *mut Acl, size: u32, revision: u32) -> i32;
|
|
465
|
+
fn AddAccessAllowedAceEx(
|
|
466
|
+
acl: *mut Acl,
|
|
467
|
+
revision: u32,
|
|
468
|
+
flags: u32,
|
|
469
|
+
mask: u32,
|
|
470
|
+
sid: Ptr,
|
|
471
|
+
) -> i32;
|
|
472
|
+
fn SetNamedSecurityInfoW(
|
|
473
|
+
name: *mut u16,
|
|
474
|
+
kind: u32,
|
|
475
|
+
info: u32,
|
|
476
|
+
owner: Ptr,
|
|
477
|
+
group: Ptr,
|
|
478
|
+
dacl: *mut Acl,
|
|
479
|
+
sacl: *mut Acl,
|
|
480
|
+
) -> u32;
|
|
481
|
+
fn GetNamedSecurityInfoW(
|
|
482
|
+
name: *const u16,
|
|
483
|
+
kind: u32,
|
|
484
|
+
info: u32,
|
|
485
|
+
owner: *mut Ptr,
|
|
486
|
+
group: *mut Ptr,
|
|
487
|
+
dacl: *mut *mut Acl,
|
|
488
|
+
sacl: *mut *mut Acl,
|
|
489
|
+
descriptor: *mut Ptr,
|
|
490
|
+
) -> u32;
|
|
491
|
+
fn GetSecurityDescriptorControl(
|
|
492
|
+
descriptor: Ptr,
|
|
493
|
+
control: *mut u16,
|
|
494
|
+
revision: *mut u32,
|
|
495
|
+
) -> i32;
|
|
496
|
+
fn GetSecurityDescriptorDacl(
|
|
497
|
+
descriptor: Ptr,
|
|
498
|
+
present: *mut i32,
|
|
499
|
+
dacl: *mut *mut Acl,
|
|
500
|
+
defaulted: *mut i32,
|
|
501
|
+
) -> i32;
|
|
502
|
+
fn EqualSid(a: Ptr, b: Ptr) -> i32;
|
|
503
|
+
fn IsValidSid(sid: Ptr) -> i32;
|
|
504
|
+
fn IsValidAcl(acl: *mut Acl) -> i32;
|
|
505
|
+
fn GetAce(acl: *mut Acl, index: u32, ace: *mut Ptr) -> i32;
|
|
506
|
+
fn GetLengthSid(sid: Ptr) -> u32;
|
|
507
|
+
fn InitializeSecurityDescriptor(descriptor: Ptr, revision: u32) -> i32;
|
|
508
|
+
fn SetSecurityDescriptorDacl(
|
|
509
|
+
descriptor: Ptr,
|
|
510
|
+
present: i32,
|
|
511
|
+
dacl: *mut Acl,
|
|
512
|
+
defaulted: i32,
|
|
513
|
+
) -> i32;
|
|
514
|
+
fn SetSecurityDescriptorControl(descriptor: Ptr, mask: u16, control: u16) -> i32;
|
|
515
|
+
}
|
|
516
|
+
|
|
517
|
+
#[link(name = "kernel32")]
|
|
518
|
+
unsafe extern "system" {
|
|
519
|
+
fn GetCurrentProcess() -> Ptr;
|
|
520
|
+
fn CloseHandle(handle: Ptr) -> i32;
|
|
521
|
+
fn LocalFree(memory: Ptr) -> Ptr;
|
|
522
|
+
fn CreateFileW(
|
|
523
|
+
name: *const u16,
|
|
524
|
+
access: u32,
|
|
525
|
+
share: u32,
|
|
526
|
+
attributes: *mut SecurityAttributes,
|
|
527
|
+
disposition: u32,
|
|
528
|
+
flags: u32,
|
|
529
|
+
template: Ptr,
|
|
530
|
+
) -> Ptr;
|
|
531
|
+
}
|
|
532
|
+
|
|
533
|
+
struct Local(Ptr);
|
|
534
|
+
impl Drop for Local {
|
|
535
|
+
fn drop(&mut self) {
|
|
536
|
+
if !self.0.is_null() {
|
|
537
|
+
// SAFETY: `self.0` was allocated by `GetNamedSecurityInfoW`.
|
|
538
|
+
unsafe {
|
|
539
|
+
LocalFree(self.0);
|
|
540
|
+
}
|
|
541
|
+
}
|
|
542
|
+
}
|
|
543
|
+
}
|
|
544
|
+
|
|
545
|
+
struct Token(Ptr);
|
|
546
|
+
impl Drop for Token {
|
|
547
|
+
fn drop(&mut self) {
|
|
548
|
+
// SAFETY: `self.0` is an open process token handle.
|
|
549
|
+
unsafe {
|
|
550
|
+
CloseHandle(self.0);
|
|
551
|
+
}
|
|
552
|
+
}
|
|
553
|
+
}
|
|
554
|
+
|
|
555
|
+
fn current_user_sid() -> Result<Vec<usize>, String> {
|
|
556
|
+
let mut token = ptr::null_mut();
|
|
557
|
+
// SAFETY: Queries current process token for TOKEN_QUERY (0x8).
|
|
558
|
+
if unsafe { OpenProcessToken(GetCurrentProcess(), 0x8, &mut token) } == 0 {
|
|
559
|
+
return Err("private-acl-unsafe: OpenProcessToken failed".to_owned());
|
|
560
|
+
}
|
|
561
|
+
let token = Token(token);
|
|
562
|
+
let mut needed = 0u32;
|
|
563
|
+
// SAFETY: First call sizes TokenUser (1).
|
|
564
|
+
unsafe {
|
|
565
|
+
GetTokenInformation(token.0, 1, ptr::null_mut(), 0, &mut needed);
|
|
566
|
+
}
|
|
567
|
+
if needed < std::mem::size_of::<usize>() as u32 || needed > 65536 {
|
|
568
|
+
return Err("private-acl-unsafe: invalid token user size".to_owned());
|
|
569
|
+
}
|
|
570
|
+
let mut buf = vec![0usize; (needed as usize).div_ceil(std::mem::size_of::<usize>())];
|
|
571
|
+
// SAFETY: `buf` has `>= needed` bytes aligned to `usize`.
|
|
572
|
+
if unsafe { GetTokenInformation(token.0, 1, buf.as_mut_ptr().cast(), needed, &mut needed) }
|
|
573
|
+
== 0
|
|
574
|
+
{
|
|
575
|
+
return Err("private-acl-unsafe: GetTokenInformation failed".to_owned());
|
|
576
|
+
}
|
|
577
|
+
// SAFETY: `buf[0]` holds the `PSID` pointer inside `TOKEN_USER`.
|
|
578
|
+
if unsafe { IsValidSid(buf[0] as Ptr) } == 0 {
|
|
579
|
+
return Err("private-acl-unsafe: invalid user SID".to_owned());
|
|
580
|
+
}
|
|
581
|
+
Ok(buf)
|
|
582
|
+
}
|
|
583
|
+
|
|
584
|
+
fn wide_nul(path: &Path) -> Result<Vec<u16>, String> {
|
|
585
|
+
let out: Vec<u16> = path.as_os_str().encode_wide().collect();
|
|
586
|
+
if out.contains(&0) {
|
|
587
|
+
return Err("private-acl-unsafe: interior NUL".to_owned());
|
|
588
|
+
}
|
|
589
|
+
Ok(out.into_iter().chain(Some(0)).collect())
|
|
590
|
+
}
|
|
591
|
+
|
|
592
|
+
fn well_known_sid(kind: u32) -> Result<[u32; 17], String> {
|
|
593
|
+
let mut sid = [0u32; 17];
|
|
594
|
+
let mut size = std::mem::size_of_val(&sid) as u32;
|
|
595
|
+
// SAFETY: `sid` is 68 bytes (SECURITY_MAX_SID_SIZE), DWORD-aligned.
|
|
596
|
+
if unsafe { CreateWellKnownSid(kind, ptr::null_mut(), sid.as_mut_ptr().cast(), &mut size) }
|
|
597
|
+
== 0
|
|
598
|
+
{
|
|
599
|
+
return Err("private-acl-unsafe: CreateWellKnownSid failed".to_owned());
|
|
600
|
+
}
|
|
601
|
+
Ok(sid)
|
|
602
|
+
}
|
|
603
|
+
|
|
604
|
+
fn private_acl(
|
|
605
|
+
directory: bool,
|
|
606
|
+
) -> Result<(Vec<usize>, [u32; 17], [u32; 17], Vec<u32>), String> {
|
|
607
|
+
let user = current_user_sid()?;
|
|
608
|
+
let mut system = well_known_sid(22)?;
|
|
609
|
+
let mut admins = well_known_sid(26)?;
|
|
610
|
+
let sids: Vec<Ptr> = if directory {
|
|
611
|
+
vec![
|
|
612
|
+
user[0] as Ptr,
|
|
613
|
+
system.as_mut_ptr().cast(),
|
|
614
|
+
admins.as_mut_ptr().cast(),
|
|
615
|
+
]
|
|
616
|
+
} else {
|
|
617
|
+
vec![user[0] as Ptr]
|
|
618
|
+
};
|
|
619
|
+
// SAFETY: All 3 SIDs were validated by `IsValidSid` / `CreateWellKnownSid`.
|
|
620
|
+
let acl_bytes = std::mem::size_of::<Acl>() as u32
|
|
621
|
+
+ sids
|
|
622
|
+
.iter()
|
|
623
|
+
.map(|&s| 8 + unsafe { GetLengthSid(s) })
|
|
624
|
+
.sum::<u32>();
|
|
625
|
+
let mut acl_buf = vec![0u32; (acl_bytes as usize).div_ceil(std::mem::size_of::<u32>())];
|
|
626
|
+
let acl_ptr = acl_buf.as_mut_ptr().cast::<Acl>();
|
|
627
|
+
let flags = if directory {
|
|
628
|
+
OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE
|
|
629
|
+
} else {
|
|
630
|
+
0
|
|
631
|
+
};
|
|
632
|
+
// SAFETY: `acl_buf` has `>= acl_bytes` DWORD-aligned capacity.
|
|
633
|
+
if unsafe { InitializeAcl(acl_ptr, acl_bytes, ACL_REVISION) } == 0 {
|
|
634
|
+
return Err("private-acl-unsafe: InitializeAcl failed".to_owned());
|
|
635
|
+
}
|
|
636
|
+
for &sid in &sids {
|
|
637
|
+
// SAFETY: `acl_ptr` initialized with exact room for `sids`.
|
|
638
|
+
if unsafe { AddAccessAllowedAceEx(acl_ptr, ACL_REVISION, flags, FULL_CONTROL, sid) }
|
|
639
|
+
== 0
|
|
640
|
+
{
|
|
641
|
+
return Err("private-acl-unsafe: AddAccessAllowedAceEx failed".to_owned());
|
|
642
|
+
}
|
|
643
|
+
}
|
|
644
|
+
Ok((user, system, admins, acl_buf))
|
|
645
|
+
}
|
|
646
|
+
|
|
647
|
+
/// Verify, without changing it, that an existing file carries the protected owner-only DACL.
|
|
648
|
+
pub fn verify_private_file(path: &Path) -> Result<(), String> {
|
|
649
|
+
let (user, mut system, mut admins, _acl) = private_acl(false)?;
|
|
650
|
+
verify(path, false, &user, &mut system, &mut admins)
|
|
651
|
+
}
|
|
652
|
+
|
|
653
|
+
pub fn harden_and_verify(path: &Path, directory: bool) -> Result<(), String> {
|
|
654
|
+
let (user, mut system, mut admins, mut acl_buf) = private_acl(directory)?;
|
|
655
|
+
let acl_ptr = acl_buf.as_mut_ptr().cast::<Acl>();
|
|
656
|
+
let mut wname = wide_nul(path)?;
|
|
657
|
+
// SAFETY: Applies protected DACL to `wname`.
|
|
658
|
+
if unsafe {
|
|
659
|
+
SetNamedSecurityInfoW(
|
|
660
|
+
wname.as_mut_ptr(),
|
|
661
|
+
SE_FILE_OBJECT,
|
|
662
|
+
DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION,
|
|
663
|
+
ptr::null_mut(),
|
|
664
|
+
ptr::null_mut(),
|
|
665
|
+
acl_ptr,
|
|
666
|
+
ptr::null_mut(),
|
|
667
|
+
)
|
|
668
|
+
} != 0
|
|
669
|
+
{
|
|
670
|
+
return Err(format!(
|
|
671
|
+
"private-acl-unsafe: SetNamedSecurityInfoW failed on {}",
|
|
672
|
+
path.display()
|
|
673
|
+
));
|
|
674
|
+
}
|
|
675
|
+
verify(path, directory, &user, &mut system, &mut admins)
|
|
676
|
+
}
|
|
677
|
+
|
|
678
|
+
/// Create an exclusive file with its protected DACL installed by the kernel at creation.
|
|
679
|
+
pub fn create_private_file(path: &Path) -> Result<File, String> {
|
|
680
|
+
let (user, mut system, mut admins, mut acl_buf) = private_acl(false)?;
|
|
681
|
+
let mut descriptor = SecurityDescriptor {
|
|
682
|
+
revision: 0,
|
|
683
|
+
reserved: 0,
|
|
684
|
+
control: 0,
|
|
685
|
+
owner: ptr::null_mut(),
|
|
686
|
+
group: ptr::null_mut(),
|
|
687
|
+
sacl: ptr::null_mut(),
|
|
688
|
+
dacl: ptr::null_mut(),
|
|
689
|
+
};
|
|
690
|
+
let descriptor_ptr = (&mut descriptor as *mut SecurityDescriptor).cast::<c_void>();
|
|
691
|
+
// SAFETY: The descriptor and ACL are initialized, aligned and live through CreateFileW.
|
|
692
|
+
if unsafe { InitializeSecurityDescriptor(descriptor_ptr, 1) } == 0
|
|
693
|
+
|| unsafe {
|
|
694
|
+
SetSecurityDescriptorDacl(descriptor_ptr, 1, acl_buf.as_mut_ptr().cast(), 0)
|
|
695
|
+
} == 0
|
|
696
|
+
|| unsafe { SetSecurityDescriptorControl(descriptor_ptr, 0x1000, 0x1000) } == 0
|
|
697
|
+
{
|
|
698
|
+
return Err("private-acl-unsafe: security descriptor initialization failed".to_owned());
|
|
699
|
+
}
|
|
700
|
+
let mut attributes = SecurityAttributes {
|
|
701
|
+
length: std::mem::size_of::<SecurityAttributes>() as u32,
|
|
702
|
+
descriptor: descriptor_ptr,
|
|
703
|
+
inherit_handle: 0,
|
|
704
|
+
};
|
|
705
|
+
let wname = wide_nul(path)?;
|
|
706
|
+
// SAFETY: The path and security attributes stay live for the call; CREATE_NEW cannot replace a file.
|
|
707
|
+
let handle = unsafe {
|
|
708
|
+
CreateFileW(
|
|
709
|
+
wname.as_ptr(),
|
|
710
|
+
0x40000000,
|
|
711
|
+
0x00000007,
|
|
712
|
+
&mut attributes,
|
|
713
|
+
1,
|
|
714
|
+
0x00000080,
|
|
715
|
+
ptr::null_mut(),
|
|
716
|
+
)
|
|
717
|
+
};
|
|
718
|
+
if handle == (-1isize as Ptr) {
|
|
719
|
+
return Err(format!(
|
|
720
|
+
"private-acl-unsafe: create failed: {}",
|
|
721
|
+
std::io::Error::last_os_error()
|
|
722
|
+
));
|
|
723
|
+
}
|
|
724
|
+
// SAFETY: CreateFileW returned a newly owned file handle.
|
|
725
|
+
let file = unsafe { File::from_raw_handle(handle) };
|
|
726
|
+
verify(path, false, &user, &mut system, &mut admins)?;
|
|
727
|
+
Ok(file)
|
|
728
|
+
}
|
|
729
|
+
|
|
730
|
+
fn verify(
|
|
731
|
+
path: &Path,
|
|
732
|
+
root: bool,
|
|
733
|
+
user: &[usize],
|
|
734
|
+
system: &mut [u32; 17],
|
|
735
|
+
admins: &mut [u32; 17],
|
|
736
|
+
) -> Result<(), String> {
|
|
737
|
+
let wname = wide_nul(path)?;
|
|
738
|
+
let mut owner = ptr::null_mut();
|
|
739
|
+
let mut dacl = ptr::null_mut();
|
|
740
|
+
let mut desc = ptr::null_mut();
|
|
741
|
+
// SAFETY: Reads owner + DACL into LocalAlloc'd security descriptor.
|
|
742
|
+
let rc = unsafe {
|
|
743
|
+
GetNamedSecurityInfoW(
|
|
744
|
+
wname.as_ptr(),
|
|
745
|
+
SE_FILE_OBJECT,
|
|
746
|
+
1 | DACL_SECURITY_INFORMATION,
|
|
747
|
+
&mut owner,
|
|
748
|
+
ptr::null_mut(),
|
|
749
|
+
&mut dacl,
|
|
750
|
+
ptr::null_mut(),
|
|
751
|
+
&mut desc,
|
|
752
|
+
)
|
|
753
|
+
};
|
|
754
|
+
let desc = Local(desc);
|
|
755
|
+
if rc != 0 || desc.0.is_null() || owner.is_null() || dacl.is_null() {
|
|
756
|
+
return Err("private-acl-unsafe: GetNamedSecurityInfoW failed".to_owned());
|
|
757
|
+
}
|
|
758
|
+
let mut control = 0u16;
|
|
759
|
+
let mut rev = 0u32;
|
|
760
|
+
let mut present = 0i32;
|
|
761
|
+
let mut defaulted = 0i32;
|
|
762
|
+
// SAFETY: Inspects valid security descriptor `desc.0`.
|
|
763
|
+
let ok = unsafe {
|
|
764
|
+
GetSecurityDescriptorControl(desc.0, &mut control, &mut rev) != 0
|
|
765
|
+
&& GetSecurityDescriptorDacl(desc.0, &mut present, &mut dacl, &mut defaulted) != 0
|
|
766
|
+
&& present != 0
|
|
767
|
+
&& !dacl.is_null()
|
|
768
|
+
&& IsValidAcl(dacl) != 0
|
|
769
|
+
&& IsValidSid(owner) != 0
|
|
770
|
+
&& (EqualSid(owner, user[0] as Ptr) != 0
|
|
771
|
+
|| EqualSid(owner, admins.as_mut_ptr().cast()) != 0)
|
|
772
|
+
&& control & 0x1000 != 0
|
|
773
|
+
};
|
|
774
|
+
if !ok {
|
|
775
|
+
return Err("private-acl-unsafe: DACL header/owner verification failed".to_owned());
|
|
776
|
+
}
|
|
777
|
+
let mut user_fc = false;
|
|
778
|
+
// SAFETY: `dacl` was validated by `IsValidAcl`.
|
|
779
|
+
let ace_count = unsafe { (*dacl).count } as u32;
|
|
780
|
+
for i in 0..ace_count {
|
|
781
|
+
let mut ace = ptr::null_mut();
|
|
782
|
+
// SAFETY: `i < ace_count`.
|
|
783
|
+
if unsafe { GetAce(dacl, i, &mut ace) } == 0 || ace.is_null() {
|
|
784
|
+
return Err("private-acl-unsafe: GetAce failed".to_owned());
|
|
785
|
+
}
|
|
786
|
+
// SAFETY: `ace` points to a valid ACE inside `dacl`.
|
|
787
|
+
let hdr = unsafe { &*ace.cast::<AceHeader>() };
|
|
788
|
+
if hdr.kind != 0 || hdr.size < 16 || (root && hdr.flags & 0x10 != 0) {
|
|
789
|
+
return Err("private-acl-unsafe: unexpected ACE kind/flags".to_owned());
|
|
790
|
+
}
|
|
791
|
+
// SAFETY: ACCESS_ALLOWED_ACE has mask at +4 and SID at +8.
|
|
792
|
+
let mask = unsafe { *ace.cast::<u8>().add(4).cast::<u32>() };
|
|
793
|
+
let sid = unsafe { ace.cast::<u8>().add(8).cast::<c_void>() };
|
|
794
|
+
// SAFETY: Bounds-checks SID inside `hdr.size`.
|
|
795
|
+
if unsafe { IsValidSid(sid) } == 0 || unsafe { GetLengthSid(sid) } + 8 > hdr.size as u32
|
|
796
|
+
{
|
|
797
|
+
return Err("private-acl-unsafe: invalid ACE SID".to_owned());
|
|
798
|
+
}
|
|
799
|
+
// SAFETY: Compares valid SIDs.
|
|
800
|
+
let is_user = unsafe { EqualSid(sid, user[0] as Ptr) } != 0;
|
|
801
|
+
let is_sys = unsafe { EqualSid(sid, system.as_mut_ptr().cast()) } != 0;
|
|
802
|
+
let is_adm = unsafe { EqualSid(sid, admins.as_mut_ptr().cast()) } != 0;
|
|
803
|
+
if !is_user && !is_sys && !is_adm {
|
|
804
|
+
return Err("private-acl-unsafe: foreign ACE present".to_owned());
|
|
805
|
+
}
|
|
806
|
+
user_fc |= is_user
|
|
807
|
+
&& hdr.flags & 0x8 == 0
|
|
808
|
+
&& (mask & FULL_CONTROL == FULL_CONTROL || mask & 0x10000000 != 0);
|
|
809
|
+
}
|
|
810
|
+
if !user_fc {
|
|
811
|
+
return Err("private-acl-unsafe: missing current-user FullControl ACE".to_owned());
|
|
812
|
+
}
|
|
813
|
+
Ok(())
|
|
814
|
+
}
|
|
815
|
+
|
|
816
|
+
#[cfg(test)]
|
|
817
|
+
mod tests {
|
|
818
|
+
use super::*;
|
|
819
|
+
use std::fs;
|
|
820
|
+
use std::io::Write;
|
|
821
|
+
use std::process::Command;
|
|
822
|
+
|
|
823
|
+
#[test]
|
|
824
|
+
fn regular_replacement_is_private_under_a_permissive_parent() {
|
|
825
|
+
struct Scratch(std::path::PathBuf);
|
|
826
|
+
impl Drop for Scratch {
|
|
827
|
+
fn drop(&mut self) {
|
|
828
|
+
let _ = fs::remove_dir_all(&self.0);
|
|
829
|
+
}
|
|
830
|
+
}
|
|
831
|
+
|
|
832
|
+
let root = std::env::temp_dir().join(format!(
|
|
833
|
+
"ocx-child-acl-{}-{}",
|
|
834
|
+
std::process::id(),
|
|
835
|
+
crate::platform::random_hex(6).unwrap()
|
|
836
|
+
));
|
|
837
|
+
fs::create_dir(&root).unwrap();
|
|
838
|
+
let _scratch = Scratch(root.clone());
|
|
839
|
+
let grant = Command::new("icacls")
|
|
840
|
+
.arg(&root)
|
|
841
|
+
.args(["/grant", "*S-1-1-0:(OI)(CI)F"])
|
|
842
|
+
.output()
|
|
843
|
+
.unwrap();
|
|
844
|
+
assert!(
|
|
845
|
+
grant.status.success(),
|
|
846
|
+
"could not make fixture parent permissive"
|
|
847
|
+
);
|
|
848
|
+
let config = root.join("config.toml");
|
|
849
|
+
fs::write(&config, b"original").unwrap();
|
|
850
|
+
harden_and_verify(&config, false).unwrap();
|
|
851
|
+
|
|
852
|
+
let temp = root.join("new-private.tmp");
|
|
853
|
+
let mut created = create_private_file(&temp).unwrap();
|
|
854
|
+
let user = current_user_sid().unwrap();
|
|
855
|
+
let mut system = well_known_sid(22).unwrap();
|
|
856
|
+
let mut admins = well_known_sid(26).unwrap();
|
|
857
|
+
verify(&temp, false, &user, &mut system, &mut admins).unwrap();
|
|
858
|
+
created.write_all(b"fixture").unwrap();
|
|
859
|
+
drop(created);
|
|
860
|
+
|
|
861
|
+
crate::platform::write_regular_atomic(&config, b"replacement").unwrap();
|
|
862
|
+
verify(&config, false, &user, &mut system, &mut admins).unwrap();
|
|
863
|
+
assert_eq!(fs::read(config).unwrap(), b"replacement");
|
|
864
|
+
}
|
|
865
|
+
}
|
|
866
|
+
}
|
|
867
|
+
|
|
868
|
+
pub fn ensure_private_dir(dir: &Path) -> Result<(), String> {
|
|
869
|
+
reject_symlink(dir)?;
|
|
870
|
+
#[cfg(unix)]
|
|
871
|
+
{
|
|
872
|
+
use std::os::unix::fs::{DirBuilderExt, PermissionsExt};
|
|
873
|
+
if !dir.exists() {
|
|
874
|
+
let mut builder = fs::DirBuilder::new();
|
|
875
|
+
builder.recursive(true).mode(0o700);
|
|
876
|
+
builder
|
|
877
|
+
.create(dir)
|
|
878
|
+
.map_err(|e| format!("failed to create {}: {e}", dir.display()))?;
|
|
879
|
+
}
|
|
880
|
+
reject_symlink(dir)?;
|
|
881
|
+
fs::set_permissions(dir, fs::Permissions::from_mode(0o700))
|
|
882
|
+
.map_err(|e| format!("failed to chmod 0700 {}: {e}", dir.display()))?;
|
|
883
|
+
}
|
|
884
|
+
#[cfg(windows)]
|
|
885
|
+
{
|
|
886
|
+
fs::create_dir_all(dir).map_err(|e| format!("failed to create {}: {e}", dir.display()))?;
|
|
887
|
+
reject_symlink(dir)?;
|
|
888
|
+
windows_private_acl::harden_and_verify(dir, true)?;
|
|
889
|
+
}
|
|
890
|
+
#[cfg(not(any(unix, windows)))]
|
|
891
|
+
{
|
|
892
|
+
fs::create_dir_all(dir).map_err(|e| format!("failed to create {}: {e}", dir.display()))?;
|
|
893
|
+
reject_symlink(dir)?;
|
|
894
|
+
}
|
|
895
|
+
Ok(())
|
|
896
|
+
}
|
|
897
|
+
|
|
898
|
+
#[cfg(unix)]
|
|
899
|
+
pub(crate) fn sync_parent_directory(parent: &Path) -> Result<(), String> {
|
|
900
|
+
let directory =
|
|
901
|
+
File::open(parent).map_err(|e| format!("failed to open parent directory: {e}"))?;
|
|
902
|
+
directory
|
|
903
|
+
.sync_all()
|
|
904
|
+
.map_err(|e| format!("failed to sync parent directory: {e}"))
|
|
905
|
+
}
|
|
906
|
+
|
|
907
|
+
pub fn write_private_atomic(path: &Path, bytes: &[u8]) -> Result<(), String> {
|
|
908
|
+
let parent = path
|
|
909
|
+
.parent()
|
|
910
|
+
.ok_or_else(|| format!("path has no parent: {}", path.display()))?;
|
|
911
|
+
ensure_private_dir(parent)?;
|
|
912
|
+
reject_symlink(path)?;
|
|
913
|
+
let nonce = random_hex(8)?;
|
|
914
|
+
let file_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("state");
|
|
915
|
+
let tmp = parent.join(format!(".{file_name}.tmp.{}.{nonce}", std::process::id()));
|
|
916
|
+
#[cfg(windows)]
|
|
917
|
+
let mut f = windows_private_acl::create_private_file(&tmp)?;
|
|
918
|
+
#[cfg(not(windows))]
|
|
919
|
+
let mut f = {
|
|
920
|
+
let mut opts = OpenOptions::new();
|
|
921
|
+
opts.write(true).create_new(true);
|
|
922
|
+
#[cfg(unix)]
|
|
923
|
+
{
|
|
924
|
+
use std::os::unix::fs::OpenOptionsExt;
|
|
925
|
+
opts.mode(0o600);
|
|
926
|
+
}
|
|
927
|
+
opts.open(&tmp)
|
|
928
|
+
.map_err(|e| format!("failed to create temp file {}: {e}", tmp.display()))?
|
|
929
|
+
};
|
|
930
|
+
if let Err(e) = f.write_all(bytes).and_then(|()| f.sync_all()) {
|
|
931
|
+
let _ = fs::remove_file(&tmp);
|
|
932
|
+
return Err(format!("failed writing {}: {e}", tmp.display()));
|
|
933
|
+
}
|
|
934
|
+
drop(f);
|
|
935
|
+
if let Err(e) = fs::rename(&tmp, path) {
|
|
936
|
+
let _ = fs::remove_file(&tmp);
|
|
937
|
+
return Err(format!(
|
|
938
|
+
"failed renaming {} -> {}: {e}",
|
|
939
|
+
tmp.display(),
|
|
940
|
+
path.display()
|
|
941
|
+
));
|
|
942
|
+
}
|
|
943
|
+
#[cfg(unix)]
|
|
944
|
+
sync_parent_directory(parent)?;
|
|
945
|
+
Ok(())
|
|
946
|
+
}
|
|
947
|
+
|
|
948
|
+
pub fn write_regular_atomic(path: &Path, bytes: &[u8]) -> Result<(), String> {
|
|
949
|
+
let parent = path
|
|
950
|
+
.parent()
|
|
951
|
+
.ok_or_else(|| format!("path has no parent: {}", path.display()))?;
|
|
952
|
+
fs::create_dir_all(parent)
|
|
953
|
+
.map_err(|e| format!("failed to create {}: {e}", parent.display()))?;
|
|
954
|
+
reject_symlink(path)?;
|
|
955
|
+
#[cfg(unix)]
|
|
956
|
+
let preserved_mode = fs::metadata(path).ok().map(|m| {
|
|
957
|
+
use std::os::unix::fs::PermissionsExt;
|
|
958
|
+
m.permissions().mode() & 0o777
|
|
959
|
+
});
|
|
960
|
+
let nonce = random_hex(8)?;
|
|
961
|
+
let file_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("file");
|
|
962
|
+
let tmp = parent.join(format!(
|
|
963
|
+
".{file_name}.ocx-child.tmp.{}.{nonce}",
|
|
964
|
+
std::process::id()
|
|
965
|
+
));
|
|
966
|
+
#[cfg(windows)]
|
|
967
|
+
let mut f = windows_private_acl::create_private_file(&tmp)?;
|
|
968
|
+
#[cfg(not(windows))]
|
|
969
|
+
let mut f = {
|
|
970
|
+
let mut opts = OpenOptions::new();
|
|
971
|
+
opts.write(true).create_new(true);
|
|
972
|
+
#[cfg(unix)]
|
|
973
|
+
{
|
|
974
|
+
use std::os::unix::fs::OpenOptionsExt;
|
|
975
|
+
opts.mode(preserved_mode.unwrap_or(0o600));
|
|
976
|
+
}
|
|
977
|
+
opts.open(&tmp)
|
|
978
|
+
.map_err(|e| format!("failed to create temp file {}: {e}", tmp.display()))?
|
|
979
|
+
};
|
|
980
|
+
if let Err(e) = f.write_all(bytes).and_then(|()| f.sync_all()) {
|
|
981
|
+
let _ = fs::remove_file(&tmp);
|
|
982
|
+
return Err(format!("failed writing {}: {e}", tmp.display()));
|
|
983
|
+
}
|
|
984
|
+
drop(f);
|
|
985
|
+
if let Err(e) = fs::rename(&tmp, path) {
|
|
986
|
+
let _ = fs::remove_file(&tmp);
|
|
987
|
+
return Err(format!(
|
|
988
|
+
"failed renaming {} -> {}: {e}",
|
|
989
|
+
tmp.display(),
|
|
990
|
+
path.display()
|
|
991
|
+
));
|
|
992
|
+
}
|
|
993
|
+
#[cfg(unix)]
|
|
994
|
+
sync_parent_directory(parent)?;
|
|
995
|
+
Ok(())
|
|
996
|
+
}
|
|
997
|
+
|
|
998
|
+
pub struct FileLock {
|
|
999
|
+
file: File,
|
|
1000
|
+
}
|
|
1001
|
+
|
|
1002
|
+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
1003
|
+
pub enum LockAcquireError {
|
|
1004
|
+
Busy,
|
|
1005
|
+
Io,
|
|
1006
|
+
}
|
|
1007
|
+
|
|
1008
|
+
/// What a lock acquisition does with the lock file's parent directory.
|
|
1009
|
+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
1010
|
+
pub enum LockParentAction {
|
|
1011
|
+
/// The parent is missing and ocx-child creates it, private, as its own directory.
|
|
1012
|
+
CreatePrivate,
|
|
1013
|
+
/// The parent already exists; its permissions are never changed. It may be an
|
|
1014
|
+
/// `OPENCODEX_HOME` shared with a full OpenCodex install, or `CODEX_HOME`.
|
|
1015
|
+
UseExisting,
|
|
1016
|
+
Refuse,
|
|
1017
|
+
}
|
|
1018
|
+
|
|
1019
|
+
/// `parent` is the parent's metadata, or `None` when it does not exist.
|
|
1020
|
+
pub fn lock_parent_action(parent: Option<&fs::Metadata>, create_missing: bool) -> LockParentAction {
|
|
1021
|
+
match parent {
|
|
1022
|
+
None if create_missing => LockParentAction::CreatePrivate,
|
|
1023
|
+
None => LockParentAction::Refuse,
|
|
1024
|
+
Some(meta) if meta.is_dir() => LockParentAction::UseExisting,
|
|
1025
|
+
Some(_) => LockParentAction::Refuse,
|
|
1026
|
+
}
|
|
1027
|
+
}
|
|
1028
|
+
|
|
1029
|
+
/// Create `dir` private (`0700`, or a protected owner-only DACL on Windows) if it is missing.
|
|
1030
|
+
/// Returns whether this call created it. A directory that already exists, including one another
|
|
1031
|
+
/// process creates concurrently, is left exactly as it is.
|
|
1032
|
+
pub fn create_private_dir_if_missing(dir: &Path) -> Result<bool, String> {
|
|
1033
|
+
if let Some(ancestor) = dir.parent().filter(|p| !p.as_os_str().is_empty()) {
|
|
1034
|
+
#[cfg(unix)]
|
|
1035
|
+
{
|
|
1036
|
+
use std::os::unix::fs::DirBuilderExt;
|
|
1037
|
+
fs::DirBuilder::new()
|
|
1038
|
+
.recursive(true)
|
|
1039
|
+
.mode(0o700)
|
|
1040
|
+
.create(ancestor)
|
|
1041
|
+
.map_err(|e| format!("failed to create {}: {e}", ancestor.display()))?;
|
|
1042
|
+
}
|
|
1043
|
+
#[cfg(not(unix))]
|
|
1044
|
+
fs::create_dir_all(ancestor)
|
|
1045
|
+
.map_err(|e| format!("failed to create {}: {e}", ancestor.display()))?;
|
|
1046
|
+
}
|
|
1047
|
+
#[cfg(unix)]
|
|
1048
|
+
let created = {
|
|
1049
|
+
use std::os::unix::fs::DirBuilderExt;
|
|
1050
|
+
fs::DirBuilder::new().mode(0o700).create(dir)
|
|
1051
|
+
};
|
|
1052
|
+
#[cfg(not(unix))]
|
|
1053
|
+
let created = fs::DirBuilder::new().create(dir);
|
|
1054
|
+
match created {
|
|
1055
|
+
Ok(()) => {}
|
|
1056
|
+
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
|
|
1057
|
+
return if fs::symlink_metadata(dir).is_ok_and(|m| m.is_dir()) {
|
|
1058
|
+
Ok(false)
|
|
1059
|
+
} else {
|
|
1060
|
+
Err(format!("{} exists and is not a directory", dir.display()))
|
|
1061
|
+
};
|
|
1062
|
+
}
|
|
1063
|
+
Err(e) => return Err(format!("failed to create {}: {e}", dir.display())),
|
|
1064
|
+
}
|
|
1065
|
+
reject_symlink(dir)?;
|
|
1066
|
+
#[cfg(unix)]
|
|
1067
|
+
{
|
|
1068
|
+
use std::os::unix::fs::PermissionsExt;
|
|
1069
|
+
fs::set_permissions(dir, fs::Permissions::from_mode(0o700))
|
|
1070
|
+
.map_err(|e| format!("failed to chmod 0700 {}: {e}", dir.display()))?;
|
|
1071
|
+
}
|
|
1072
|
+
#[cfg(windows)]
|
|
1073
|
+
windows_private_acl::harden_and_verify(dir, true)?;
|
|
1074
|
+
Ok(true)
|
|
1075
|
+
}
|
|
1076
|
+
|
|
1077
|
+
impl FileLock {
|
|
1078
|
+
/// Lock `path`, creating its parent private only if it is missing. An existing parent keeps
|
|
1079
|
+
/// its permissions; the lock file itself is created owner-only.
|
|
1080
|
+
pub fn try_acquire_nonblocking(path: &Path) -> Result<Self, LockAcquireError> {
|
|
1081
|
+
Self::acquire_inner(path, false, true)
|
|
1082
|
+
}
|
|
1083
|
+
|
|
1084
|
+
pub fn acquire_blocking(path: &Path) -> Result<Self, LockAcquireError> {
|
|
1085
|
+
Self::acquire_inner(path, true, true)
|
|
1086
|
+
}
|
|
1087
|
+
|
|
1088
|
+
/// Lock a file inside a directory the caller does not own (such as `CODEX_HOME`), leaving
|
|
1089
|
+
/// the directory's permissions untouched. The lock file itself is created private.
|
|
1090
|
+
pub fn acquire_in_existing_dir(path: &Path, blocking: bool) -> Result<Self, LockAcquireError> {
|
|
1091
|
+
Self::acquire_inner(path, blocking, false)
|
|
1092
|
+
}
|
|
1093
|
+
|
|
1094
|
+
fn acquire_inner(
|
|
1095
|
+
path: &Path,
|
|
1096
|
+
blocking: bool,
|
|
1097
|
+
create_missing_parent: bool,
|
|
1098
|
+
) -> Result<Self, LockAcquireError> {
|
|
1099
|
+
let parent = path.parent().ok_or(LockAcquireError::Io)?;
|
|
1100
|
+
// A symlinked parent is refused rather than followed, as ensure_private_dir did.
|
|
1101
|
+
let parent_meta = fs::symlink_metadata(parent).ok();
|
|
1102
|
+
match lock_parent_action(parent_meta.as_ref(), create_missing_parent) {
|
|
1103
|
+
LockParentAction::CreatePrivate => {
|
|
1104
|
+
create_private_dir_if_missing(parent).map_err(|_| LockAcquireError::Io)?;
|
|
1105
|
+
}
|
|
1106
|
+
LockParentAction::UseExisting => {}
|
|
1107
|
+
LockParentAction::Refuse => return Err(LockAcquireError::Io),
|
|
1108
|
+
}
|
|
1109
|
+
reject_symlink(path).map_err(|_| LockAcquireError::Io)?;
|
|
1110
|
+
crate::test_hooks::barrier("lock-before-open");
|
|
1111
|
+
#[cfg(windows)]
|
|
1112
|
+
let existed = path.exists();
|
|
1113
|
+
let mut opts = OpenOptions::new();
|
|
1114
|
+
opts.read(true).write(true).create(true).truncate(false);
|
|
1115
|
+
#[cfg(unix)]
|
|
1116
|
+
{
|
|
1117
|
+
use std::os::unix::fs::OpenOptionsExt;
|
|
1118
|
+
opts.mode(0o600).custom_flags(O_NOFOLLOW);
|
|
1119
|
+
}
|
|
1120
|
+
#[cfg(windows)]
|
|
1121
|
+
{
|
|
1122
|
+
use std::os::windows::fs::OpenOptionsExt;
|
|
1123
|
+
const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
|
|
1124
|
+
opts.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT);
|
|
1125
|
+
}
|
|
1126
|
+
let file = opts.open(path).map_err(|_| LockAcquireError::Io)?;
|
|
1127
|
+
// The open did not follow a link; refuse anything that is not a plain file anyway.
|
|
1128
|
+
let metadata = file.metadata().map_err(|_| LockAcquireError::Io)?;
|
|
1129
|
+
if !metadata.is_file() {
|
|
1130
|
+
return Err(LockAcquireError::Io);
|
|
1131
|
+
}
|
|
1132
|
+
#[cfg(windows)]
|
|
1133
|
+
{
|
|
1134
|
+
use std::os::windows::fs::MetadataExt;
|
|
1135
|
+
const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x400;
|
|
1136
|
+
if metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0 {
|
|
1137
|
+
return Err(LockAcquireError::Io);
|
|
1138
|
+
}
|
|
1139
|
+
let private = if existed {
|
|
1140
|
+
windows_private_acl::verify_private_file(path)
|
|
1141
|
+
} else {
|
|
1142
|
+
windows_private_acl::harden_and_verify(path, false)
|
|
1143
|
+
};
|
|
1144
|
+
private.map_err(|_| LockAcquireError::Io)?;
|
|
1145
|
+
}
|
|
1146
|
+
#[cfg(unix)]
|
|
1147
|
+
{
|
|
1148
|
+
use std::os::fd::AsRawFd;
|
|
1149
|
+
const LOCK_EX: i32 = 2;
|
|
1150
|
+
const LOCK_NB: i32 = 4;
|
|
1151
|
+
let op = if blocking { LOCK_EX } else { LOCK_EX | LOCK_NB };
|
|
1152
|
+
// SAFETY: `file` owns a valid open descriptor.
|
|
1153
|
+
let rc = unsafe { flock(file.as_raw_fd(), op) };
|
|
1154
|
+
if rc != 0 {
|
|
1155
|
+
return Err(LockAcquireError::Busy);
|
|
1156
|
+
}
|
|
1157
|
+
}
|
|
1158
|
+
#[cfg(windows)]
|
|
1159
|
+
{
|
|
1160
|
+
use std::os::windows::io::AsRawHandle;
|
|
1161
|
+
const LOCKFILE_FAIL_IMMEDIATELY: u32 = 1;
|
|
1162
|
+
const LOCKFILE_EXCLUSIVE_LOCK: u32 = 2;
|
|
1163
|
+
let flags = if blocking {
|
|
1164
|
+
LOCKFILE_EXCLUSIVE_LOCK
|
|
1165
|
+
} else {
|
|
1166
|
+
LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY
|
|
1167
|
+
};
|
|
1168
|
+
let mut ov = Overlapped {
|
|
1169
|
+
internal: 0,
|
|
1170
|
+
internal_high: 0,
|
|
1171
|
+
offset: 0,
|
|
1172
|
+
offset_high: 0,
|
|
1173
|
+
event: std::ptr::null_mut(),
|
|
1174
|
+
};
|
|
1175
|
+
// SAFETY: `file` owns a valid open Win32 file handle and `ov` is stack-valid.
|
|
1176
|
+
let ok = unsafe { LockFileEx(file.as_raw_handle(), flags, 0, 1, 0, &mut ov) };
|
|
1177
|
+
if ok == 0 {
|
|
1178
|
+
return Err(LockAcquireError::Busy);
|
|
1179
|
+
}
|
|
1180
|
+
}
|
|
1181
|
+
Ok(Self { file })
|
|
1182
|
+
}
|
|
1183
|
+
}
|
|
1184
|
+
|
|
1185
|
+
impl Drop for FileLock {
|
|
1186
|
+
fn drop(&mut self) {
|
|
1187
|
+
#[cfg(unix)]
|
|
1188
|
+
{
|
|
1189
|
+
use std::os::fd::AsRawFd;
|
|
1190
|
+
const LOCK_UN: i32 = 8;
|
|
1191
|
+
// SAFETY: `self.file` is still open until Drop returns.
|
|
1192
|
+
let _ = unsafe { flock(self.file.as_raw_fd(), LOCK_UN) };
|
|
1193
|
+
}
|
|
1194
|
+
#[cfg(windows)]
|
|
1195
|
+
{
|
|
1196
|
+
use std::os::windows::io::AsRawHandle;
|
|
1197
|
+
let mut ov = Overlapped {
|
|
1198
|
+
internal: 0,
|
|
1199
|
+
internal_high: 0,
|
|
1200
|
+
offset: 0,
|
|
1201
|
+
offset_high: 0,
|
|
1202
|
+
event: std::ptr::null_mut(),
|
|
1203
|
+
};
|
|
1204
|
+
// SAFETY: `self.file` is still open until Drop returns.
|
|
1205
|
+
let _ = unsafe { UnlockFileEx(self.file.as_raw_handle(), 0, 1, 0, &mut ov) };
|
|
1206
|
+
}
|
|
1207
|
+
}
|
|
1208
|
+
}
|
|
1209
|
+
|
|
1210
|
+
/// Spawn `serve --foreground --lifecycle-start` and write `start_line` to its stdin, which
|
|
1211
|
+
/// stays open: the caller later writes the commit line or drops it to make the child exit.
|
|
1212
|
+
pub fn spawn_detached_serve(
|
|
1213
|
+
exe: &Path,
|
|
1214
|
+
opencodex_home: &Path,
|
|
1215
|
+
codex_home: &Path,
|
|
1216
|
+
listen_port: u16,
|
|
1217
|
+
start_line: &[u8],
|
|
1218
|
+
) -> Result<std::process::Child, String> {
|
|
1219
|
+
let mut cmd = Command::new(exe);
|
|
1220
|
+
cmd.arg("serve")
|
|
1221
|
+
.arg("--foreground")
|
|
1222
|
+
.arg("--lifecycle-start")
|
|
1223
|
+
.arg("--listen-port")
|
|
1224
|
+
.arg(listen_port.to_string())
|
|
1225
|
+
.env("OPENCODEX_HOME", opencodex_home)
|
|
1226
|
+
.env("CODEX_HOME", codex_home)
|
|
1227
|
+
.stdin(Stdio::piped())
|
|
1228
|
+
.stdout(Stdio::null())
|
|
1229
|
+
.stderr(Stdio::null());
|
|
1230
|
+
crate::test_hooks::strip_barrier_env(&mut cmd);
|
|
1231
|
+
|
|
1232
|
+
#[cfg(unix)]
|
|
1233
|
+
{
|
|
1234
|
+
use std::os::unix::process::CommandExt;
|
|
1235
|
+
// SAFETY: `setsid()` is async-signal-safe in the forked child before exec.
|
|
1236
|
+
unsafe {
|
|
1237
|
+
cmd.pre_exec(|| {
|
|
1238
|
+
let _ = setsid();
|
|
1239
|
+
Ok(())
|
|
1240
|
+
});
|
|
1241
|
+
}
|
|
1242
|
+
}
|
|
1243
|
+
#[cfg(windows)]
|
|
1244
|
+
{
|
|
1245
|
+
use std::os::windows::process::CommandExt;
|
|
1246
|
+
const DETACHED_PROCESS: u32 = 0x0000_0008;
|
|
1247
|
+
const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200;
|
|
1248
|
+
const CREATE_BREAKAWAY_FROM_JOB: u32 = 0x0100_0000;
|
|
1249
|
+
cmd.creation_flags(CREATE_BREAKAWAY_FROM_JOB | DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP);
|
|
1250
|
+
}
|
|
1251
|
+
|
|
1252
|
+
let mut child = cmd
|
|
1253
|
+
.spawn()
|
|
1254
|
+
.map_err(|e| format!("failed to spawn detached ocx-child serve: {e}"))?;
|
|
1255
|
+
let write_result = match child.stdin.as_mut() {
|
|
1256
|
+
Some(stdin) => stdin.write_all(start_line).and_then(|()| stdin.flush()),
|
|
1257
|
+
None => Err(std::io::Error::other("missing child stdin")),
|
|
1258
|
+
};
|
|
1259
|
+
if let Err(e) = write_result {
|
|
1260
|
+
let cleanup = child.kill().and_then(|()| child.wait().map(|_| ()));
|
|
1261
|
+
return Err(format!(
|
|
1262
|
+
"failed to authorize spawned child: {e}; cleanup: {cleanup:?}"
|
|
1263
|
+
));
|
|
1264
|
+
}
|
|
1265
|
+
Ok(child)
|
|
1266
|
+
}
|
|
1267
|
+
|
|
1268
|
+
pub fn process_is_alive(pid: u32) -> bool {
|
|
1269
|
+
if pid == 0 {
|
|
1270
|
+
return false;
|
|
1271
|
+
}
|
|
1272
|
+
#[cfg(unix)]
|
|
1273
|
+
{
|
|
1274
|
+
// SAFETY: `kill(pid, 0)` sends no signal and probes process existence.
|
|
1275
|
+
let rc = unsafe { kill(pid as i32, 0) };
|
|
1276
|
+
if rc == 0 {
|
|
1277
|
+
return true;
|
|
1278
|
+
}
|
|
1279
|
+
std::io::Error::last_os_error().raw_os_error() == Some(1) // EPERM
|
|
1280
|
+
}
|
|
1281
|
+
#[cfg(windows)]
|
|
1282
|
+
{
|
|
1283
|
+
const SYNCHRONIZE: u32 = 0x0010_0000;
|
|
1284
|
+
const WAIT_TIMEOUT: u32 = 258;
|
|
1285
|
+
// SAFETY: Opens a temporary SYNCHRONIZE handle for `pid` and closes it immediately.
|
|
1286
|
+
unsafe {
|
|
1287
|
+
let h = OpenProcess(SYNCHRONIZE, 0, pid);
|
|
1288
|
+
if h.is_null() {
|
|
1289
|
+
return false;
|
|
1290
|
+
}
|
|
1291
|
+
let state = WaitForSingleObject(h, 0);
|
|
1292
|
+
CloseHandle(h);
|
|
1293
|
+
state == WAIT_TIMEOUT
|
|
1294
|
+
}
|
|
1295
|
+
}
|
|
1296
|
+
}
|
|
1297
|
+
|
|
1298
|
+
pub fn resolve_user_home() -> PathBuf {
|
|
1299
|
+
if let Some(h) = std::env::var_os("HOME").filter(|v| !v.is_empty()) {
|
|
1300
|
+
return PathBuf::from(h);
|
|
1301
|
+
}
|
|
1302
|
+
if let Some(h) = std::env::var_os("USERPROFILE").filter(|v| !v.is_empty()) {
|
|
1303
|
+
return PathBuf::from(h);
|
|
1304
|
+
}
|
|
1305
|
+
PathBuf::from(".")
|
|
1306
|
+
}
|
|
1307
|
+
|
|
1308
|
+
pub fn resolve_opencodex_home() -> PathBuf {
|
|
1309
|
+
if let Some(custom) = std::env::var_os("OPENCODEX_HOME").filter(|v| !v.is_empty()) {
|
|
1310
|
+
return PathBuf::from(custom);
|
|
1311
|
+
}
|
|
1312
|
+
resolve_user_home().join(".opencodex")
|
|
1313
|
+
}
|
|
1314
|
+
|
|
1315
|
+
pub fn resolve_codex_home() -> PathBuf {
|
|
1316
|
+
if let Some(custom) = std::env::var_os("CODEX_HOME").filter(|v| !v.is_empty()) {
|
|
1317
|
+
return PathBuf::from(custom);
|
|
1318
|
+
}
|
|
1319
|
+
resolve_user_home().join(".codex")
|
|
1320
|
+
}
|
|
1321
|
+
|
|
1322
|
+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
1323
|
+
pub enum PurgeExecutableOutcome {
|
|
1324
|
+
Removed,
|
|
1325
|
+
SkippedUnmanagedPath,
|
|
1326
|
+
}
|
|
1327
|
+
|
|
1328
|
+
fn reject_managed_subpath_symlinks(root: &Path, components: &[&str]) -> Result<PathBuf, String> {
|
|
1329
|
+
let mut cur = root.to_path_buf();
|
|
1330
|
+
for comp in components {
|
|
1331
|
+
cur.push(comp);
|
|
1332
|
+
reject_symlink(&cur)?;
|
|
1333
|
+
}
|
|
1334
|
+
Ok(cur)
|
|
1335
|
+
}
|
|
1336
|
+
|
|
1337
|
+
pub fn is_managed_plant_executable(
|
|
1338
|
+
exe_path: &Path,
|
|
1339
|
+
user_home: &Path,
|
|
1340
|
+
local_appdata: Option<&Path>,
|
|
1341
|
+
) -> Result<bool, String> {
|
|
1342
|
+
reject_symlink(exe_path)?;
|
|
1343
|
+
if !fs::symlink_metadata(exe_path).is_ok_and(|m| m.file_type().is_file()) {
|
|
1344
|
+
return Ok(false);
|
|
1345
|
+
}
|
|
1346
|
+
let Some(parent) = exe_path.parent() else {
|
|
1347
|
+
return Ok(false);
|
|
1348
|
+
};
|
|
1349
|
+
reject_symlink(parent)?;
|
|
1350
|
+
let expected_name = if cfg!(windows) {
|
|
1351
|
+
"ocx-child.exe"
|
|
1352
|
+
} else {
|
|
1353
|
+
"ocx-child"
|
|
1354
|
+
};
|
|
1355
|
+
if exe_path.file_name().and_then(|n| n.to_str()) != Some(expected_name) {
|
|
1356
|
+
return Ok(false);
|
|
1357
|
+
}
|
|
1358
|
+
let canon_parent = fs::canonicalize(parent)
|
|
1359
|
+
.map_err(|e| format!("failed canonicalizing {}: {e}", parent.display()))?;
|
|
1360
|
+
let cache_bin = reject_managed_subpath_symlinks(user_home, &[".cache", "opencodex", "bin"])?;
|
|
1361
|
+
if fs::canonicalize(&cache_bin).ok().as_ref() == Some(&canon_parent) {
|
|
1362
|
+
return Ok(true);
|
|
1363
|
+
}
|
|
1364
|
+
if let Some(appdata) = local_appdata {
|
|
1365
|
+
let win_bin = reject_managed_subpath_symlinks(appdata, &["opencodex", "bin"])?;
|
|
1366
|
+
if fs::canonicalize(&win_bin).ok().as_ref() == Some(&canon_parent) {
|
|
1367
|
+
return Ok(true);
|
|
1368
|
+
}
|
|
1369
|
+
}
|
|
1370
|
+
Ok(false)
|
|
1371
|
+
}
|
|
1372
|
+
|
|
1373
|
+
pub fn purge_managed_executable(
|
|
1374
|
+
exe_path: &Path,
|
|
1375
|
+
user_home: &Path,
|
|
1376
|
+
local_appdata: Option<&Path>,
|
|
1377
|
+
) -> Result<PurgeExecutableOutcome, String> {
|
|
1378
|
+
if !is_managed_plant_executable(exe_path, user_home, local_appdata)? {
|
|
1379
|
+
return Ok(PurgeExecutableOutcome::SkippedUnmanagedPath);
|
|
1380
|
+
}
|
|
1381
|
+
#[cfg(unix)]
|
|
1382
|
+
{
|
|
1383
|
+
fs::remove_file(exe_path).map_err(|e| {
|
|
1384
|
+
format!(
|
|
1385
|
+
"failed removing planted ocx-child {}: {e}",
|
|
1386
|
+
exe_path.display()
|
|
1387
|
+
)
|
|
1388
|
+
})?;
|
|
1389
|
+
let _ = exe_path.parent().map(fs::remove_dir);
|
|
1390
|
+
let _ = exe_path.parent().and_then(Path::parent).map(fs::remove_dir);
|
|
1391
|
+
Ok(PurgeExecutableOutcome::Removed)
|
|
1392
|
+
}
|
|
1393
|
+
#[cfg(windows)]
|
|
1394
|
+
{
|
|
1395
|
+
use std::os::windows::process::CommandExt;
|
|
1396
|
+
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
|
|
1397
|
+
const DETACHED_PROCESS: u32 = 0x0000_0008;
|
|
1398
|
+
let parent = exe_path
|
|
1399
|
+
.parent()
|
|
1400
|
+
.ok_or_else(|| "missing parent".to_owned())?;
|
|
1401
|
+
let trashed = parent.join(format!(".ocx-child.purge.{}.old", std::process::id()));
|
|
1402
|
+
let _ = fs::remove_file(&trashed);
|
|
1403
|
+
fs::rename(exe_path, &trashed)
|
|
1404
|
+
.map_err(|e| format!("failed renaming planted ocx-child for purge: {e}"))?;
|
|
1405
|
+
let _ = Command::new("cmd.exe")
|
|
1406
|
+
.args([
|
|
1407
|
+
"/d",
|
|
1408
|
+
"/c",
|
|
1409
|
+
"ping -n 2 127.0.0.1 >nul & del /f /q \"%OCX_PURGE_TARGET%\"",
|
|
1410
|
+
])
|
|
1411
|
+
.env("OCX_PURGE_TARGET", &trashed)
|
|
1412
|
+
.stdin(Stdio::null())
|
|
1413
|
+
.stdout(Stdio::null())
|
|
1414
|
+
.stderr(Stdio::null())
|
|
1415
|
+
.creation_flags(CREATE_NO_WINDOW | DETACHED_PROCESS)
|
|
1416
|
+
.spawn();
|
|
1417
|
+
Ok(PurgeExecutableOutcome::Removed)
|
|
1418
|
+
}
|
|
1419
|
+
}
|
|
1420
|
+
|
|
1421
|
+
#[cfg(test)]
|
|
1422
|
+
mod lock_parent_tests {
|
|
1423
|
+
use super::*;
|
|
1424
|
+
|
|
1425
|
+
struct Scratch(PathBuf);
|
|
1426
|
+
impl Drop for Scratch {
|
|
1427
|
+
fn drop(&mut self) {
|
|
1428
|
+
let _ = fs::remove_dir_all(&self.0);
|
|
1429
|
+
}
|
|
1430
|
+
}
|
|
1431
|
+
|
|
1432
|
+
fn scratch() -> Scratch {
|
|
1433
|
+
let dir = std::env::temp_dir().join(format!(
|
|
1434
|
+
"ocx-child-lock-parent-{}-{}",
|
|
1435
|
+
std::process::id(),
|
|
1436
|
+
random_hex(6).unwrap()
|
|
1437
|
+
));
|
|
1438
|
+
fs::create_dir(&dir).unwrap();
|
|
1439
|
+
Scratch(dir)
|
|
1440
|
+
}
|
|
1441
|
+
|
|
1442
|
+
#[test]
|
|
1443
|
+
fn only_a_missing_parent_is_created_and_an_existing_one_is_never_touched() {
|
|
1444
|
+
let root = scratch();
|
|
1445
|
+
let file = root.0.join("plain-file");
|
|
1446
|
+
fs::write(&file, b"x").unwrap();
|
|
1447
|
+
let dir_meta = fs::symlink_metadata(&root.0).unwrap();
|
|
1448
|
+
let file_meta = fs::symlink_metadata(&file).unwrap();
|
|
1449
|
+
assert_eq!(
|
|
1450
|
+
lock_parent_action(None, true),
|
|
1451
|
+
LockParentAction::CreatePrivate
|
|
1452
|
+
);
|
|
1453
|
+
assert_eq!(lock_parent_action(None, false), LockParentAction::Refuse);
|
|
1454
|
+
for create in [true, false] {
|
|
1455
|
+
assert_eq!(
|
|
1456
|
+
lock_parent_action(Some(&dir_meta), create),
|
|
1457
|
+
LockParentAction::UseExisting
|
|
1458
|
+
);
|
|
1459
|
+
assert_eq!(
|
|
1460
|
+
lock_parent_action(Some(&file_meta), create),
|
|
1461
|
+
LockParentAction::Refuse
|
|
1462
|
+
);
|
|
1463
|
+
}
|
|
1464
|
+
}
|
|
1465
|
+
|
|
1466
|
+
#[test]
|
|
1467
|
+
fn create_private_dir_if_missing_reports_creation_and_keeps_existing_modes() {
|
|
1468
|
+
let root = scratch();
|
|
1469
|
+
let created = root.0.join("new").join("home");
|
|
1470
|
+
assert!(create_private_dir_if_missing(&created).unwrap());
|
|
1471
|
+
assert!(!create_private_dir_if_missing(&created).unwrap());
|
|
1472
|
+
#[cfg(unix)]
|
|
1473
|
+
{
|
|
1474
|
+
use std::os::unix::fs::PermissionsExt;
|
|
1475
|
+
let mode = |p: &Path| fs::metadata(p).unwrap().permissions().mode() & 0o777;
|
|
1476
|
+
assert_eq!(mode(&created), 0o700);
|
|
1477
|
+
let shared = root.0.join("shared");
|
|
1478
|
+
fs::create_dir(&shared).unwrap();
|
|
1479
|
+
fs::set_permissions(&shared, fs::Permissions::from_mode(0o755)).unwrap();
|
|
1480
|
+
assert!(!create_private_dir_if_missing(&shared).unwrap());
|
|
1481
|
+
let lock = FileLock::acquire_blocking(&shared.join("child.lock")).unwrap();
|
|
1482
|
+
drop(lock);
|
|
1483
|
+
assert_eq!(mode(&shared), 0o755);
|
|
1484
|
+
assert_eq!(mode(&shared.join("child.lock")), 0o600);
|
|
1485
|
+
}
|
|
1486
|
+
}
|
|
1487
|
+
}
|