kobako 0.30.0 → 0.31.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.
Files changed (266) hide show
  1. checksums.yaml +4 -4
  2. data/.release-please-manifest.json +1 -1
  3. data/CHANGELOG.md +335 -0
  4. data/Cargo.lock +469 -11
  5. data/README.md +43 -3
  6. data/ROADMAP.md +1 -1
  7. data/crates/kobako-runtime/CHANGELOG.md +219 -0
  8. data/crates/kobako-runtime/Cargo.toml +51 -3
  9. data/crates/kobako-runtime/README.md +7 -4
  10. data/crates/kobako-runtime/src/cred.rs +124 -0
  11. data/crates/kobako-runtime/src/dispatch.rs +4 -5
  12. data/crates/kobako-runtime/src/endpoint/buffer.rs +153 -44
  13. data/crates/kobako-runtime/src/endpoint/dispatch.rs +80 -41
  14. data/crates/kobako-runtime/src/endpoint/invoke.rs +23 -36
  15. data/crates/kobako-runtime/src/endpoint.rs +137 -36
  16. data/crates/kobako-runtime/src/errno.rs +391 -0
  17. data/crates/kobako-runtime/src/error.rs +31 -10
  18. data/crates/kobako-runtime/src/filesystem/anon_inodes.rs +52 -0
  19. data/crates/kobako-runtime/src/filesystem/bind/lookup.rs +52 -14
  20. data/crates/kobako-runtime/src/filesystem/bind/walk.rs +19 -20
  21. data/crates/kobako-runtime/src/filesystem/bind.rs +437 -245
  22. data/crates/kobako-runtime/src/filesystem/overlay/file.rs +6 -6
  23. data/crates/kobako-runtime/src/filesystem/overlay/path.rs +43 -65
  24. data/crates/kobako-runtime/src/filesystem/overlay/stack/copy_up.rs +9 -16
  25. data/crates/kobako-runtime/src/filesystem/overlay/stack/dir.rs +47 -72
  26. data/crates/kobako-runtime/src/filesystem/overlay/stack/namei.rs +12 -12
  27. data/crates/kobako-runtime/src/filesystem/overlay/stack/readdir.rs +4 -7
  28. data/crates/kobako-runtime/src/filesystem/overlay/stack.rs +121 -37
  29. data/crates/kobako-runtime/src/filesystem/overlay.rs +302 -343
  30. data/crates/kobako-runtime/src/filesystem/pipe.rs +12 -9
  31. data/crates/kobako-runtime/src/filesystem/rdir.rs +15 -32
  32. data/crates/kobako-runtime/src/filesystem/tmpfs/seed.rs +32 -0
  33. data/crates/kobako-runtime/src/filesystem/tmpfs/tmpfile.rs +3 -3
  34. data/crates/kobako-runtime/src/filesystem/tmpfs/whiteout.rs +57 -35
  35. data/crates/kobako-runtime/src/filesystem/tmpfs/xattr.rs +2 -2
  36. data/crates/kobako-runtime/src/filesystem/tmpfs.rs +172 -160
  37. data/crates/kobako-runtime/src/filesystem/wrap.rs +36 -52
  38. data/crates/kobako-runtime/src/filesystem.rs +6 -3
  39. data/crates/kobako-runtime/src/fork.rs +96 -0
  40. data/crates/kobako-runtime/src/grant.rs +3 -0
  41. data/crates/kobako-runtime/src/hashtable.rs +4 -2
  42. data/crates/kobako-runtime/src/lib.rs +18 -7
  43. data/crates/kobako-runtime/src/limits.rs +195 -0
  44. data/crates/kobako-runtime/src/locking.rs +10 -0
  45. data/crates/kobako-runtime/src/memcg.rs +383 -0
  46. data/crates/kobako-runtime/src/mount.rs +67 -9
  47. data/crates/kobako-runtime/src/net/backends.rs +43 -0
  48. data/crates/kobako-runtime/src/net/connections.rs +179 -0
  49. data/crates/kobako-runtime/src/net/credential.rs +125 -0
  50. data/crates/kobako-runtime/src/net/egress.rs +160 -0
  51. data/crates/kobako-runtime/src/net/family.rs +181 -0
  52. data/crates/kobako-runtime/src/net/http.rs +2733 -0
  53. data/crates/kobako-runtime/src/net/lookup.rs +285 -0
  54. data/crates/kobako-runtime/src/net/mock.rs +251 -0
  55. data/crates/kobako-runtime/src/net/namespace.rs +1366 -0
  56. data/crates/kobako-runtime/src/net/reactor.rs +531 -0
  57. data/crates/kobako-runtime/src/net/resolv/darwin.rs +275 -0
  58. data/crates/kobako-runtime/src/net/resolv/stub/tests.rs +469 -0
  59. data/crates/kobako-runtime/src/net/resolv/stub.rs +536 -0
  60. data/crates/kobako-runtime/src/net/resolv/windows.rs +248 -0
  61. data/crates/kobako-runtime/src/net/resolv.rs +227 -0
  62. data/crates/kobako-runtime/src/net/socket.rs +870 -0
  63. data/crates/kobako-runtime/src/net/tcp.rs +1588 -0
  64. data/crates/kobako-runtime/src/net/tls.rs +58 -0
  65. data/crates/kobako-runtime/src/net/transport.rs +279 -0
  66. data/crates/kobako-runtime/src/net/udp.rs +1003 -0
  67. data/crates/kobako-runtime/src/net.rs +42 -0
  68. data/crates/kobako-runtime/src/network/builder.rs +177 -0
  69. data/crates/kobako-runtime/src/network/ruleset.rs +777 -0
  70. data/crates/kobako-runtime/src/network.rs +551 -0
  71. data/crates/kobako-runtime/src/policy.rs +16 -0
  72. data/crates/kobako-runtime/src/profile.rs +29 -144
  73. data/crates/kobako-runtime/src/runtime.rs +3 -5
  74. data/crates/kobako-runtime/src/sched.rs +130 -29
  75. data/crates/kobako-runtime/src/security/entry_policy.rs +22 -0
  76. data/crates/kobako-runtime/src/{vfs/cred.rs → security/hooks.rs} +52 -144
  77. data/crates/kobako-runtime/src/security/mount_policy.rs +158 -0
  78. data/crates/kobako-runtime/src/security.rs +101 -196
  79. data/crates/kobako-runtime/src/snapshot.rs +121 -2
  80. data/crates/kobako-runtime/src/vfs/attr.rs +5 -5
  81. data/crates/kobako-runtime/src/vfs/dentry.rs +143 -89
  82. data/crates/kobako-runtime/src/vfs/file.rs +199 -203
  83. data/crates/kobako-runtime/src/vfs/inode.rs +41 -45
  84. data/crates/kobako-runtime/src/vfs/kern_path.rs +38 -42
  85. data/crates/kobako-runtime/src/vfs/mount.rs +10 -9
  86. data/crates/kobako-runtime/src/vfs/namei.rs +829 -700
  87. data/crates/kobako-runtime/src/vfs/namespace.rs +162 -0
  88. data/crates/kobako-runtime/src/vfs/open_files.rs +69 -0
  89. data/crates/kobako-runtime/src/vfs/openat2.rs +3 -3
  90. data/crates/kobako-runtime/src/vfs/path.rs +6 -6
  91. data/crates/kobako-runtime/src/vfs/readdir.rs +6 -6
  92. data/crates/kobako-runtime/src/vfs/stat.rs +159 -23
  93. data/crates/kobako-runtime/src/vfs/super_block.rs +18 -14
  94. data/crates/kobako-runtime/src/vfs/utimes.rs +37 -27
  95. data/crates/kobako-runtime/src/vfs.rs +9 -6
  96. data/crates/kobako-runtime/src/wait.rs +356 -0
  97. data/crates/kobako-transport/CHANGELOG.md +31 -0
  98. data/crates/kobako-transport/Cargo.toml +1 -1
  99. data/crates/kobako-transport/README.md +3 -4
  100. data/crates/kobako-transport/src/abi.rs +78 -72
  101. data/crates/kobako-transport/src/envelope/bytes.rs +17 -6
  102. data/crates/kobako-transport/src/envelope/call.rs +32 -4
  103. data/crates/kobako-transport/src/envelope/error_record.rs +21 -0
  104. data/crates/kobako-transport/src/envelope/name.rs +99 -0
  105. data/crates/kobako-transport/src/envelope/outcome.rs +9 -9
  106. data/crates/kobako-transport/src/envelope/preamble.rs +24 -21
  107. data/crates/kobako-transport/src/envelope/reply.rs +27 -27
  108. data/crates/kobako-transport/src/envelope/unsupported.rs +10 -10
  109. data/crates/kobako-transport/src/envelope.rs +13 -8
  110. data/crates/kobako-wasmtime/CHANGELOG.md +161 -0
  111. data/crates/kobako-wasmtime/Cargo.toml +26 -7
  112. data/crates/kobako-wasmtime/README.md +3 -2
  113. data/crates/kobako-wasmtime/build/preview2.rs +1339 -0
  114. data/crates/kobako-wasmtime/build.rs +16 -0
  115. data/crates/kobako-wasmtime/src/abi.rs +17 -37
  116. data/crates/kobako-wasmtime/src/ambient.rs +33 -18
  117. data/crates/kobako-wasmtime/src/cache.rs +23 -15
  118. data/crates/kobako-wasmtime/src/config.rs +52 -68
  119. data/crates/kobako-wasmtime/src/driver.rs +48 -63
  120. data/crates/kobako-wasmtime/src/exports.rs +143 -17
  121. data/crates/kobako-wasmtime/src/guest.rs +12 -6
  122. data/crates/kobako-wasmtime/src/guest_binary.rs +14 -0
  123. data/crates/kobako-wasmtime/src/imports.rs +42 -18
  124. data/crates/kobako-wasmtime/src/instance_pre.rs +4 -4
  125. data/crates/kobako-wasmtime/src/invocation.rs +74 -12
  126. data/crates/kobako-wasmtime/src/lib.rs +5 -3
  127. data/crates/kobako-wasmtime/src/limiter.rs +70 -5
  128. data/crates/kobako-wasmtime/src/preview1/descriptors.rs +309 -0
  129. data/crates/kobako-wasmtime/src/preview1/differential/mount.rs +5 -15
  130. data/crates/kobako-wasmtime/src/preview1/differential.rs +27 -31
  131. data/crates/kobako-wasmtime/src/preview1/errno.rs +55 -66
  132. data/crates/kobako-wasmtime/src/preview1/fd.rs +327 -296
  133. data/crates/kobako-wasmtime/src/preview1/memory.rs +21 -12
  134. data/crates/kobako-wasmtime/src/preview1/mount_view/wrap.rs +34 -53
  135. data/crates/kobako-wasmtime/src/preview1/mount_view.rs +231 -217
  136. data/crates/kobako-wasmtime/src/preview1/path.rs +56 -121
  137. data/crates/kobako-wasmtime/src/preview1/poll.rs +244 -120
  138. data/crates/kobako-wasmtime/src/preview1/sock.rs +10 -8
  139. data/crates/kobako-wasmtime/src/preview1/testsuite.rs +5 -15
  140. data/crates/kobako-wasmtime/src/preview1.rs +46 -42
  141. data/crates/kobako-wasmtime/src/preview2/abi.rs +227 -0
  142. data/crates/kobako-wasmtime/src/preview2/error.rs +118 -0
  143. data/crates/kobako-wasmtime/src/preview2/filesystem.rs +122 -0
  144. data/crates/kobako-wasmtime/src/preview2/host.rs +3959 -0
  145. data/crates/kobako-wasmtime/src/preview2/http.rs +1503 -0
  146. data/crates/kobako-wasmtime/src/preview2/io.rs +315 -0
  147. data/crates/kobako-wasmtime/src/preview2/sockets.rs +379 -0
  148. data/crates/kobako-wasmtime/src/preview2/table.rs +305 -0
  149. data/crates/kobako-wasmtime/src/preview2.rs +57 -0
  150. data/crates/kobako-wasmtime/src/trap.rs +24 -9
  151. data/crates/kobako-wasmtime/src/wasi.rs +210 -81
  152. data/crates/kobako-wasmtime/wit/deps/cli.wit +233 -0
  153. data/crates/kobako-wasmtime/wit/deps/clocks.wit +162 -0
  154. data/crates/kobako-wasmtime/wit/deps/filesystem.wit +589 -0
  155. data/crates/kobako-wasmtime/wit/deps/http.wit +733 -0
  156. data/crates/kobako-wasmtime/wit/deps/io.wit +299 -0
  157. data/crates/kobako-wasmtime/wit/deps/random.wit +92 -0
  158. data/crates/kobako-wasmtime/wit/deps/sockets.wit +949 -0
  159. data/data/kobako.wasm +0 -0
  160. data/ext/kobako/Cargo.toml +1 -1
  161. data/ext/kobako/src/{runtime/errors.rs → errors.rs} +34 -26
  162. data/ext/kobako/src/{runtime/escape.rs → escape.rs} +42 -11
  163. data/ext/kobako/src/{runtime/filesystem → filesystem}/grants.rs +30 -26
  164. data/ext/kobako/src/{runtime/filesystem → filesystem}/ruby.rs +149 -168
  165. data/ext/kobako/src/{runtime/filesystem.rs → filesystem.rs} +24 -15
  166. data/ext/kobako/src/gvl.rs +306 -0
  167. data/ext/kobako/src/lib.rs +64 -3
  168. data/ext/kobako/src/network/mock.rs +187 -0
  169. data/ext/kobako/src/network.rs +591 -0
  170. data/ext/kobako/src/runtime/bridge.rs +30 -29
  171. data/ext/kobako/src/runtime/snapshot.rs +4 -4
  172. data/ext/kobako/src/runtime.rs +221 -143
  173. data/ext/kobako/src/wire.rs +42 -0
  174. data/lib/kobako/catalog/extensions.rb +14 -2
  175. data/lib/kobako/catalog/flags.rb +3 -5
  176. data/lib/kobako/catalog/grants.rb +5 -4
  177. data/lib/kobako/catalog/handles.rb +5 -27
  178. data/lib/kobako/catalog/mount.rb +11 -3
  179. data/lib/kobako/catalog/network.rb +35 -0
  180. data/lib/kobako/catalog/replacements.rb +28 -0
  181. data/lib/kobako/catalog/services.rb +5 -19
  182. data/lib/kobako/catalog/snippets.rb +3 -18
  183. data/lib/kobako/catalog.rb +3 -0
  184. data/lib/kobako/codec/{utils.rb → boundary.rb} +4 -2
  185. data/lib/kobako/codec/decoder.rb +4 -4
  186. data/lib/kobako/codec/ext_types.rb +3 -3
  187. data/lib/kobako/codec/handle_walk.rb +3 -43
  188. data/lib/kobako/codec/value_budget.rb +132 -40
  189. data/lib/kobako/codec.rb +1 -1
  190. data/lib/kobako/context.rb +24 -11
  191. data/lib/kobako/errors.rb +15 -12
  192. data/lib/kobako/extension.rb +3 -2
  193. data/lib/kobako/filesystem.rb +9 -2
  194. data/lib/kobako/handle.rb +2 -2
  195. data/lib/kobako/names.rb +28 -0
  196. data/lib/kobako/network.rb +210 -0
  197. data/lib/kobako/outcome.rb +7 -7
  198. data/lib/kobako/pool.rb +45 -23
  199. data/lib/kobako/runtime.rb +3 -2
  200. data/lib/kobako/sandbox.rb +92 -35
  201. data/lib/kobako/sandbox_options.rb +41 -106
  202. data/lib/kobako/transport/argument_wrap.rb +64 -0
  203. data/lib/kobako/transport/block_failure.rb +1 -1
  204. data/lib/kobako/transport/dispatcher.rb +6 -6
  205. data/lib/kobako/transport/exposure.rb +26 -15
  206. data/lib/kobako/transport/reflection.rb +21 -4
  207. data/lib/kobako/transport/run.rb +8 -23
  208. data/lib/kobako/transport/yielder.rb +2 -9
  209. data/lib/kobako/transport.rb +1 -0
  210. data/lib/kobako/version.rb +1 -1
  211. data/lib/kobako.rb +6 -2
  212. data/release-please-config.json +15 -0
  213. data/sig/core/thread.rbs +6 -0
  214. data/sig/kobako/catalog/extensions.rbs +2 -0
  215. data/sig/kobako/catalog/grants.rbs +7 -4
  216. data/sig/kobako/catalog/handles.rbs +0 -2
  217. data/sig/kobako/catalog/mount.rbs +3 -1
  218. data/sig/kobako/catalog/network.rbs +20 -0
  219. data/sig/kobako/catalog/replacements.rbs +14 -0
  220. data/sig/kobako/catalog/services.rbs +0 -4
  221. data/sig/kobako/catalog/snippets.rbs +0 -2
  222. data/sig/kobako/codec/{utils.rbs → boundary.rbs} +2 -2
  223. data/sig/kobako/codec/handle_walk.rbs +0 -6
  224. data/sig/kobako/codec/value_budget.rbs +47 -4
  225. data/sig/kobako/context.rbs +3 -1
  226. data/sig/kobako/errors.rbs +4 -4
  227. data/sig/kobako/filesystem.rbs +21 -3
  228. data/sig/kobako/network.rbs +115 -0
  229. data/sig/kobako/outcome.rbs +1 -1
  230. data/sig/kobako/pool.rbs +7 -3
  231. data/sig/kobako/runtime.rbs +32 -3
  232. data/sig/kobako/sandbox.rbs +19 -2
  233. data/sig/kobako/sandbox_options.rbs +29 -38
  234. data/sig/kobako/transport/argument_wrap.rbs +15 -0
  235. data/sig/kobako/transport/error.rbs +1 -1
  236. data/sig/kobako/transport/exposure.rbs +2 -4
  237. data/sig/kobako/transport/reflection.rbs +10 -0
  238. data/sig/kobako/transport/run.rbs +0 -2
  239. data/sig/kobako/transport/yielder.rbs +0 -3
  240. data/sig/kobako/transport.rbs +1 -1
  241. data/sig/kobako.rbs +13 -0
  242. metadata +84 -35
  243. data/crates/kobako-runtime/src/endpoint/capture.rs +0 -115
  244. data/crates/kobako-runtime/src/endpoint/memory_cap.rs +0 -238
  245. data/crates/kobako-runtime/src/filesystem/path.rs +0 -21
  246. data/crates/kobako-runtime/src/vfs/errno.rs +0 -153
  247. data/crates/kobako-runtime/tests/linux_baseline/calls.rs +0 -171
  248. data/crates/kobako-runtime/tests/linux_baseline/concurrent.rs +0 -276
  249. data/crates/kobako-runtime/tests/linux_baseline/kobako.rs +0 -323
  250. data/crates/kobako-runtime/tests/linux_baseline/linux-baseline-expected.txt +0 -16
  251. data/crates/kobako-runtime/tests/linux_baseline/linux.rs +0 -449
  252. data/crates/kobako-runtime/tests/linux_baseline/main.rs +0 -611
  253. data/crates/kobako-runtime/tests/linux_baseline/permissions.rs +0 -236
  254. data/crates/kobako-wasmtime/src/descriptors.rs +0 -200
  255. data/crates/kobako-wasmtime/tests/integration/compile_posture.rs +0 -43
  256. data/crates/kobako-wasmtime/tests/integration/guest_file.rs +0 -1085
  257. data/crates/kobako-wasmtime/tests/integration/main.rs +0 -29
  258. data/crates/kobako-wasmtime/tests/integration/preamble_flags.rs +0 -70
  259. data/crates/kobako-wasmtime/tests/integration/snippet_compile.rs +0 -95
  260. data/crates/kobako-wasmtime/tests/integration/support/mod.rs +0 -30
  261. data/crates/kobako-wasmtime/tests/integration/unanswered_call.rs +0 -86
  262. data/crates/kobako-wasmtime/tests/integration/unsupported_call.rs +0 -51
  263. data/ext/kobako/src/runtime/gvl.rs +0 -147
  264. data/lib/kobako/constant_name.rb +0 -8
  265. data/sig/kobako/constant_name.rbs +0 -3
  266. /data/ext/kobako/src/{runtime/pinned_value.rs → pinned_value.rs} +0 -0
