use serde_json::{json, Map, Value};
pub fn normalize_bundle_id(raw: &str) -> Option<String> {
let id = raw.trim();
if id.is_empty() || id.len() > 155 {
return None;
}
let segments: Vec<&str> = id.split('.').collect();
let ok = segments.len() >= 2
&& segments.iter().all(|s| {
!s.is_empty()
&& !s.starts_with('-')
&& !s.ends_with('-')
&& s.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-')
});
ok.then(|| id.to_string())
}
pub fn normalize_team_id(raw: &str) -> Option<String> {
let id = raw.trim().to_ascii_uppercase();
(id.len() == 10
&& id
.bytes()
.all(|b| b.is_ascii_uppercase() || b.is_ascii_digit()))
.then_some(id)
}
pub fn normalize_package(raw: &str) -> Option<String> {
let name = raw.trim();
if name.is_empty() || name.len() > 155 {
return None;
}
let segments: Vec<&str> = name.split('.').collect();
let ok = segments.len() >= 2
&& segments.iter().all(|s| {
s.bytes().next().is_some_and(|b| b.is_ascii_alphabetic())
&& s.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')
});
ok.then(|| name.to_string())
}
pub fn normalize_sha256(raw: &str) -> Option<String> {
let hex: String = raw
.trim()
.chars()
.filter(|c| *c != ':' && !c.is_whitespace())
.collect();
if hex.len() != 64 || !hex.bytes().all(|b| b.is_ascii_hexdigit()) {
return None;
}
let hex = hex.to_ascii_uppercase();
Some(
hex.as_bytes()
.chunks(2)
.map(|p| std::str::from_utf8(p).unwrap_or_default())
.collect::<Vec<_>>()
.join(":"),
)
}
pub const BUNDLE_ID_HELP: &str =
"an iOS bundle ID looks like com.example.app (letters, digits, hyphens; the exact case of your signed build)";
pub const TEAM_ID_HELP: &str =
"the Apple Team ID (App ID prefix) is 10 letters or digits, e.g. ABCDE12345 \
(Apple Developer → Membership, or `ios.appleTeamId` in app.json)";
pub const PACKAGE_HELP: &str =
"an Android package name looks like com.example.app (letters, digits, underscores)";
pub const SHA256_HELP: &str =
"a signing certificate SHA-256 is 64 hex digits, e.g. AB:CD:…; get it from \
Play Console → App integrity → App signing, `./gradlew signingReport`, or \
`keytool -list -v -keystore <file>`";
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IosApp {
pub bundle_id: String,
pub team_id: String,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AndroidApp {
pub package: String,
pub sha256: Vec<String>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Native {
attestation: Map<String, Value>,
android_package_names: Vec<String>,
}
impl Native {
pub fn from_application(app: &Value) -> Self {
let mut attestation = app
.get("native_attestation")
.and_then(Value::as_object)
.cloned()
.unwrap_or_default();
for key in ["ios_apps", "android_apps"] {
if !attestation.get(key).is_some_and(Value::is_array) {
attestation.insert(key.into(), json!([]));
}
}
if !attestation
.get("allow_development")
.is_some_and(Value::is_boolean)
{
attestation.insert("allow_development".into(), json!(false));
}
let android_package_names = app
.get("android_package_names")
.and_then(Value::as_array)
.map(|a| {
a.iter()
.filter_map(Value::as_str)
.map(str::to_string)
.collect()
})
.unwrap_or_default();
Self {
attestation,
android_package_names,
}
}
pub fn ios_apps(&self) -> Vec<IosApp> {
self.attestation["ios_apps"]
.as_array()
.map(|a| {
a.iter()
.filter_map(|v| {
Some(IosApp {
bundle_id: v.get("bundle_id")?.as_str()?.to_string(),
team_id: v.get("app_id_prefix")?.as_str()?.to_string(),
})
})
.collect()
})
.unwrap_or_default()
}
pub fn android_apps(&self) -> Vec<AndroidApp> {
self.attestation["android_apps"]
.as_array()
.map(|a| {
a.iter()
.filter_map(|v| {
Some(AndroidApp {
package: v.get("package_name")?.as_str()?.to_string(),
sha256: v
.get("signing_cert_sha256")?
.as_array()?
.iter()
.filter_map(Value::as_str)
.map(str::to_string)
.collect(),
})
})
.collect()
})
.unwrap_or_default()
}
pub fn android_packages_without_certificate(&self) -> Vec<String> {
let paired: Vec<String> = self.android_apps().into_iter().map(|a| a.package).collect();
self.android_package_names
.iter()
.filter(|p| !paired.contains(p))
.cloned()
.collect()
}
pub fn allow_development(&self) -> bool {
self.attestation["allow_development"]
.as_bool()
.unwrap_or(false)
}
fn set_ios(&mut self, apps: Vec<IosApp>) {
self.attestation.insert(
"ios_apps".into(),
Value::Array(
apps.into_iter()
.map(|a| json!({ "bundle_id": a.bundle_id, "app_id_prefix": a.team_id }))
.collect(),
),
);
}
fn set_android(&mut self, apps: Vec<AndroidApp>) {
self.attestation.insert(
"android_apps".into(),
Value::Array(
apps.into_iter()
.map(|a| json!({ "package_name": a.package, "signing_cert_sha256": a.sha256 }))
.collect(),
),
);
}
pub fn add_ios(&mut self, bundle_id: &str, team_id: &str) -> bool {
let mut apps = self.ios_apps();
let exists = apps
.iter()
.any(|a| a.bundle_id == bundle_id && a.team_id.eq_ignore_ascii_case(team_id));
if exists {
return false;
}
apps.push(IosApp {
bundle_id: bundle_id.to_string(),
team_id: team_id.to_ascii_uppercase(),
});
self.set_ios(apps);
true
}
pub fn remove_ios(&mut self, bundle_id: &str, team_id: Option<&str>) -> bool {
let apps = self.ios_apps();
let kept: Vec<IosApp> = apps
.iter()
.filter(|a| {
let team_matches = match team_id {
Some(t) => a.team_id.eq_ignore_ascii_case(t),
None => true,
};
!(a.bundle_id.eq_ignore_ascii_case(bundle_id) && team_matches)
})
.cloned()
.collect();
let changed = kept.len() != apps.len();
if changed {
self.set_ios(kept);
}
changed
}
pub fn add_android(&mut self, package: &str, certs: &[String]) -> bool {
let mut apps = self.android_apps();
let mut changed = false;
match apps.iter_mut().find(|a| a.package == package) {
Some(app) => {
for cert in certs {
if !app.sha256.contains(cert) {
app.sha256.push(cert.clone());
changed = true;
}
}
}
None => {
apps.push(AndroidApp {
package: package.to_string(),
sha256: certs.to_vec(),
});
changed = true;
}
}
if !self.android_package_names.iter().any(|p| p == package) {
self.android_package_names.push(package.to_string());
changed = true;
}
if changed {
self.set_android(apps);
}
changed
}
pub fn remove_android(&mut self, package: &str, cert: Option<&str>) -> bool {
let mut apps = self.android_apps();
let before = apps.clone();
match cert {
Some(cert) => {
for app in apps.iter_mut().filter(|a| a.package == package) {
app.sha256.retain(|c| c != cert);
}
apps.retain(|a| !a.sha256.is_empty());
}
None => apps.retain(|a| a.package != package),
}
let package_gone = !apps.iter().any(|a| a.package == package);
let mut changed = apps != before;
if package_gone && self.android_package_names.iter().any(|p| p == package) {
self.android_package_names.retain(|p| p != package);
changed = true;
}
if changed {
self.set_android(apps);
}
changed
}
pub fn production(&self) -> bool {
self.attestation
.get("production")
.and_then(Value::as_bool)
.unwrap_or(false)
}
pub fn set_production(&mut self, on: bool) -> bool {
if self.production() == on {
return false;
}
self.attestation
.insert("production".into(), Value::Bool(on));
true
}
pub fn android_degraded(&self) -> &str {
match self
.attestation
.get("android_degraded")
.and_then(Value::as_str)
{
Some("refuse") => "refuse",
_ => "allow",
}
}
pub fn set_android_degraded(&mut self, allow: bool) -> bool {
let value = if allow { "allow" } else { "refuse" };
if self.android_degraded() == value {
return false;
}
self.attestation
.insert("android_degraded".into(), Value::String(value.into()));
true
}
pub fn development_until(&self) -> Option<String> {
if self.production() {
return None;
}
let until = self
.attestation
.get("development_mode")
.and_then(|d| d.get("until"))
.and_then(Value::as_str)?;
(super::is_future(until)).then(|| until.to_string())
}
pub fn set_allow_development(&mut self, on: bool) -> bool {
if self.allow_development() == on {
return false;
}
self.attestation
.insert("allow_development".into(), Value::Bool(on));
true
}
pub fn patch_body(&self) -> Value {
let mut attestation = self.attestation.clone();
attestation.remove("android_service_account_email");
attestation.remove("android_credentials_configured");
attestation.remove("development_mode");
json!({
"native_attestation": Value::Object(attestation),
"android_package_names": self.android_package_names,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
const SHA: &str = "ab:cd:ef:01:23:45:67:89:ab:cd:ef:01:23:45:67:89:ab:cd:ef:01:23:45:67:89:ab:cd:ef:01:23:45:67:89";
#[test]
fn identifiers_are_validated_like_the_server() {
assert_eq!(
normalize_bundle_id(" Com.Example.App ").as_deref(),
Some("Com.Example.App")
);
assert!(normalize_bundle_id("example").is_none());
assert!(normalize_bundle_id("com.example.app_1").is_none());
assert_eq!(
normalize_team_id("abcde12345").as_deref(),
Some("ABCDE12345")
);
assert!(normalize_team_id("ABC").is_none());
assert_eq!(
normalize_package("com.Example.my_app").as_deref(),
Some("com.Example.my_app")
);
assert!(normalize_package("com.example-app").is_none());
assert_eq!(
normalize_sha256(&SHA.replace(':', "")).unwrap(),
SHA.to_ascii_uppercase()
);
assert!(normalize_sha256("abcd").is_none());
}
#[test]
fn edits_are_idempotent_and_keep_settings_this_cli_does_not_touch() {
let app = json!({
"native_attestation": { "mode": "off", "ios_apps": [], "android_apps": [],
"allow_development": false, "android_cloud_project_number": "123",
"android_credentials_configured": true, "android_service_account_email": "x@y.iam.gserviceaccount.com" },
"android_package_names": ["com.legacy.app"]
});
let mut n = Native::from_application(&app);
let cert = normalize_sha256(SHA).unwrap();
assert!(n.add_ios("com.example.app", "ABCDE12345"));
assert!(!n.add_ios("com.example.app", "abcde12345"));
assert!(n.add_android("com.example.app", std::slice::from_ref(&cert)));
assert!(!n.add_android("com.example.app", std::slice::from_ref(&cert)));
assert!(n.set_allow_development(true));
assert!(!n.set_allow_development(true));
assert_eq!(
n.android_packages_without_certificate(),
vec!["com.legacy.app"]
);
let body = n.patch_body();
assert_eq!(
body["native_attestation"]["android_cloud_project_number"],
"123"
);
assert!(body["native_attestation"]
.get("android_credentials_configured")
.is_none());
assert_eq!(
body["native_attestation"]["ios_apps"][0]["app_id_prefix"],
"ABCDE12345"
);
assert_eq!(
body["android_package_names"],
json!(["com.legacy.app", "com.example.app"])
);
assert!(n.remove_android("com.example.app", Some(&cert)));
assert!(n.android_apps().is_empty());
assert_eq!(
n.patch_body()["android_package_names"],
json!(["com.legacy.app"])
);
assert!(n.remove_ios("COM.EXAMPLE.APP", None));
assert!(!n.remove_ios("com.example.app", None));
}
#[test]
fn an_application_without_settings_starts_empty() {
let n = Native::from_application(&json!({ "native_attestation": null }));
assert!(n.ios_apps().is_empty());
assert!(!n.allow_development());
assert_eq!(n.patch_body()["native_attestation"]["ios_apps"], json!([]));
}
}