Skip to content

Secure, Fast, and Extensible Sandbox runtime for AI agents.

perf(execd): avoid redundant JDK MITM CA imports

lihaopenge509d9e70ee7
diff --git a/.github/workflows/execd-test.yml b/.github/workflows/execd-test.yml
index 35dadd104..51949bd13 100644
--- a/.github/workflows/execd-test.yml
+++ b/.github/workflows/execd-test.yml
@@ -181,6 +181,11 @@ jobs:
working-directory: components/execd
run: bash tests/mitm_ca_nss.sh
+ - name: MITM CA JDK bootstrap test
+ if: matrix.os == 'ubuntu-latest'
+ working-directory: components/execd
+ run: python3 tests/test_mitm_ca_jdk.py
+
- name: Smoke test bwrap (Docker image build + extraction)
if: matrix.os == 'ubuntu-latest'
shell: bash
diff --git a/components/execd/bootstrap.sh b/components/execd/bootstrap.sh
index 0e566ccd2..781edae76 100755
--- a/components/execd/bootstrap.sh
+++ b/components/execd/bootstrap.sh
@@ -342,8 +342,34 @@ _jdk_import_ca() {
return 0
fi
- # Remove stale alias first so a regenerated CA cert is always picked up.
- if "$kt" -list -alias "$alias_name" -keystore "$ks" -storepass changeit >/dev/null 2>&1; then
+ # Different JDK installations can link to the same system trust store.
+ while :; do
+ ks_dir="$(cd "$(dirname "$ks")" 2>/dev/null && pwd -P)" || return 0
+ ks="$ks_dir/$(basename "$ks")"
+ [ -L "$ks" ] || break
+ link_target="$(readlink "$ks" 2>/dev/null)" || break
+ case "$link_target" in
+ /*) ks="$link_target" ;;
+ *) ks="$ks_dir/$link_target" ;;
+ esac
+ done
+ case "
+${_SEEN_JDK_STORES:-}" in
+ *"
+$ks
+"*) return 0 ;;
+ esac
+
+ # Compare certificate content, not just the alias: a rotated CA must replace
+ # the old certificate. PEM normalization avoids an openssl dependency.
+ if current_cert="$("$kt" -exportcert -rfc -alias "$alias_name" -keystore "$ks" -storepass changeit 2>/dev/null)"; then
+ current_cert="$(printf '%s\n' "$current_cert" | sed -n '/-----BEGIN CERTIFICATE-----/,/-----END CERTIFICATE-----/p' | tr -d '[:space:]')"
+ incoming_cert="$(sed -n '/-----BEGIN CERTIFICATE-----/,/-----END CERTIFICATE-----/p' "$cert" | tr -d '[:space:]')"
+ if [ -n "$incoming_cert" ] && [ "$current_cert" = "$incoming_cert" ]; then
+ _SEEN_JDK_STORES="${_SEEN_JDK_STORES:-}$ks
+"
+ return 0
+ fi
_sudo "$kt" -delete -alias "$alias_name" -keystore "$ks" -storepass changeit >/dev/null 2>&1
fi
@@ -353,6 +379,8 @@ _jdk_import_ca() {
-keystore "$ks" \
-storepass changeit >/dev/null 2>&1; then
echo "imported mitm CA into JDK trust store at $ks"
+ _SEEN_JDK_STORES="${_SEEN_JDK_STORES:-}$ks
+"
else
echo "warning: failed to import mitm CA into $ks" >&2
fi
@@ -376,6 +404,7 @@ trust_mitm_ca_jdk() {
cert="$1"
[ -f "$cert" ] || return 0
_SEEN_JDKS=""
+ _SEEN_JDK_STORES=""
# 1) $JAVA_HOME if set.
if [ -n "${JAVA_HOME:-}" ]; then
@@ -412,6 +441,7 @@ trust_mitm_ca_jdk() {
fi
_SEEN_JDKS=""
+ _SEEN_JDK_STORES=""
return 0
}
diff --git a/components/execd/tests/test_mitm_ca_jdk.py b/components/execd/tests/test_mitm_ca_jdk.py
new file mode 100644
index 000000000..5326c67a0
--- /dev/null
+++ b/components/execd/tests/test_mitm_ca_jdk.py
@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+# Copyright 2026 The OpenSandbox Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Exercise the production shell helpers with isolated JDK/store fixtures."""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+BOOTSTRAP = Path(__file__).resolve().parents[1] / "bootstrap.sh"
+SOURCE = BOOTSTRAP.read_text()
+HELPERS = SOURCE[SOURCE.index("_jdk_import_ca() {") : SOURCE.index("\nMITM_CA=")]
+CERT_A = "-----BEGIN CERTIFICATE-----\nY2VydC1h\n-----END CERTIFICATE-----\n"
+CERT_B = "-----BEGIN CERTIFICATE-----\nY2VydC1i\n-----END CERTIFICATE-----\n"
+KEYTOOL = r"""
+import json, os, pathlib, sys
+args = sys.argv[1:]
+operation = args[0]
+store = pathlib.Path(args[args.index("-keystore") + 1])
+with open(os.environ["KEYTOOL_LOG"], "a") as log:
+ log.write(json.dumps({"op": operation, "store": str(store)}) + "\n")
+if operation in ("-list", "-exportcert"):
+ if not store.read_text():
+ sys.exit(1)
+ if operation == "-exportcert":
+ print(store.read_text(), end="")
+elif operation == "-delete":
+ store.write_text("")
+elif operation == "-importcert":
+ if "reject-import" in sys.argv[0]:
+ sys.exit(1)
+ cert = pathlib.Path(args[args.index("-file") + 1])
+ store.write_text(cert.read_text())
+else:
+ raise SystemExit("unexpected keytool operation")
+"""
+
+
+class JDKTrustTests(unittest.TestCase):
+ def setUp(self):
+ self.directory = tempfile.TemporaryDirectory(prefix="jdk-ca-")
+ self.addCleanup(self.directory.cleanup)
+ self.root = Path(self.directory.name)
+ self.cert = self.root / "ca.pem"
+ self.cert.write_text(CERT_A)
+ self.log = self.root / "keytool.jsonl"
+
+ def store(self, name, certificate=""):
+ path = self.root / name
+ path.parent.mkdir(parents=True, exist_ok=True)
+ path.write_text(certificate)
+ return path
+
+ def jdk(self, name, store, java8=False, relative=False):
+ home = self.root / name
+ binary = home / "bin/keytool"
+ binary.parent.mkdir(parents=True)
+ binary.write_text("#!" + sys.executable + "\n" + KEYTOOL)
+ binary.chmod(0o755)
+ link = home / ("jre/lib/security/cacerts" if java8 else "lib/security/cacerts")
+ link.parent.mkdir(parents=True)
+ link.symlink_to(os.path.relpath(store, link.parent) if relative else store)
+ return home
+
+ def run_helpers(self, *homes, commands=None, extra_env=None):
+ script = 'set -eu\n_sudo() { "$@"; }\n' + HELPERS
+ script += (
+ commands
+ or '\ncert="$1"; shift\nfor home do _try_jdk "$home" "$cert"; done\n'
+ )
+ env = dict(os.environ, KEYTOOL_LOG=str(self.log))
+ env.update(extra_env or {})
+ result = subprocess.run(
+ ["sh", "-c", script, "jdk-ca-test", str(self.cert), *map(str, homes)],
+ env=env,
+ capture_output=True,
+ text=True,
+ timeout=10,
+ )
+ self.assertEqual(result.returncode, 0, result.stderr)
+ return (
+ [json.loads(line) for line in self.log.read_text().splitlines()]
+ if self.log.exists()
+ else []
+ )
+
+ def test_unchanged_certificate_does_not_rewrite_store(self):
+ store = self.store("store", CERT_A)
+ calls = self.run_helpers(self.jdk("jdk", store))
+ self.assertEqual([c["op"] for c in calls], ["-exportcert"])
+ self.assertEqual(store.read_text(), CERT_A)
+
+ def test_rotated_certificate_replaces_old_alias(self):
+ store = self.store("store", CERT_A)
+ self.cert.write_text(CERT_B)
+ calls = self.run_helpers(self.jdk("jdk", store))
+ self.assertEqual(
+ [c["op"] for c in calls], ["-exportcert", "-delete", "-importcert"]
+ )
+ self.assertEqual(store.read_text(), CERT_B)
+
+ def test_four_jdks_sharing_store_import_once(self):
+ store = self.store("shared/cacerts")
+ homes = [
+ self.jdk("jdk-" + str(v), store, java8=v == 8) for v in (8, 11, 17, 21)
+ ]
+ calls = self.run_helpers(*homes)
+ self.assertEqual([c["op"] for c in calls], ["-exportcert", "-importcert"])
+ self.assertEqual(store.read_text(), CERT_A)
+
+ def test_independent_stores_are_both_updated(self):
+ stores = [self.store("one/cacerts"), self.store("two/cacerts")]
+ calls = self.run_helpers(
+ *(self.jdk("jdk-" + str(i), p) for i, p in enumerate(stores))
+ )
+ self.assertEqual(sum(c["op"] == "-importcert" for c in calls), 2)
+ self.assertTrue(all(p.read_text() == CERT_A for p in stores))
+
+ def test_relative_symlinks_spaces_and_java8_layout(self):
+ store = self.store("shared store/cacerts")
+ alias = self.root / "store alias"
+ alias.symlink_to(os.path.relpath(store, alias.parent))
+ homes = [
+ self.jdk("jdk eight", alias, java8=True, relative=True),
+ self.jdk("jdk latest", store),
+ ]
+ calls = self.run_helpers(*homes)
+ self.assertEqual([c["op"] for c in calls], ["-exportcert", "-importcert"])
+
+ def test_pem_line_wrapping_and_crlf_do_not_trigger_reimport(self):
+ store = self.store("store", CERT_A)
+ self.cert.write_bytes(
+ b"-----BEGIN CERTIFICATE-----\r\nY2Vy\r\ndC1h\r\n"
+ b"-----END CERTIFICATE-----\r\n"
+ )
+ calls = self.run_helpers(self.jdk("jdk", store))
+ self.assertEqual([c["op"] for c in calls], ["-exportcert"])
+
+ def test_failed_import_can_retry_with_another_jdk(self):
+ store = self.store("shared/cacerts")
+ calls = self.run_helpers(
+ self.jdk("reject-import", store), self.jdk("working-jdk", store)
+ )
+ self.assertEqual(sum(c["op"] == "-importcert" for c in calls), 2)
+ self.assertEqual(store.read_text(), CERT_A)
+
+ def test_missing_keytool_and_missing_store_are_skipped(self):
+ no_keytool = self.root / "no-keytool"
+ no_keytool.mkdir()
+ missing = self.root / "absent-store"
+ no_store = self.jdk("no-store", missing)
+ self.assertEqual(self.run_helpers(no_keytool, no_store), [])
+
+ def test_unavailable_readlink_does_not_skip_import(self):
+ tools = self.root / "tools"
+ tools.mkdir()
+ readlink = tools / "readlink"
+ readlink.write_text("#!/bin/sh\nexit 1\n")
+ readlink.chmod(0o755)
+ store = self.store("shared/cacerts")
+ calls = self.run_helpers(
+ self.jdk("jdk", store),
+ extra_env={"PATH": str(tools) + os.pathsep + os.environ["PATH"]},
+ )
+ self.assertEqual(sum(c["op"] == "-importcert" for c in calls), 1)
+ self.assertEqual(store.read_text(), CERT_A)
+
+ def test_new_pass_rechecks_store_after_ca_rotation(self):
+ store = self.store("shared/cacerts", CERT_A)
+ home = self.jdk("jdk", store)
+ rotated = self.root / "rotated.pem"
+ rotated.write_text(CERT_B)
+ # Limit discovery to this fixture; never invoke host JDKs.
+ commands = """
+cert="$1"
+fixture="$2"
+_try_jdk() { [ "$1" != "$fixture" ] || _jdk_import_ca "$1" "$2"; }
+JAVA_HOME="$fixture"
+trust_mitm_ca_jdk "$cert"
+cp "$3" "$cert"
+trust_mitm_ca_jdk "$cert"
+"""
+ calls = self.run_helpers(home, rotated, commands=commands)
+ self.assertEqual(
+ [c["op"] for c in calls],
+ ["-exportcert", "-exportcert", "-delete", "-importcert"],
+ )
+ self.assertEqual(store.read_text(), CERT_B)
+
+
+if __name__ == "__main__":
+ unittest.main()