@@ -0,0 +1,179 @@
1
+ //! The connections a guest holds open, counted against its Sandbox and the
2
+ //! process, as a cgroup's `pids.max` bounds the tasks beneath it, so one
3
+ //! tenant cannot starve another of host sockets. A socket and an HTTP request
4
+ //! each hold one place until released, and a request's connection still
5
+ //! sending holds it until it closes; a name lookup holds one until it answers
6
+ //! or is dropped, which cancels its query.
7
+
8
+ use std::sync::{Arc, LazyLock, Mutex, PoisonError};
9
+
10
+ use crate::fork::{Pid, ProcessLocal};
11
+
12
+ /// The process's limit until a Host App sets its own, as tokio caps its
13
+ /// blocking pool.
14
+ const DEFAULT_PROCESS_LIMIT: usize = 512;
15
+
16
+ static PROCESS: LazyLock<Arc<OpenConnections>> =
17
+ LazyLock::new(|| OpenConnections::new(Some(DEFAULT_PROCESS_LIMIT)));
18
+
19
+ /// Every connection the process's Sandboxes hold open together, 512 at most
20
+ /// until `set_limit` moves it.
21
+ pub fn process_connections() -> &'static Arc<OpenConnections> {
22
+ &PROCESS
23
+ }
24
+
25
+ /// How many connections one owner holds open, and the most it may. A count is
26
+ /// the process's own: a forked child, which inherits no socket of its
27
+ /// parent's runs, starts from none.
28
+ pub struct OpenConnections {
29
+ /// The most held at once; `None` lifts the limit.
30
+ limit: Mutex<Option<usize>>,
31
+ /// How many are held, counted in this process alone.
32
+ count: ProcessLocal<usize>,
33
+ }
34
+
35
+ impl OpenConnections {
36
+ /// None held yet, at most `limit` at once; `None` lifts the limit.
37
+ pub fn new(limit: Option<usize>) -> Arc<Self> {
38
+ Arc::new(Self {
39
+ limit: Mutex::new(limit),
40
+ count: ProcessLocal::new(),
41
+ })
42
+ }
43
+
44
+ /// Move the limit, as writing `pids.max` does: one held past a lowered
45
+ /// limit stays open, and the next is refused.
46
+ pub fn set_limit(&self, limit: Option<usize>) {
47
+ *self.limit.lock().unwrap_or_else(PoisonError::into_inner) = limit;
48
+ }
49
+
50
+ /// Whether one more fits, counting it if so.
51
+ fn try_open(&self) -> bool {
52
+ let limit = *self.limit.lock().unwrap_or_else(PoisonError::into_inner);
53
+ self.count.with(|count| {
54
+ let count = count.get_or_insert(0);
55
+ if limit.is_some_and(|limit| *count >= limit) {
56
+ return false;
57
+ }
58
+ *count += 1;
59
+ true
60
+ })
61
+ }
62
+
63
+ /// One given back, counted in `pid`; one a parent counted is not this
64
+ /// process's to give back.
65
+ fn close(&self, pid: Pid) {
66
+ if pid.is_current() {
67
+ self.count.with(|count| {
68
+ if let Some(count) = count {
69
+ *count -= 1;
70
+ }
71
+ });
72
+ }
73
+ }
74
+ }
75
+
76
+ /// One connection's place against its Sandbox and the process, given back as
77
+ /// it drops, as a task's exit uncharges its cgroup.
78
+ pub(crate) struct Place {
79
+ owners: [Arc<OpenConnections>; 2],
80
+ pid: Pid,
81
+ }
82
+
83
+ impl Drop for Place {
84
+ fn drop(&mut self) {
85
+ self.owners.iter().for_each(|owner| owner.close(self.pid));
86
+ }
87
+ }
88
+
89
+ /// A place counted against `sandbox` and the process, or `None` when either
90
+ /// is full.
91
+ pub(crate) fn open(sandbox: &Arc<OpenConnections>) -> Option<Place> {
92
+ open_within(sandbox, &PROCESS)
93
+ }
94
+
95
+ /// A place counted against `sandbox` and then `process`, or `None`, counting
96
+ /// nothing, when either is full.
97
+ pub(super) fn open_within(
98
+ sandbox: &Arc<OpenConnections>,
99
+ process: &Arc<OpenConnections>,
100
+ ) -> Option<Place> {
101
+ let pid = Pid::current();
102
+ if !sandbox.try_open() {
103
+ return None;
104
+ }
105
+ if !process.try_open() {
106
+ sandbox.close(pid);
107
+ return None;
108
+ }
109
+ Some(Place {
110
+ owners: [sandbox.clone(), process.clone()],
111
+ pid,
112
+ })
113
+ }
114
+
115
+ #[cfg(test)]
116
+ mod tests {
117
+ use super::*;
118
+
119
+ // @behavior NW-022
120
+ #[test]
121
+ fn a_full_sandbox_opens_no_more_until_one_is_given_back() {
122
+ let sandbox = OpenConnections::new(Some(2));
123
+ let held = [open(&sandbox), open(&sandbox)];
124
+ let full = open(&sandbox).is_none();
125
+ drop(held);
126
+ assert!(
127
+ full && open(&sandbox).is_some(),
128
+ "a Sandbox at its open connection limit must open no more until one is given back"
129
+ );
130
+ }
131
+
132
+ // @behavior NW-022
133
+ #[test]
134
+ fn a_full_process_opens_no_more_for_any_sandbox() {
135
+ let process = OpenConnections::new(Some(2));
136
+ let (first, second) = (OpenConnections::new(None), OpenConnections::new(None));
137
+ let held = [open_within(&first, &process), open_within(&first, &process)];
138
+ let refused = open_within(&second, &process).is_none();
139
+ let counted_while_refused = second.count.with(|count| count.unwrap_or(0));
140
+ drop(held);
141
+ assert!(
142
+ refused && counted_while_refused == 0 && open_within(&second, &process).is_some(),
143
+ "a process at its limit must open no more for another Sandbox until one is given \
144
+ back, counting nothing against the Sandbox it refused"
145
+ );
146
+ }
147
+
148
+ // @behavior NW-022
149
+ #[test]
150
+ fn a_count_made_in_another_process_starts_from_none() {
151
+ let sandbox = OpenConnections::new(Some(2));
152
+ sandbox.count.with(|count| *count = Some(2));
153
+ sandbox.count.inherit();
154
+ assert!(
155
+ open(&sandbox).is_some(),
156
+ "a connection count inherited across a fork must start from none in the child"
157
+ );
158
+ }
159
+
160
+ // @behavior NW-060
161
+ #[test]
162
+ fn a_lowered_limit_keeps_what_is_open_and_refuses_the_next() {
163
+ let process = OpenConnections::new(Some(3));
164
+ let sandbox = OpenConnections::new(None);
165
+ let held = [
166
+ open_within(&sandbox, &process),
167
+ open_within(&sandbox, &process),
168
+ ];
169
+ process.set_limit(Some(1));
170
+ let refused = open_within(&sandbox, &process).is_none();
171
+ process.set_limit(None);
172
+ let lifted = open_within(&sandbox, &process).is_some();
173
+ assert!(
174
+ held.iter().all(Option::is_some) && refused && lifted,
175
+ "OpenConnections::set_limit below what is open must keep each one open and refuse \
176
+ the next, and None must lift the limit"
177
+ );
178
+ }
179
+ }
@@ -0,0 +1,125 @@
1
+ //! A credential's swap into a request on its way out: the placeholder the
2
+ //! guest wrote replaced by the secret, in the one header its binding names, as
3
+ //! OpenShell's egress proxy swaps one.
4
+
5
+ use crate::network::Secret;
6
+
7
+ /// The scheme an `authorization` header names a basic pair by.
8
+ const BASIC: &[u8] = b"Basic ";
9
+
10
+ /// RFC 4648's standard alphabet, which a basic pair is encoded in.
11
+ const BASE64: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
12
+
13
+ fn encode_base64(bytes: &[u8]) -> Vec<u8> {
14
+ let mut encoded = Vec::with_capacity(bytes.len().div_ceil(3) * 4);
15
+ for chunk in bytes.chunks(3) {
16
+ let n = chunk
17
+ .iter()
18
+ .enumerate()
19
+ .fold(0u32, |n, (i, byte)| n | u32::from(*byte) << (16 - 8 * i));
20
+ for i in 0..4 {
21
+ encoded.push(match i <= chunk.len() {
22
+ true => BASE64[(n >> (18 - 6 * i) & 63) as usize],
23
+ false => b'=',
24
+ });
25
+ }
26
+ }
27
+ encoded
28
+ }
29
+
30
+ /// The bytes `text` encodes, `None` for text that is no padded base64.
31
+ fn decode_base64(text: &[u8]) -> Option<Vec<u8>> {
32
+ if !text.len().is_multiple_of(4) {
33
+ return None;
34
+ }
35
+ let mut decoded = Vec::with_capacity(text.len() / 4 * 3);
36
+ for chunk in text.chunks(4) {
37
+ let padding = chunk.iter().rev().take_while(|byte| **byte == b'=').count();
38
+ if padding > 2 {
39
+ return None;
40
+ }
41
+ let mut n = 0u32;
42
+ for (i, byte) in chunk[..4 - padding].iter().enumerate() {
43
+ let value = BASE64.iter().position(|b| b == byte)? as u32;
44
+ n |= value << (18 - 6 * i);
45
+ }
46
+ decoded.extend(n.to_be_bytes()[1..4 - padding].iter());
47
+ }
48
+ Some(decoded)
49
+ }
50
+
51
+ /// One placeholder to replace with a secret in one named header's value.
52
+ #[derive(Clone, Debug, PartialEq, Eq)]
53
+ pub(crate) struct Swap {
54
+ pub(crate) header: String,
55
+ pub(crate) placeholder: Vec<u8>,
56
+ pub(crate) secret: Secret,
57
+ }
58
+
59
+ impl Swap {
60
+ /// `value`, the named header's, with the placeholder replaced. A `Basic`
61
+ /// credential carries its pair encoded, so the placeholder is replaced in
62
+ /// the decoded pair, which is encoded again, as OpenShell's does.
63
+ pub(crate) fn apply(&self, name: &str, value: &[u8]) -> Vec<u8> {
64
+ if !name.eq_ignore_ascii_case(&self.header) || self.placeholder.is_empty() {
65
+ return value.to_vec();
66
+ }
67
+ if let Some(pair) =
68
+ basic_pair_of(value).filter(|pair| position_of(&self.placeholder, pair).is_some())
69
+ {
70
+ let mut swapped = BASIC.to_vec();
71
+ swapped.extend(encode_base64(&self.replace(&pair)));
72
+ return swapped;
73
+ }
74
+ self.replace(value)
75
+ }
76
+
77
+ /// `value` with its first placeholder replaced by the secret, so a swap
78
+ /// grows a value by one secret at most.
79
+ fn replace(&self, value: &[u8]) -> Vec<u8> {
80
+ match position_of(&self.placeholder, value) {
81
+ Some(at) => [
82
+ &value[..at],
83
+ self.secret.expose(),
84
+ &value[at + self.placeholder.len()..],
85
+ ]
86
+ .concat(),
87
+ None => value.to_vec(),
88
+ }
89
+ }
90
+ }
91
+
92
+ /// How many times a header's `value` carries `placeholder`, as sent or inside
93
+ /// the pair a `Basic` value encodes, as OpenShell finds one.
94
+ pub(crate) fn occurrences_of(placeholder: &[u8], value: &[u8]) -> usize {
95
+ if placeholder.is_empty() {
96
+ return 0;
97
+ }
98
+ match basic_pair_of(value).map(|pair| count_of(placeholder, &pair)) {
99
+ Some(inside) if inside > 0 => inside,
100
+ _ => count_of(placeholder, value),
101
+ }
102
+ }
103
+
104
+ /// The pair a `Basic` value encodes.
105
+ fn basic_pair_of(value: &[u8]) -> Option<Vec<u8>> {
106
+ value
107
+ .get(..BASIC.len())
108
+ .filter(|scheme| scheme.eq_ignore_ascii_case(BASIC))
109
+ .and_then(|_| decode_base64(&value[BASIC.len()..]))
110
+ }
111
+
112
+ fn position_of(part: &[u8], value: &[u8]) -> Option<usize> {
113
+ value.windows(part.len()).position(|window| window == part)
114
+ }
115
+
116
+ /// How many times `part` stands in `value`, each after the last one's end.
117
+ fn count_of(part: &[u8], value: &[u8]) -> usize {
118
+ let mut rest = value;
119
+ let mut found = 0;
120
+ while let Some(at) = position_of(part, rest) {
121
+ found += 1;
122
+ rest = &rest[at + part.len()..];
123
+ }
124
+ found
125
+ }
@@ -0,0 +1,160 @@
1
+ //! The HTTP layer's own judgment, as an egress proxy makes it beside the
2
+ //! kernel's: the socket hooks and the ruleset on the authority, each entry's
3
+ //! request policies, and the credentials bound to its own endpoints. It reads
4
+ //! the namespace's state and decides at layer 7.
5
+
6
+ use std::sync::Arc;
7
+
8
+ use super::credential::{occurrences_of, Swap};
9
+ use super::http::{
10
+ is_token, join_authority, split_authority, to_field_name, to_field_value, to_origin_form,
11
+ Exchange, FieldError, HttpError, OutgoingRequest, Scheme,
12
+ };
13
+ use super::lookup::allows_lookup;
14
+ use super::socket::{check_family, AddressFamily};
15
+ use super::transport::Connector;
16
+ use super::Namespace;
17
+ use crate::cred::Cred;
18
+ use crate::network::{Connection, Credential, Host, Protocol, Request, Ruleset};
19
+ use crate::policy::Policy;
20
+
21
+ /// Send an HTTP request in `net` as `cred`. The socket hooks judge the
22
+ /// authority the guest named first, a name passing the `resolve` policies
23
+ /// too, and an `http` endpoint must name it at its port; a literal address
24
+ /// passes the ruleset as itself, so a virtual one is refused, and an IPv6 one
25
+ /// reaches nothing. A header the guest may not set is refused too, so the
26
+ /// seam frames every request itself, and each name goes on in lower case,
27
+ /// as a request policy reads it. So is a method that is not a token,
28
+ /// which HTTP cannot carry, and a target not in origin form, which a proxy
29
+ /// would forward past the judged authority, and a bound credential's header
30
+ /// carrying its placeholder more than once. Any refusal answers `Denied`, and
31
+ /// nothing is sent.
32
+ pub fn send(
33
+ net: &Namespace,
34
+ cred: &Arc<Cred>,
35
+ mut request: OutgoingRequest,
36
+ ) -> Result<Arc<Exchange>, HttpError> {
37
+ let in_origin_form = to_origin_form(&request.path_with_query).as_deref()
38
+ == Some(request.path_with_query.as_str());
39
+ if !in_origin_form || !is_token(&request.method) {
40
+ return Err(HttpError::Denied);
41
+ }
42
+ request.headers = std::mem::take(&mut request.headers)
43
+ .into_iter()
44
+ .map(|(name, value)| Ok((to_field_name(&name)?, to_field_value(value)?)))
45
+ .collect::<Result<_, FieldError>>()
46
+ .map_err(|_| HttpError::Denied)?;
47
+ let (host, port) =
48
+ split_authority(&request.authority, request.scheme).ok_or(HttpError::Denied)?;
49
+ let judged = Host::parse(&host).ok_or(HttpError::Denied)?;
50
+ let host = judged.to_string();
51
+ let connection = Connection::new(&host, port, Protocol::Http);
52
+ if cred.security_socket_connect(&connection).is_err() {
53
+ return Err(HttpError::Denied);
54
+ }
55
+ // A literal the socket hooks passed meets the ruleset as itself where
56
+ // the request does, below; one of a family no socket has reaches
57
+ // nothing, as a socket's `connect4` answers it.
58
+ let reachable = match judged {
59
+ Host::Address(ip) => check_family(AddressFamily::of(ip)).is_ok(),
60
+ Host::Name(ref name) => allows_lookup(net, name),
61
+ };
62
+ let path = request
63
+ .path_with_query
64
+ .split_once('?')
65
+ .map_or(request.path_with_query.as_str(), |(path, _)| path);
66
+ let method = request.method.as_str();
67
+ let names = request
68
+ .headers
69
+ .iter()
70
+ .map(|(name, _)| name.as_str())
71
+ .collect::<Vec<_>>();
72
+ let scheme = match request.scheme {
73
+ Scheme::Http => "http",
74
+ Scheme::Https => "https",
75
+ };
76
+ let policy_request = Request::new((&host, port), method, scheme, path, &names);
77
+ let proxy = net.egress();
78
+ let admitted = reachable
79
+ && net.ruleset().admits_request(&judged, port, method, path)
80
+ && proxy.admits(&policy_request);
81
+ if !admitted {
82
+ return Err(HttpError::Denied);
83
+ }
84
+ let swaps = match request.scheme {
85
+ Scheme::Https => proxy
86
+ .swaps_of(&policy_request, &request.headers)
87
+ .ok_or(HttpError::Denied)?,
88
+ Scheme::Http => Vec::new(),
89
+ };
90
+ request.authority = join_authority(&host, port, request.scheme);
91
+ request.swaps = swaps;
92
+
93
+ net.within_connection_budget(HttpError::ConnectionLimitReached, || {
94
+ Exchange::start(
95
+ net.outbound().clone(),
96
+ request,
97
+ |place| Connector::new(net, cred, judged, port, place),
98
+ net.open_connections(),
99
+ cred,
100
+ )
101
+ })
102
+ }
103
+
104
+ /// The entries' request policies, which judge a request `send` found its
105
+ /// authority reachable for, and the credentials it swaps into one.
106
+ pub(crate) struct EgressProxy {
107
+ pub(crate) request: Vec<Arc<dyn for<'a> Policy<Request<'a>>>>,
108
+ /// Each entry's own endpoints and the credentials bound to them.
109
+ pub(crate) bindings: Vec<(Ruleset, Vec<Credential>)>,
110
+ }
111
+
112
+ impl EgressProxy {
113
+ /// Whether every request policy lets `request` leave.
114
+ pub(crate) fn admits(&self, request: &Request<'_>) -> bool {
115
+ self.request.iter().all(|policy| policy.allows(request))
116
+ }
117
+
118
+ /// The credentials bound to `request`, one over `https`: an entry's own
119
+ /// endpoint names its exact host and allows it, and the placement's header
120
+ /// carries the placeholder once. `None` is a request to refuse: one whose
121
+ /// header carries a placeholder more than once, as OpenShell's leaves no
122
+ /// second placeholder resolved, so a swap grows a request by one secret at
123
+ /// most; or one whose credential's source could not answer. Each source answers here, on the guest thread, so its time counts
124
+ /// against the deadline.
125
+ pub(crate) fn swaps_of(
126
+ &self,
127
+ request: &Request<'_>,
128
+ headers: &[(String, Vec<u8>)],
129
+ ) -> Option<Vec<Swap>> {
130
+ let (host, port) = request.authority;
131
+ let mut swaps = Vec::new();
132
+ for (rules, credentials) in &self.bindings {
133
+ if !rules.binds(host, port, request.method, request.path) {
134
+ continue;
135
+ }
136
+ for credential in credentials {
137
+ let header = credential.placement.header();
138
+ let placeholder = credential.placeholder.as_bytes();
139
+ let carried = headers
140
+ .iter()
141
+ .filter(|(name, _)| name.eq_ignore_ascii_case(header))
142
+ .map(|(_, value)| occurrences_of(placeholder, value))
143
+ .sum::<usize>();
144
+ match carried {
145
+ 0 => continue,
146
+ 1 => {}
147
+ _ => return None,
148
+ }
149
+ if let Some(secret) = credential.source.value_of(request).ok()? {
150
+ swaps.push(Swap {
151
+ header: header.to_string(),
152
+ placeholder: placeholder.to_vec(),
153
+ secret,
154
+ });
155
+ }
156
+ }
157
+ }
158
+ Some(swaps)
159
+ }
160
+ }
@@ -0,0 +1,181 @@
1
+ //! The backend that reaches the host network, as Linux's `net_proto_family`
2
+ //! makes a socket of one family. Every entry of an Invocation dials into one
3
+ //! namespace through one family, which `Backends` names, as gVisor's
4
+ //! `hostinet` is one choice of backend for a sandbox. Each socket it hands
5
+ //! out is non-blocking, so the reactor waits on it and no call blocks a
6
+ //! thread.
7
+
8
+ use std::io;
9
+ use std::net::{IpAddr, SocketAddr, TcpStream, UdpSocket};
10
+
11
+ use super::lookup::{Resolver, Resolving};
12
+
13
+ /// What dials the host network.
14
+ pub trait ProtocolFamily: Send + Sync {
15
+ /// A non-blocking stream to `addr`, whose connect may still be under way,
16
+ /// as a non-blocking `connect` answers `EINPROGRESS`.
17
+ fn connect(&self, addr: SocketAddr) -> io::Result<TcpStream>;
18
+
19
+ /// The host's own addresses, as Linux's `local` routing table holds them,
20
+ /// read at each connect. A family with none answers an empty list; one
21
+ /// that cannot read them, or does not say, answers a failure, and the
22
+ /// connect is refused rather than judged as if the host had none.
23
+ fn local_addresses(&self) -> io::Result<Vec<IpAddr>> {
24
+ Err(io::ErrorKind::Unsupported.into())
25
+ }
26
+
27
+ /// A non-blocking datagram socket bound to an ephemeral port and connected
28
+ /// to `addr`, so it sends to and hears from that one peer. A family with
29
+ /// no datagrams answers `Unsupported`.
30
+ fn connect_datagram(&self, _addr: SocketAddr) -> io::Result<UdpSocket> {
31
+ Err(io::ErrorKind::Unsupported.into())
32
+ }
33
+
34
+ /// Where a datagram socket this family handed out, bound at `local`,
35
+ /// sends once the guest points it at `addr`, keeping its port, as
36
+ /// `__ip4_datagram_connect` routes a socket connected again; `None` when
37
+ /// the socket cannot, as one in another family than where it sends, and a
38
+ /// fresh one is made through `connect_datagram`. The host's own family
39
+ /// sends to `addr` itself; one that sends elsewhere from
40
+ /// `connect_datagram` answers alike here.
41
+ fn route_datagram(
42
+ &self,
43
+ local: SocketAddr,
44
+ addr: SocketAddr,
45
+ ) -> io::Result<Option<SocketAddr>> {
46
+ Ok(is_same_family(local, addr).then_some(addr))
47
+ }
48
+ }
49
+
50
+ /// Whether `local` and `peer` are both IPv4 or both IPv6, as a socket bound
51
+ /// at one may connect to the other.
52
+ pub(crate) fn is_same_family(local: SocketAddr, peer: SocketAddr) -> bool {
53
+ local.is_ipv4() == peer.is_ipv4()
54
+ }
55
+
56
+ /// The host's own network: its TCP and UDP sockets, as gVisor's `hostinet`
57
+ /// hands a sandbox the host's sockets, and the host's resolver.
58
+ #[derive(Default)]
59
+ pub struct HostInet;
60
+
61
+ impl ProtocolFamily for HostInet {
62
+ fn connect(&self, addr: SocketAddr) -> io::Result<TcpStream> {
63
+ Ok(mio::net::TcpStream::connect(addr)?.into())
64
+ }
65
+
66
+ /// The host's own UDP, bound to an ephemeral port of `addr`'s family.
67
+ fn connect_datagram(&self, addr: SocketAddr) -> io::Result<UdpSocket> {
68
+ let socket = UdpSocket::bind(super::resolv::any_address_of(addr))?;
69
+ socket.connect(addr)?;
70
+ socket.set_nonblocking(true)?;
71
+ Ok(socket)
72
+ }
73
+
74
+ fn local_addresses(&self) -> io::Result<Vec<IpAddr>> {
75
+ super::resolv::local_addresses()
76
+ }
77
+ }
78
+
79
+ impl Resolver for HostInet {
80
+ /// The host's resolver, asked for `name` with its trailing dot, so no
81
+ /// search domain lengthens it.
82
+ fn resolve(&self, name: &str) -> Resolving {
83
+ super::resolv::resolve(&format!("{name}."))
84
+ }
85
+ }
86
+
87
+ /// Protocol Families the net tests share.
88
+ #[cfg(test)]
89
+ pub(crate) mod testing {
90
+ use std::future::Future;
91
+ use std::io;
92
+ use std::net::{IpAddr, SocketAddr, TcpStream, UdpSocket};
93
+ use std::pin::Pin;
94
+ use std::sync::atomic::{AtomicUsize, Ordering};
95
+ use std::sync::{mpsc, Arc, Mutex};
96
+ use std::task::{Context, Poll};
97
+
98
+ use super::{ProtocolFamily, Resolver};
99
+ use crate::net::lookup::LookupError;
100
+
101
+ /// A family refusing every dial, TCP or UDP, counting how often it is
102
+ /// asked, beside a resolver that resolves nothing.
103
+ #[derive(Default)]
104
+ pub(crate) struct CountsDials(AtomicUsize);
105
+
106
+ impl CountsDials {
107
+ /// How many dials it refused.
108
+ pub(crate) fn dials(&self) -> usize {
109
+ self.0.load(Ordering::SeqCst)
110
+ }
111
+ }
112
+
113
+ impl ProtocolFamily for CountsDials {
114
+ fn connect(&self, _addr: SocketAddr) -> io::Result<TcpStream> {
115
+ self.0.fetch_add(1, Ordering::SeqCst);
116
+ Err(io::ErrorKind::ConnectionRefused.into())
117
+ }
118
+
119
+ fn connect_datagram(&self, _addr: SocketAddr) -> io::Result<UdpSocket> {
120
+ self.0.fetch_add(1, Ordering::SeqCst);
121
+ Err(io::ErrorKind::ConnectionRefused.into())
122
+ }
123
+ }
124
+
125
+ impl Resolver for CountsDials {
126
+ fn resolve(&self, _name: &str) -> crate::net::Resolving {
127
+ Box::pin(std::future::ready(Err(LookupError::Fail)))
128
+ }
129
+ }
130
+
131
+ /// A host refusing every dial, whose resolver says each query started,
132
+ /// then never answers, counting the queries dropped.
133
+ pub(crate) struct StallsLookups {
134
+ starts: Mutex<mpsc::Sender<()>>,
135
+ cancelled: Arc<AtomicUsize>,
136
+ }
137
+
138
+ impl StallsLookups {
139
+ pub(crate) fn new(starts: mpsc::Sender<()>) -> Self {
140
+ Self {
141
+ starts: Mutex::new(starts),
142
+ cancelled: Arc::default(),
143
+ }
144
+ }
145
+
146
+ /// How many queries were dropped unanswered.
147
+ pub(crate) fn cancelled(&self) -> usize {
148
+ self.cancelled.load(Ordering::SeqCst)
149
+ }
150
+ }
151
+
152
+ impl ProtocolFamily for StallsLookups {
153
+ fn connect(&self, _addr: SocketAddr) -> io::Result<TcpStream> {
154
+ Err(io::ErrorKind::ConnectionRefused.into())
155
+ }
156
+ }
157
+
158
+ impl Resolver for StallsLookups {
159
+ fn resolve(&self, _name: &str) -> crate::net::Resolving {
160
+ let _ = self.starts.lock().unwrap().send(());
161
+ Box::pin(Stalled(self.cancelled.clone()))
162
+ }
163
+ }
164
+
165
+ /// One query that never answers, counted as it drops.
166
+ struct Stalled(Arc<AtomicUsize>);
167
+
168
+ impl Future for Stalled {
169
+ type Output = Result<Vec<IpAddr>, LookupError>;
170
+
171
+ fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
172
+ Poll::Pending
173
+ }
174
+ }
175
+
176
+ impl Drop for Stalled {
177
+ fn drop(&mut self) {
178
+ self.0.fetch_add(1, Ordering::SeqCst);
179
+ }
180
+ }
181
+ }