use crate::args::{CodecArg, parse_codec};
use crate::{build, crypt, glob};
use embark_format::{CodecId, CryptoId};
use quote::quote;
use std::collections::HashSet;
use std::path::{Path, PathBuf};
use syn::LitStr;
use syn::spanned::Spanned;
struct Config {
folder: LitStr,
codec: CodecArg,
cipher: CryptoId,
encrypt: bool,
dev: bool,
follow_links: bool,
include: Vec<String>,
exclude: Vec<String>,
}
pub(crate) fn expand(input: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
check_shape(input)?;
let name = &input.ident;
let cfg = parse_config(input)?;
let folder_span = cfg.folder.span();
let folder_abs = build::resolve(&cfg.folder);
let folder_abs_str = build::path_str(&folder_abs, folder_span)?.to_string();
let mut files = Vec::new();
walk(
&folder_abs,
&folder_abs,
&cfg,
&mut HashSet::new(),
&mut files,
)?;
files.sort();
let key_material = if cfg.encrypt {
Some(embark_crypt::gen_key_nonce().0)
} else {
None
};
let jobs: Vec<(String, PathBuf)> = files
.iter()
.map(|(rel, abs)| (shown_child(&cfg, rel), abs.clone()))
.collect();
let (codec, cipher) = (cfg.codec, cfg.cipher);
let built = embark_codec::parallel::map(&jobs, |(shown, abs)| {
let data = build::read(abs, shown)?;
match key_material {
Some(key) => crypt::seal_with_key(&data, codec, cipher, key, shown),
None => build::build_entry(codec, &data, shown),
}
});
let mut manifest_items = Vec::new();
let mut tracked = Vec::new();
for ((rel, abs), entry) in files.iter().zip(built) {
let entry = entry.map_err(build::at(folder_span))?;
let lit = build::bytes_literal(&entry);
manifest_items.push(quote! {
::embark::Manifest::new(#rel, #lit)
});
tracked.push(build::track_file(abs, folder_span)?);
}
let dev = cfg.dev;
let (recon_fn, get_body) = if let Some(key) = key_material {
let (recon_fn, recon_name) = crate::obfuscate::emit_key_recon(key);
(
recon_fn,
quote!(::embark::lookup_encrypted(MANIFEST, path, #recon_name)),
)
} else {
(quote!(), quote!(::embark::lookup(MANIFEST, path)))
};
let (dev_branch, unreachable_allow) = if dev {
(
quote! {
#[cfg(debug_assertions)]
{
return ::embark::__dev_file(MANIFEST, #folder_abs_str, path);
}
},
quote!(#[allow(unreachable_code)]),
)
} else {
(quote!(), quote!())
};
Ok(quote! {
const _: () = {
#(#tracked)*
static MANIFEST: &[::embark::Manifest] = &[ #(#manifest_items),* ];
#recon_fn
impl ::embark::Embed for #name {
#unreachable_allow
fn get(path: &str) -> ::core::option::Option<::embark::EmbeddedFile> {
#dev_branch
#get_body
}
fn iter() -> ::embark::Entries {
::embark::entries(MANIFEST)
}
}
};
})
}
pub(crate) fn error_with_stub(
input: &syn::DeriveInput,
err: &syn::Error,
) -> proc_macro2::TokenStream {
let name = &input.ident;
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
let diagnostic = err.to_compile_error();
quote! {
#diagnostic
const _: () = {
impl #impl_generics ::embark::Embed for #name #ty_generics #where_clause {
fn get(_path: &str) -> ::core::option::Option<::embark::EmbeddedFile> {
::core::option::Option::None
}
fn iter() -> ::embark::Entries {
::embark::entries(&[])
}
}
};
}
}
fn check_shape(input: &syn::DeriveInput) -> syn::Result<()> {
const EXPECTED: &str = "#[derive(Embed)] expects a unit struct, e.g. `struct Assets;`";
if !input.generics.params.is_empty() {
let at = input
.generics
.lt_token
.map_or_else(|| input.ident.span(), |lt| lt.span());
return Err(syn::Error::new(
at,
format!("{EXPECTED}; generic parameters are not supported"),
));
}
match &input.data {
syn::Data::Struct(s) => match &s.fields {
syn::Fields::Unit => Ok(()),
fields => Err(syn::Error::new(
fields.span(),
format!("{EXPECTED}; this struct has fields"),
)),
},
syn::Data::Enum(e) => Err(syn::Error::new(
e.enum_token.span,
format!("{EXPECTED}; enums are not supported"),
)),
syn::Data::Union(u) => Err(syn::Error::new(
u.union_token.span,
format!("{EXPECTED}; unions are not supported"),
)),
}
}
fn walk(
root: &Path,
dir: &Path,
cfg: &Config,
seen: &mut HashSet<PathBuf>,
out: &mut Vec<(String, std::path::PathBuf)>,
) -> syn::Result<()> {
if cfg.follow_links {
let real = std::fs::canonicalize(dir).unwrap_or_else(|_| dir.to_path_buf());
if !seen.insert(real) {
return Ok(());
}
}
let rd = std::fs::read_dir(dir).map_err(|e| {
let shown = if dir == root {
cfg.folder.value()
} else {
shown_child(cfg, &relative_to(root, dir))
};
let msg = if e.kind() == std::io::ErrorKind::NotFound {
format!("embark: folder not found: `{shown}` (resolved relative to CARGO_MANIFEST_DIR)")
} else {
format!("embark: cannot read folder `{shown}`: {e}")
};
syn::Error::new(cfg.folder.span(), msg)
})?;
for entry in rd.flatten() {
let path = entry.path();
let is_link = entry.file_type().is_ok_and(|kind| kind.is_symlink());
if is_link && !cfg.follow_links {
let shown = shown_child(cfg, &relative_to(root, &path));
return Err(syn::Error::new(
cfg.folder.span(),
format!(
"embark: `{shown}` is a symbolic link, and links are not followed: one \
pointing outside the folder would embed its target -- a key, a \
credential file -- into the binary. Add `follow_links` to \
`#[embark(...)]` to follow links, or replace it with the file itself."
),
));
}
if path.is_dir() {
walk(root, &path, cfg, seen, out)?;
} else {
let rel = relative_to(root, &path);
if included(cfg, &rel) {
out.push((rel, path));
}
}
}
Ok(())
}
fn shown_child(cfg: &Config, rel: &str) -> String {
format!("{}/{rel}", cfg.folder.value().trim_end_matches('/'))
}
fn relative_to(root: &Path, path: &Path) -> String {
path.strip_prefix(root)
.unwrap_or(path)
.to_string_lossy()
.replace('\\', "/")
}
fn included(cfg: &Config, rel: &str) -> bool {
if cfg.exclude.iter().any(|p| glob::matches(p, rel)) {
return false;
}
if cfg.include.is_empty() {
return true;
}
cfg.include.iter().any(|p| glob::matches(p, rel))
}
fn parse_config(input: &syn::DeriveInput) -> syn::Result<Config> {
let mut folder: Option<LitStr> = None;
let mut codec = CodecArg::Fixed(CodecId::Deflate);
let mut cipher = CryptoId::ChaCha20Poly1305;
let mut encrypt = false;
let mut dev = false;
let mut follow_links = false;
let mut include = Vec::new();
let mut exclude = Vec::new();
for attr in &input.attrs {
if !attr.path().is_ident("embark") {
continue;
}
attr.parse_nested_meta(|meta| {
if meta.path.is_ident("folder") {
folder = Some(meta.value()?.parse()?);
} else if meta.path.is_ident("codec") {
let s: syn::LitStr = meta.value()?.parse()?;
let name = s.value();
codec = parse_codec(&name)
.ok_or_else(|| meta.error(format!("unknown codec `{name}`")))?;
} else if meta.path.is_ident("cipher") {
let s: syn::LitStr = meta.value()?.parse()?;
match s.value().as_str() {
"chacha" => cipher = CryptoId::ChaCha20Poly1305,
"aes" => {
if !cfg!(feature = "aes") {
return Err(meta.error(
"cipher = \"aes\" requires the `aes` feature enabled on `embark`",
));
}
cipher = CryptoId::Aes256Gcm;
}
other => return Err(meta.error(format!("unknown cipher `{other}`"))),
}
} else if meta.path.is_ident("encrypt") {
encrypt = true;
} else if meta.path.is_ident("dev") {
dev = true;
} else if meta.path.is_ident("follow_links") {
follow_links = true;
} else if meta.path.is_ident("include") {
let s: syn::LitStr = meta.value()?.parse()?;
include.push(s.value());
} else if meta.path.is_ident("exclude") {
let s: syn::LitStr = meta.value()?.parse()?;
exclude.push(s.value());
} else {
return Err(meta.error("unknown `#[embark(...)]` attribute"));
}
Ok(())
})?;
}
let folder = folder.ok_or_else(|| {
syn::Error::new(
input.ident.span(),
"#[derive(Embed)] requires #[embark(folder = \"...\")]",
)
})?;
Ok(Config {
folder,
codec,
cipher,
encrypt,
dev,
follow_links,
include,
exclude,
})
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
fn config(follow_links: bool) -> Config {
Config {
folder: LitStr::new("assets", proc_macro2::Span::call_site()),
codec: CodecArg::Fixed(CodecId::Store),
cipher: CryptoId::ChaCha20Poly1305,
encrypt: false,
dev: false,
follow_links,
include: Vec::new(),
exclude: Vec::new(),
}
}
fn scratch(name: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!("embark-walk-{name}-{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(dir.join("assets")).unwrap();
fs::write(dir.join("assets/ok.txt"), b"ok").unwrap();
fs::write(dir.join("outside.txt"), b"not an asset").unwrap();
dir
}
fn link(target: &Path, at: &Path, is_dir: bool) -> Option<()> {
#[cfg(unix)]
{
let _ = is_dir;
std::os::unix::fs::symlink(target, at).ok()
}
#[cfg(windows)]
{
if is_dir {
std::os::windows::fs::symlink_dir(target, at).ok()
} else {
std::os::windows::fs::symlink_file(target, at).ok()
}
}
}
fn names(dir: &Path, follow_links: bool) -> syn::Result<Vec<String>> {
let root = dir.join("assets");
let mut out = Vec::new();
walk(
&root,
&root,
&config(follow_links),
&mut HashSet::new(),
&mut out,
)?;
Ok(out.into_iter().map(|(rel, _)| rel).collect())
}
#[test]
fn a_link_out_of_the_folder_is_refused_unless_asked_for() {
let dir = scratch("out");
if link(
&dir.join("outside.txt"),
&dir.join("assets/leak.txt"),
false,
)
.is_none()
{
return;
}
let err = names(&dir, false).expect_err("a link must not be followed by default");
let msg = err.to_string();
assert!(msg.contains("leak.txt"), "{msg}");
assert!(msg.contains("follow_links"), "{msg}");
let followed = names(&dir, true).unwrap();
assert!(followed.contains(&"leak.txt".to_string()), "{followed:?}");
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn a_link_back_to_an_ancestor_ends_the_walk_instead_of_never_ending_it() {
let dir = scratch("loop");
if link(&dir.join("assets"), &dir.join("assets/again"), true).is_none() {
return;
}
let followed = names(&dir, true).unwrap();
assert_eq!(
followed.iter().filter(|n| n.ends_with("ok.txt")).count(),
1,
"{followed:?}"
);
let _ = fs::remove_dir_all(&dir);
}
}