diff --git a/crates/horizon-prepare/src/artifacts.rs b/crates/horizon-prepare/src/artifacts.rs index 80b3bcf05..b29bffb28 100644 --- a/crates/horizon-prepare/src/artifacts.rs +++ b/crates/horizon-prepare/src/artifacts.rs @@ -79,12 +79,22 @@ impl Lock { /// Mojang republishes a version JSON for asset-index changes; every known one is accepted. fn manifest_accepted(&self, checksum: &str) -> bool { - let game = self.json.get("minecraft"); self.pin("manifest_sha1").is_ok_and(|pin| pin == checksum) - || game - .and_then(|g| g.get("accepted_manifest_sha1")) - .and_then(Value::as_array) - .is_some_and(|list| list.iter().any(|v| v.as_str() == Some(checksum))) + || self.listed("accepted_manifest_sha1", checksum) + } + + /// The asset indexes of those republished version JSONs: a launcher keeps one + /// `indexes/.json`, the last it downloaded, whichever version JSON it reads. + pub(crate) fn asset_index_accepted(&self, checksum: &str) -> bool { + self.listed("accepted_asset_index_sha1", checksum) + } + + fn listed(&self, key: &str, checksum: &str) -> bool { + self.json + .get("minecraft") + .and_then(|g| g.get(key)) + .and_then(Value::as_array) + .is_some_and(|list| list.iter().any(|v| v.as_str() == Some(checksum))) } } diff --git a/crates/horizon-prepare/src/sounds.rs b/crates/horizon-prepare/src/sounds.rs index f6ff0b714..313100ff4 100644 --- a/crates/horizon-prepare/src/sounds.rs +++ b/crates/horizon-prepare/src/sounds.rs @@ -9,9 +9,17 @@ use crate::{digest, read_json, Log}; use std::fs; use std::path::{Path, PathBuf}; -/// The launcher's asset directory and the pinned version's verified asset index -/// (tools/lab.py `launcher_assets`). -fn launcher_assets(manifest: &Value, minecraft: &Path) -> Result<(PathBuf, PathBuf), String> { +/// The launcher's asset directory and the pinned version's asset index (tools/lab.py +/// `launcher_assets`). Mojang republishes a version's index under the same id for translation +/// fixes, and a launcher keeps only the last one it downloaded (#1076): an index the lock does +/// not know is still used, with a line in the log, since every object copied from it is +/// checked against its own SHA-1. +fn launcher_assets( + lock: &Lock, + manifest: &Value, + minecraft: &Path, + log: Log, +) -> Result<(PathBuf, PathBuf), String> { let assets = minecraft.join("assets"); let info = manifest .get("assetIndex") @@ -34,8 +42,13 @@ fn launcher_assets(manifest: &Value, minecraft: &Path) -> Result<(PathBuf, PathB artifacts::launcher_hint(version) )); } - if digest(&index, "sha1")? != sha1 { - return Err(format!("{} is not the pinned asset index", index.display())); + let checksum = digest(&index, "sha1")?; + if checksum != sha1 && !lock.asset_index_accepted(&checksum) { + log(&format!( + "{} is an asset index Horizon does not know yet (sha1 {checksum}); Mojang may have \ + republished it. Using it: every file is still checked against its own SHA-1.", + index.display() + )); } Ok((assets, index)) } @@ -76,7 +89,14 @@ fn is_sound(name: &str) -> bool { /// `.local/horizon-client/`; returns that folder. Files already there with the right /// SHA-1 are kept. pub fn sounds(root: &Path, minecraft: Option<&Path>, log: Log) -> Result { - copy_assets(root, minecraft, log, is_sound, "Sound", &[]) + copy_assets( + root, + minecraft, + log, + is_sound, + "Sound", + &["minecraft/sounds.json"], + ) } /// Replaces the client JAR's 1x1 title placeholders with the full panorama from the @@ -119,7 +139,7 @@ fn copy_assets( let lock = Lock::read(root)?; let minecraft = artifacts::minecraft_dir(minecraft); let manifest = artifacts::import_manifest(&lock, &minecraft)?; - let (store, index) = launcher_assets(&manifest, &minecraft)?; + let (store, index) = launcher_assets(&lock, &manifest, &minecraft, log)?; let id = manifest .get("id") .and_then(Value::as_str) @@ -307,6 +327,51 @@ mod tests { f.run().unwrap(); } + /// #1076: the launcher holds an index Mojang republished under the same id, so its SHA-1 + /// is not the one in the version JSON. A known one is used quietly, an unknown one with a + /// line in the log; the sounds come through either way. + #[test] + fn republished_asset_indexes_still_give_sounds() { + let f = Fixture::new("republished"); + let index = f.minecraft.join("assets/indexes/7.json"); + let republished = format!("{}\n", fs::read_to_string(&index).unwrap()); + fs::write(&index, &republished).unwrap(); + let checksum = sha1_hex(republished.as_bytes()); + let lock = f.root.join("research-lock.json"); + let pinned = fs::read_to_string(&lock).unwrap(); + let sound = f + .root + .join(".local/horizon-client/9.9/assets/minecraft/sounds/dig/stone1.ogg"); + for known in [true, false] { + let accepted = if known { checksum.as_str() } else { "0" }; + fs::write( + &lock, + pinned.replace( + "\"manifest_sha1\"", + &format!("\"accepted_asset_index_sha1\": [\"{accepted}\"], \"manifest_sha1\""), + ), + ) + .unwrap(); + let _ = fs::remove_file(&sound); + let lines = std::cell::RefCell::new(Vec::new()); + sounds(&f.root, Some(&f.minecraft), &|l| { + lines.borrow_mut().push(l.to_string()) + }) + .unwrap(); + assert_eq!(fs::read(&sound).unwrap(), b"OggS stone"); + let lines = lines.into_inner(); + assert_eq!(lines.last().unwrap(), "Sound assets ready: 3 files, 0.0 MB"); + assert_eq!(lines.len(), if known { 1 } else { 2 }, "{lines:?}"); + if !known { + assert!( + lines[0].contains(&format!("does not know yet (sha1 {checksum})")), + "{}", + lines[0] + ); + } + } + } + #[test] fn every_object_is_checked() { let f = Fixture::new("corrupt"); @@ -412,14 +477,14 @@ mod tests { } #[test] - fn the_index_must_be_the_pinned_one() { + fn the_index_must_hold_the_sounds() { let f = Fixture::new("index"); let index = f.minecraft.join("assets/indexes/7.json"); fs::write(&index, "{\"objects\": {}}").unwrap(); - assert!(f - .run() - .unwrap_err() - .ends_with("is not the pinned asset index")); + assert_eq!( + f.run().unwrap_err(), + "minecraft/sounds.json is missing from the asset index" + ); fs::remove_file(&index).unwrap(); let error = f.run().unwrap_err(); assert!( diff --git a/research-lock.json b/research-lock.json index 219a59066..ab2234a3f 100644 --- a/research-lock.json +++ b/research-lock.json @@ -4,9 +4,16 @@ "manifest_sha1": "11f1aefe473eefba0af62e3286c33b692807b2eb", "accepted_manifest_sha1": [ "4fe1aa1ef8da1cb95c5bad1fb98890ca56dd8ca3", - "702fe59163c6ee6578607daa85811d9bc9c7cc40" + "702fe59163c6ee6578607daa85811d9bc9c7cc40", + "61fff1316bd50312624a858bbb5eb18fa45208ed" ], - "accepted_manifest_note": "Earlier 26.3 version JSONs Mojang republished: only assetIndex differs (non-English translations), jars and libraries are identical. A launcher may still hold any of them.", + "accepted_manifest_note": "Other 26.3 version JSONs Mojang republished: only assetIndex differs (non-English translations), jars and libraries are identical. A launcher may still hold any of them.", + "accepted_asset_index_sha1": [ + "abfaa525f923f807df8b4e4d29c1b5e3a104adbe", + "1e4e4a68dece1c0f51b8f93b45da8fe8da51bcd3", + "0c8f43b28f837869c1e54a6aeb22c396a1548946" + ], + "accepted_asset_index_note": "The asset indexes (id 34) of those republished version JSONs: a launcher keeps one 34.json, the last it downloaded, whichever version JSON it reads.", "client_sha1": "e877b6a07acd633fb3bb475002175cec036e7b87", "server_sha1": "33680f5f2ac32864d6d7cf5e56a705fdb3e05f4c", "java_major": 25 diff --git a/tools/lab.py b/tools/lab.py index 43770091b..c6b47ee8b 100644 --- a/tools/lab.py +++ b/tools/lab.py @@ -237,14 +237,18 @@ def import_library(artifact, destination_root, minecraft=None): def launcher_assets(manifest, minecraft=None): - """The launcher's asset directory and the pinned version's verified asset index.""" + """The launcher's asset directory and the pinned version's asset index.""" assets = minecraft_dir(minecraft) / "assets" info = manifest["assetIndex"] index = assets / "indexes" / f"{info['id']}.json" if not index.is_file(): raise FileNotFoundError(f"Missing {index}. {LAUNCHER_HINT.format(version=manifest['id'])}") - if digest(index, "sha1") != info["sha1"]: - raise ValueError(f"{index} is not the pinned asset index") + checksum = digest(index, "sha1") + known = json.loads(LOCK.read_text(encoding="utf-8"))["minecraft"].get("accepted_asset_index_sha1", []) + if checksum != info["sha1"] and checksum not in known: + # Mojang republishes an index under the same id (#1076); each object is still verified. + print(f"{index} is an asset index Horizon does not know yet (sha1 {checksum}); " + "using it, every file is still checked against its own SHA-1", file=sys.stderr) return assets, index