1pub const AGENT_PATH: &str = "/usr/local/bin/alien-sandbox-agent";
19
20pub const AGENT_PORT: u16 = 8971;
26
27pub const PREVIEW_CAPABILITY_HEADER: &str = "x-alien-preview-capability";
30
31pub const PREVIEW_PORT_HEADER: &str = "x-alien-preview-port";
33
34pub const CALLER_AUTHORIZATION_HEADER: &str = "x-alien-caller-authorization";
38
39pub const ENV_CALLER_AUTHORIZATION_HEADER: &str = "ALIEN_SANDBOX_CALLER_AUTHORIZATION_HEADER";
42
43pub const PREVIEW_CAPABILITY_MAX_SECONDS: i64 = 15 * 60;
45
46pub const ENV_PROTECTED_MOUNTS: &str = "ALIEN_SANDBOX_PROTECTED_MOUNTS";
51
52pub const ENV_MUST_DROP_KUBE_API: &str = "ALIEN_SANDBOX_MUST_DROP_KUBE_API";
57pub const ENV_MUST_DROP_PUBLIC: &str = "ALIEN_SANDBOX_MUST_DROP_PUBLIC";
62pub const MUST_DROP_PUBLIC_PROBE: &str = "1.1.1.1:443";
64pub const STAGE_PROTECTED_FILES_ARGUMENT: &str = "--stage-protected-files";
66pub const AGENT_IDENTITY_ARGUMENT: &str = "identity";
68pub const STAGED_AGENT_NAME: &str = "agent";
72pub const STAGED_METADATA_NAME: &str = "opt";
74pub const STAGED_AGENT_FILE: &str = "alien-sandbox-agent";
79pub const STAGED_AGENT_PATH: &str = "/opt/alien/alien-sandbox-agent";
81
82pub const AGENT_MODE: u32 = 0o755;
84
85pub const EXEC_USER: &str = "sandbox";
87
88pub const SESSION_ROOT_MODE: u32 = 0o700;
90
91pub const GCP_AGENT_LOG_FILTER: &str = "info";
93
94pub const IMAGE_ROOT_CAPABILITY_SET: &[(&str, u8)] = &[
101 ("CHOWN", 0),
102 ("DAC_OVERRIDE", 1),
103 ("FOWNER", 3),
104 ("FSETID", 4),
105 ("KILL", 5),
106 ("SETGID", 6),
107 ("SETUID", 7),
108 ("SETPCAP", 8),
109 ("NET_BIND_SERVICE", 10),
110 ("SYS_CHROOT", 18),
111 ("MKNOD", 27),
112 ("AUDIT_WRITE", 29),
113 ("SETFCAP", 31),
114];
115
116pub const IMAGE_ROOT_CAPABILITY_MASK: u32 = {
118 let mut mask = 0u32;
119 let mut index = 0;
120 while index < IMAGE_ROOT_CAPABILITY_SET.len() {
121 mask |= 1 << IMAGE_ROOT_CAPABILITY_SET[index].1;
122 index += 1;
123 }
124 mask
125};
126
127#[derive(Debug, Clone, Copy, PartialEq, Eq)]
133pub enum Isolation {
134 UidSplit,
137 Platform,
140}
141
142impl Isolation {
143 pub fn env_value(self) -> &'static str {
145 match self {
146 Self::UidSplit => "uid-split",
147 Self::Platform => "platform",
148 }
149 }
150}
151
152#[derive(Debug, Clone, Copy, PartialEq, Eq)]
154pub enum Authorization {
155 Transport,
158 Capability,
160 NativeFile,
162}
163
164impl Authorization {
165 pub fn env_value(self) -> &'static str {
167 match self {
168 Self::Transport => "transport",
169 Self::Capability => "capability",
170 Self::NativeFile => "native-file",
171 }
172 }
173}
174
175#[derive(Debug, Clone, Copy, PartialEq, Eq)]
177pub struct SandboxImage {
178 pub exec_uid: u32,
180 pub exec_gid: u32,
182 pub session_root: &'static str,
184 pub port: u16,
186 pub authorization: Authorization,
187 pub isolation: Isolation,
188}
189
190impl SandboxImage {
191 pub fn exec_gid(&self) -> u32 {
193 self.exec_gid
194 }
195
196 pub fn contract_env_vars(&self) -> [(&'static str, String); 6] {
199 [
200 ("ALIEN_SANDBOX_ROOT", self.session_root.to_string()),
201 ("ALIEN_SANDBOX_PORT", self.port.to_string()),
202 (
203 "ALIEN_SANDBOX_AUTHORIZATION",
204 self.authorization.env_value().to_string(),
205 ),
206 ("ALIEN_SANDBOX_EXEC_UID", self.exec_uid.to_string()),
207 ("ALIEN_SANDBOX_EXEC_GID", self.exec_gid().to_string()),
208 (
209 "ALIEN_SANDBOX_ISOLATION",
210 self.isolation.env_value().to_string(),
211 ),
212 ]
213 }
214
215 pub fn user(&self) -> Option<String> {
218 match self.isolation {
219 Isolation::UidSplit => None,
220 Isolation::Platform => Some(format!("{}:{}", self.exec_uid, self.exec_gid())),
221 }
222 }
223
224 pub fn exposed_port(&self) -> String {
226 format!("{}/tcp", self.port)
227 }
228
229 pub fn passwd_entry(&self) -> String {
231 format!(
232 "{EXEC_USER}:x:{uid}:{gid}::{root}:/sbin/nologin",
233 uid = self.exec_uid,
234 gid = self.exec_gid(),
235 root = self.session_root,
236 )
237 }
238
239 pub fn group_entry(&self) -> String {
241 format!("{EXEC_USER}:x:{gid}:", gid = self.exec_gid())
242 }
243}
244
245pub const AWS_MICROVM: SandboxImage = SandboxImage {
251 exec_uid: 60000,
252 exec_gid: 60000,
253 session_root: "/sandbox",
254 port: AGENT_PORT,
255 authorization: Authorization::Transport,
256 isolation: Isolation::UidSplit,
257};
258
259pub const GCP_AGENT_PLATFORM: SandboxImage = SandboxImage {
266 exec_uid: 1000,
267 exec_gid: 1000,
268 session_root: "/sandbox",
269 port: AGENT_PORT,
270 authorization: Authorization::Transport,
271 isolation: Isolation::UidSplit,
272};
273
274pub fn gcp_agent_platform_env() -> Vec<(&'static str, String)> {
276 let mut env = GCP_AGENT_PLATFORM.contract_env_vars().to_vec();
277 env.push(("RUST_LOG", GCP_AGENT_LOG_FILTER.to_string()));
278 env.push(("ALIEN_SANDBOX_IMAGE_COMMAND", "true".into()));
279 env.push((
282 ENV_CALLER_AUTHORIZATION_HEADER,
283 CALLER_AUTHORIZATION_HEADER.into(),
284 ));
285 env
286}
287
288pub const AZURE_SANDBOX: SandboxImage = SandboxImage {
291 exec_uid: 1000,
292 exec_gid: 1000,
293 session_root: "/sandbox",
294 port: AGENT_PORT,
295 authorization: Authorization::NativeFile,
296 isolation: Isolation::UidSplit,
297};
298
299pub const KUBERNETES_SANDBOX: SandboxImage = SandboxImage {
304 exec_uid: 1000,
305 exec_gid: 1000,
306 session_root: "/sandbox",
307 port: AGENT_PORT,
308 authorization: Authorization::Capability,
309 isolation: Isolation::Platform,
310};
311
312pub const DEFAULT_SANDBOX_BASE_IMAGE: &str = "public.ecr.aws/docker/library/buildpack-deps:26.04@sha256:159ea382e6fb39e62480ee932113f885f7bd787cd4895fc4dc71aebb175077fd";
317
318pub const DEFAULT_SANDBOX_UV_IMAGE: &str = "ghcr.io/astral-sh/uv:0.12.21@sha256:a7aed3216253ee804de3e2d8afa5073baa1a177335345d43845cd4165e43b711";
320
321#[derive(Debug, Clone, Copy, PartialEq, Eq)]
323pub struct SandboxTool {
324 pub package: Option<&'static str>,
327 pub version_command: &'static str,
329}
330
331pub const DEFAULT_SANDBOX_TOOLS: &[SandboxTool] = &[
336 SandboxTool {
337 package: Some("nftables"),
338 version_command: "/usr/sbin/nft --version",
339 },
340 SandboxTool {
341 package: Some("iptables"),
342 version_command: "iptables-nft --version",
343 },
344 SandboxTool {
345 package: Some("nodejs"),
346 version_command: "node --version",
347 },
348 SandboxTool {
349 package: Some("npm"),
350 version_command: "npm --version",
351 },
352 SandboxTool {
353 package: Some("ripgrep"),
354 version_command: "rg --version",
355 },
356 SandboxTool {
357 package: Some("jq"),
358 version_command: "jq --version",
359 },
360 SandboxTool {
361 package: Some("zip"),
362 version_command: "zip -v",
363 },
364 SandboxTool {
365 package: Some("less"),
366 version_command: "less --version",
367 },
368 SandboxTool {
369 package: Some("nano"),
370 version_command: "nano --version",
371 },
372 SandboxTool {
373 package: Some("vim-tiny"),
374 version_command: "vim.tiny --version",
375 },
376 SandboxTool {
377 package: Some("htop"),
378 version_command: "htop --version",
379 },
380 SandboxTool {
381 package: None,
382 version_command: "uv --version",
383 },
384 SandboxTool {
385 package: None,
386 version_command: "uvx --version",
387 },
388];
389
390pub fn identity_setup(image: &SandboxImage) -> String {
392 format!(
393 r#"RUN test ! -L /etc/passwd && test ! -L /etc/group && test ! -L {root} \
394 && touch /etc/passwd /etc/group \
395 && chown 0:0 /etc/passwd /etc/group && chmod 0644 /etc/passwd /etc/group \
396 && (awk -F: '$3 == {uid} {{ found=1 }} END {{ exit !found }}' /etc/passwd || printf '{passwd}\n' >> /etc/passwd) \
397 && (awk -F: '$3 == {gid} {{ found=1 }} END {{ exit !found }}' /etc/group || printf '{group}\n' >> /etc/group) \
398 && mkdir -p {root} \
399 && chown {uid}:{gid} {root} \
400 && chmod {SESSION_ROOT_MODE:04o} {root}"#,
401 passwd = image.passwd_entry(),
402 group = image.group_entry(),
403 root = image.session_root,
404 uid = image.exec_uid,
405 gid = image.exec_gid(),
406 )
407}
408
409pub fn contract_env(image: &SandboxImage) -> String {
411 let vars: Vec<String> = image
412 .contract_env_vars()
413 .iter()
414 .map(|(name, value)| format!("{name}={value}"))
415 .collect();
416 format!("ENV {}", vars.join(" \\\n "))
417}
418
419pub fn entrypoint(image: &SandboxImage) -> String {
421 let ending = match image.user() {
422 None => String::new(),
423 Some(user) => format!(
424 "# Explicit gid so a runtime that does not read /etc/passwd cannot start the agent in \
425 group 0, which\n# makes the exec drop a privilege crossing whose setgroups needs a \
426 CAP_SETGID this image lacks, so\n# every exec fails.\nUSER {user}\n"
427 ),
428 };
429 format!(
430 "EXPOSE {port}\n{ending}ENTRYPOINT [\"{AGENT_PATH}\"]",
431 port = image.exposed_port()
432 )
433}
434
435#[cfg(test)]
437const GCP_DOCKERFILE: &str = "docker/Dockerfile.alien-sandbox-agent";
438
439#[cfg(test)]
441const GCP_DEFAULT_DOCKERFILE: &str = "docker/Dockerfile.alien-sandbox-gcp";
442
443#[cfg(test)]
445const DEFAULT_SANDBOX_DOCKERFILE: &str = "docker/Dockerfile.alien-sandbox-default";
446
447#[cfg(test)]
449const DEFAULT_SANDBOX_TOOLS_FILE: &str = "docker/sandbox-default-tools.txt";
450
451#[cfg(test)]
454const SANDBOX_FILES_UPDATE: &str = "UPDATE_SANDBOX_AGENT_DOCKERFILE";
455
456#[cfg(test)]
458fn default_sandbox_dockerfile() -> String {
459 let packages: Vec<&str> = DEFAULT_SANDBOX_TOOLS
460 .iter()
461 .filter_map(|tool| tool.package)
462 .collect();
463 format!(
464 r#"# Generated by `cargo test -p alien-core --lib sandbox_image`. Do not edit by hand.
465# Regenerate with {SANDBOX_FILES_UPDATE}=1 in front of that command.
466#
467# Multi-arch tools-only base for the default sandbox images, with no agent. An image that runs the
468# agent adds it and its own ending on top, and a runtime with no in-guest agent runs this as is,
469# so it declares no USER, ENTRYPOINT or ENV.
470
471FROM {DEFAULT_SANDBOX_BASE_IMAGE}
472
473# No version pins: the -updates and -security pockets supersede a pinned version and the arm64
474# ports lag behind, so a pin breaks the build. The published digest is what fixes the versions.
475# ca-certificates is already in the base; naming it upgrades the trust store to the archive's
476# current one instead of the one frozen in the base digest.
477RUN apt-get update \
478 && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
479 ca-certificates {packages} \
480 && rm -rf /var/lib/apt/lists/*
481
482COPY --from={DEFAULT_SANDBOX_UV_IMAGE} /uv /uvx /usr/local/bin/
483"#,
484 packages = packages.join(" "),
485 )
486}
487
488#[cfg(test)]
490fn default_sandbox_tools_list() -> String {
491 let mut list = format!(
492 "# Generated by `cargo test -p alien-core --lib sandbox_image`. Do not edit by hand.
493# Regenerate with {SANDBOX_FILES_UPDATE}=1 in front of that command.
494#
495# One command per tool the default sandbox base ships; each prints a version and exits zero.
496"
497 );
498 for tool in DEFAULT_SANDBOX_TOOLS {
499 list.push_str(tool.version_command);
500 list.push('\n');
501 }
502 list
503}
504
505#[cfg(test)]
507enum GcpBase {
508 Image(&'static str),
509 BuildArg(&'static str),
511}
512
513#[cfg(test)]
515fn gcp_agent_platform_dockerfile() -> String {
516 gcp_dockerfile(
517 "Multi-arch build for the alien-sandbox-agent Docker image",
518 GcpBase::Image("docker.io/chainguard/wolfi-base:latest"),
519 "# git is for the sandboxed command, not the agent, and pulls 24 transitive packages. That cost
520# lands here because this image is the sandbox, with no customer base image underneath to carry it.
521RUN apk add --no-cache git",
522 )
523}
524
525#[cfg(test)]
528fn gcp_default_sandbox_dockerfile() -> String {
529 assert_eq!(
530 GCP_AGENT_PLATFORM.exec_uid, 1000,
531 "the userdel below exists only because Ubuntu's own user holds the exec uid"
532 );
533 gcp_dockerfile(
534 "Multi-arch build for the default GCP sandbox image: the default sandbox base plus the agent",
535 GcpBase::BuildArg("SANDBOX_DEFAULT_BASE"),
536 "# Ubuntu ships `ubuntu` at uid 1000. Appending a second entry for that uid leaves `id` and every
537# tool resolving it to `ubuntu`, so the exec user would not be `sandbox`.
538RUN userdel --remove ubuntu",
539 )
540}
541
542#[cfg(test)]
549fn gcp_dockerfile(title: &str, base: GcpBase, base_setup: &str) -> String {
550 let image = &GCP_AGENT_PLATFORM;
551 let (directive, base_arg, base) = match base {
554 GcpBase::Image(reference) => (String::new(), String::new(), reference.to_string()),
555 GcpBase::BuildArg(name) => (
556 "# check=skip=InvalidDefaultArgInFrom\n".to_string(),
557 format!(
558 "# No default: the base's digest exists only once it is built, so whoever builds \
559 this image\n# passes it. The check directive on line 1 is for this.\nARG {name}\n\n"
560 ),
561 format!("${{{name}}}"),
562 ),
563 };
564 format!(
565 r#"{directive}# Generated by `cargo test -p alien-core --lib sandbox_image`. Do not edit by hand.
566# Regenerate with {SANDBOX_FILES_UPDATE}=1 in front of that command.
567#
568# {title}
569# Run directly as the GCP Agent Platform sandbox; nothing layers on top of it
570
571{base_arg}FROM docker.io/chainguard/wolfi-base:latest AS binary-selector
572
573COPY target/aarch64-unknown-linux-musl/release/alien-sandbox-agent /tmp/alien-sandbox-agent-aarch64
574COPY target/x86_64-unknown-linux-musl/release/alien-sandbox-agent /tmp/alien-sandbox-agent-x86_64
575
576ARG TARGETARCH
577RUN case "$TARGETARCH" in \
578 amd64) cp /tmp/alien-sandbox-agent-x86_64 /tmp/alien-sandbox-agent ;; \
579 arm64) cp /tmp/alien-sandbox-agent-aarch64 /tmp/alien-sandbox-agent ;; \
580 *) echo "unsupported TARGETARCH '$TARGETARCH'" >&2; exit 1 ;; \
581 esac
582
583FROM {base}
584
585{base_setup}
586
587# Root-owned and unwritable by uid {exec_uid}: the supervised command runs under that uid and must not
588# be able to rewrite its own supervisor.
589COPY --from=binary-selector --chown=0:0 --chmod={AGENT_MODE:04o} \
590 /tmp/alien-sandbox-agent {AGENT_PATH}
591
592# Numeric ids and a plain append rather than adduser, which differs across base distributions.
593# Linux runs a process under a uid with no passwd entry, but tooling inside the sandbox reads one.
594{identity}
595
596# The template carries no env, so the contract lives here, and none of it is optional. transport
597# serves an uncapabilitied request only from a socket `peer::transport_may_serve` cannot trace
598# back to the exec uid, and the agent refuses the mode where /proc/net/tcp is unreadable.
599{env}
600
601# The release build resolves tracing-subscriber once across every package it names, and five of
602# them ask for env-filter, so the agent's fmt::init() has an EnvFilter under it. Unset, that
603# filter discards the startup warning saying this image serves requests without a capability.
604ENV RUST_LOG={GCP_AGENT_LOG_FILTER} \
605 ALIEN_SANDBOX_IMAGE_COMMAND=true
606
607# The edge consumes `Authorization` for its own credential, so a preview caller's bearer arrives in
608# this header and the agent hands it to the code inside as `Authorization`.
609ENV {ENV_CALLER_AUTHORIZATION_HEADER}={CALLER_AUTHORIZATION_HEADER}
610
611# These published agent images have no application startup command. Declare that explicitly so
612# inherited base CMD values cannot become agent arguments or a second shell process.
613RUN mkdir -p /opt/alien \
614 && printf '%s\n' '{empty_image_command}' > {IMAGE_COMMAND_PATH} \
615 && chmod 0444 {IMAGE_COMMAND_PATH}
616
617{entrypoint}
618CMD []
619"#,
620 empty_image_command = serde_json::to_string(&SandboxImageCommand {
621 user: Some(String::new()),
622 working_directory: "/".into(),
623 ..Default::default()
624 })
625 .expect("static default image command must serialize"),
626 exec_uid = image.exec_uid,
627 identity = identity_setup(image),
628 env = contract_env(image),
629 entrypoint = entrypoint(image),
630 )
631}
632
633#[cfg(test)]
634mod tests {
635 use super::*;
636
637 #[test]
639 fn the_gcp_agent_leaves_port_8080_to_the_workload() {
640 assert_ne!(GCP_AGENT_PLATFORM.port, 8080);
641 assert_eq!(GCP_AGENT_PLATFORM.port, AGENT_PORT);
642 }
643
644 #[test]
647 fn root_capability_set_is_dockers_default_without_net_raw() {
648 assert_eq!(IMAGE_ROOT_CAPABILITY_MASK, 0xa80405fb);
649 for forbidden in ["NET_ADMIN", "SYS_ADMIN", "NET_RAW"] {
650 assert!(IMAGE_ROOT_CAPABILITY_SET
651 .iter()
652 .all(|(name, _)| *name != forbidden));
653 }
654 }
655
656 fn committed_path(relative: &str) -> std::path::PathBuf {
657 std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
658 .join("../..")
659 .join(relative)
660 }
661
662 fn first_difference(committed: &str, rendered: &str) -> String {
665 for (index, (left, right)) in committed.lines().zip(rendered.lines()).enumerate() {
666 if left != right {
667 let line = index + 1;
668 return format!("line {line}: committed {left:?}, contract renders {right:?}");
669 }
670 }
671 format!(
672 "committed has {} lines, the contract renders {}",
673 committed.lines().count(),
674 rendered.lines().count()
675 )
676 }
677
678 #[test]
681 fn the_committed_gcp_dockerfiles_are_what_the_contract_renders() {
682 for (file, rendered) in [
683 (GCP_DOCKERFILE, gcp_agent_platform_dockerfile()),
684 (GCP_DEFAULT_DOCKERFILE, gcp_default_sandbox_dockerfile()),
685 (DEFAULT_SANDBOX_DOCKERFILE, default_sandbox_dockerfile()),
686 (DEFAULT_SANDBOX_TOOLS_FILE, default_sandbox_tools_list()),
687 ] {
688 let path = committed_path(file);
689
690 if std::env::var_os(SANDBOX_FILES_UPDATE).is_some() {
691 std::fs::write(&path, &rendered)
692 .unwrap_or_else(|error| panic!("{} must be writable: {error}", path.display()));
693 continue;
694 }
695
696 let committed = std::fs::read_to_string(&path)
697 .unwrap_or_else(|error| panic!("{} must be readable: {error}", path.display()));
698 assert!(
699 committed == rendered,
700 "{file} has drifted from the contract it is rendered from.\n\
701 {}\n\
702 Regenerate it: {SANDBOX_FILES_UPDATE}=1 cargo test -p alien-core --lib sandbox_image",
703 first_difference(&committed, &rendered)
704 );
705 }
706 }
707
708 #[test]
711 fn the_gcp_env_accessor_is_every_env_the_committed_dockerfile_sets() {
712 let committed = std::fs::read_to_string(committed_path(GCP_DEFAULT_DOCKERFILE)).unwrap();
713 let mut set = Vec::new();
714 let mut in_env = false;
715 for line in committed.lines() {
716 let line = line.trim();
717 let rest = match line.strip_prefix("ENV ") {
718 Some(rest) => rest,
719 None if in_env => line,
720 None => continue,
721 };
722 in_env = rest.ends_with('\\');
723 for pair in rest.trim_end_matches('\\').split_whitespace() {
724 let (name, value) = pair.split_once('=').expect("ENV name=value");
725 set.push((name.to_string(), value.to_string()));
726 }
727 }
728 let accessor: Vec<(String, String)> = gcp_agent_platform_env()
729 .into_iter()
730 .map(|(name, value)| (name.to_string(), value))
731 .collect();
732 assert_eq!(accessor, set);
733 }
734
735 #[test]
739 fn the_two_images_carry_the_identities_their_stacks_were_built_against() {
740 assert_eq!(AWS_MICROVM.port, 8971);
741 assert_eq!(AWS_MICROVM.exec_uid, 60000);
742 assert_eq!(AWS_MICROVM.session_root, "/sandbox");
743 assert_eq!(GCP_AGENT_PLATFORM.port, 8971);
744 assert_eq!(GCP_AGENT_PLATFORM.exec_uid, 1000);
745 assert_eq!(GCP_AGENT_PLATFORM.session_root, "/sandbox");
746 for image in [&AWS_MICROVM, &GCP_AGENT_PLATFORM] {
747 assert_ne!(image.exec_uid, 0, "the exec uid must never be root");
748 }
749 }
750
751 #[test]
755 fn the_ending_an_image_declares_follows_its_isolation() {
756 assert!(!entrypoint(&AWS_MICROVM).contains("USER "));
757 assert!(contract_env(&AWS_MICROVM).contains("ALIEN_SANDBOX_ISOLATION=uid-split"));
758 assert_eq!(GCP_AGENT_PLATFORM.isolation, Isolation::UidSplit);
759 assert!(contract_env(&GCP_AGENT_PLATFORM).contains("ALIEN_SANDBOX_ISOLATION=uid-split"));
760 }
761}
762
763#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
765#[serde(rename_all = "camelCase", deny_unknown_fields)]
766pub struct SandboxImageCommand {
767 #[serde(default, skip_serializing_if = "Option::is_none")]
770 pub user: Option<String>,
771 pub command: Vec<String>,
773 pub env: std::collections::BTreeMap<String, String>,
775 pub working_directory: String,
777}
778
779pub const IMAGE_COMMAND_PATH: &str = "/opt/alien/image-command.json";
781
782pub const NATIVE_TOKEN_PATH: &str = "/opt/alien/native-token";