diff --git a/3rdparty/decompress/Cargo.toml b/3rdparty/decompress/Cargo.toml new file mode 100644 index 00000000..24ffe282 --- /dev/null +++ b/3rdparty/decompress/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "decompress" +edition.workspace = true +version.workspace = true +authors.workspace = true +license.workspace = true +repository.workspace = true + +[features] +default = [] + +[dependencies] +regex.workspace = true +thiserror.workspace = true +flate2.workspace = true +zip.workspace = true +lazy_static = "1.5" +derive_builder = "0.20" +ar = "0.9" +tar = "0.4" +bzip2 = "0.6" +xz2 = "0.1" +lzma-rs = "0.3" +zstd = "0.13" +infer = "0.19" diff --git a/3rdparty/decompress/LICENSE b/3rdparty/decompress/LICENSE new file mode 100644 index 00000000..e1a96dba --- /dev/null +++ b/3rdparty/decompress/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2021- Dotan Nahum + + 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. \ No newline at end of file diff --git a/3rdparty/decompress/src/decompressors/ar.rs b/3rdparty/decompress/src/decompressors/ar.rs new file mode 100755 index 00000000..b3049ec4 --- /dev/null +++ b/3rdparty/decompress/src/decompressors/ar.rs @@ -0,0 +1,140 @@ +use crate::decompressors::utils::normalize_mode; +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use ar::Archive; +use lazy_static::lazy_static; +use regex::Regex; +use std::path::{Component, PathBuf}; +use std::{fs, io}; +use std::{ + fs::File, + io::{BufReader, Read}, + path::Path, +}; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.(ar|deb)$").unwrap(); +} + +fn build_archive(archive: &Path) -> Result>, DecompressError> { + let fd = BufReader::new(File::open(archive)?); + let out: Archive> = Archive::new(Box::new(fd)); + Ok(out) +} +#[derive(Default)] +pub struct Ar { + re: Option, +} + +impl Ar { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Ar { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/x-unix-archive" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + let mut out = build_archive(archive)?; + let mut entries = vec![]; + while let Some(entry) = out.next_entry() { + let entry = entry?; + let header = entry.header(); + + let filepath = { + #[cfg(windows)] + { + PathBuf::from(String::from_utf8_lossy(header.identifier()).to_string()) + } + #[cfg(unix)] + { + use std::ffi::OsStr; + use std::os::unix::prelude::OsStrExt; + PathBuf::from(OsStr::from_bytes(header.identifier())) + } + }; + entries.push(filepath.to_string_lossy().to_string()); + } + Ok(Listing { id: "ar", entries }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + _opts: &ExtractOpts, + ) -> Result { + let mut out = build_archive(archive)?; + let mut files = vec![]; + + if !to.exists() { + fs::create_dir_all(to)?; + } + + // alternative impl: just unpack, and then mv everything back X levels + while let Some(entry) = out.next_entry() { + let entry = entry?; + let header = entry.header(); + + let filepath = { + #[cfg(windows)] + { + PathBuf::from(String::from_utf8_lossy(header.identifier()).to_string()) + } + #[cfg(unix)] + { + use std::ffi::OsStr; + use std::os::unix::prelude::OsStrExt; + PathBuf::from(OsStr::from_bytes(header.identifier())) + } + }; + + if filepath.components().any(|component| match component { + Component::ParentDir | Component::RootDir | Component::Prefix(..) => true, + Component::Normal(..) | Component::CurDir => false, + }) { + continue; + } + + // guess what, ar archives don't support components, only 1 level is there, so stripping not relevant! + // so does create_dir_all'isms + + // because we potentially stripped a component, we may have an empty path, in which case + // the joined target will be identical to the target folder + // we take this approach to avoid hardcoding a check against empty "" + let outpath = to.join(filepath); + if to == outpath { + continue; + } + + #[cfg(unix)] + let mode = entry.header().mode(); + + let mut outfile = fs::File::create(&outpath)?; + io::copy(&mut BufReader::new(entry), &mut outfile)?; + files.push(outpath.to_string_lossy().to_string()); + + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + let mode = normalize_mode(mode); + fs::set_permissions(&outpath, fs::Permissions::from_mode(mode))?; + } + } + Ok(Decompression { id: "ar", files }) + } +} diff --git a/3rdparty/decompress/src/decompressors/bz2.rs b/3rdparty/decompress/src/decompressors/bz2.rs new file mode 100755 index 00000000..d7640819 --- /dev/null +++ b/3rdparty/decompress/src/decompressors/bz2.rs @@ -0,0 +1,78 @@ +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::fs::File; +use std::io::BufReader; +use std::path::Path; +use std::{fs, io}; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.bz2|bz").unwrap(); +} + +#[derive(Default)] +pub struct Bz2 { + re: Option, +} + +impl Bz2 { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Bz2 { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/x-bzip2" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "bz2", + entries: vec![archive + .file_stem() + .ok_or_else(|| DecompressError::Error("cannot compose a file name".into()))? + .to_string_lossy() + .to_string()], + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + _opts: &ExtractOpts, + ) -> Result { + let fd = BufReader::new(File::open(archive)?); + let dec = bzip2::bufread::BzDecoder::new(fd); + + if !Path::new(to).exists() { + let _res = fs::create_dir_all(to); + } + + let target = to.join( + archive + .file_stem() + .ok_or_else(|| DecompressError::Error("cannot compose a file name".to_string()))?, + ); + let mut outfile = fs::File::create(&target)?; + + io::copy(&mut BufReader::new(dec), &mut outfile)?; + Ok(Decompression { + id: "bz2", + files: vec![target.to_string_lossy().to_string()], + }) + } +} diff --git a/3rdparty/decompress/src/decompressors/gz.rs b/3rdparty/decompress/src/decompressors/gz.rs new file mode 100755 index 00000000..ec81164b --- /dev/null +++ b/3rdparty/decompress/src/decompressors/gz.rs @@ -0,0 +1,74 @@ +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::{fs, io}; +use std::{fs::File, io::BufReader, path::Path}; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.gz$").unwrap(); +} + +#[derive(Default)] +pub struct Gz { + re: Option, +} + +impl Gz { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Gz { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/gzip" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "gz", + entries: vec![archive + .file_stem() + .ok_or_else(|| DecompressError::Error("cannot compose a file name".into()))? + .to_string_lossy() + .to_string()], + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + _opts: &ExtractOpts, + ) -> Result { + let fd = BufReader::new(File::open(archive)?); + let dec = flate2::bufread::GzDecoder::new(fd); + if !Path::new(to).exists() { + let _res = fs::create_dir_all(to); + } + let target = to.join( + archive + .file_stem() + .ok_or_else(|| DecompressError::Error("cannot compose a file name".to_string()))?, + ); + let mut outfile = fs::File::create(&target)?; + + io::copy(&mut BufReader::new(dec), &mut outfile)?; + Ok(Decompression { + id: "gz", + files: vec![target.to_string_lossy().to_string()], + }) + } +} diff --git a/3rdparty/decompress/src/decompressors/lzma.rs b/3rdparty/decompress/src/decompressors/lzma.rs new file mode 100755 index 00000000..5572c21a --- /dev/null +++ b/3rdparty/decompress/src/decompressors/lzma.rs @@ -0,0 +1,74 @@ +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::{fs, fs::File, io::BufReader, path::Path}; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.(lzma|tlz)$").unwrap(); +} + +#[derive(Default)] +pub struct Lzma { + re: Option, +} + +impl Lzma { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Lzma { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/x-lzma" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "lzma", + entries: vec![archive + .file_stem() + .ok_or_else(|| DecompressError::Error("cannot compose a file name".into()))? + .to_string_lossy() + .to_string()], + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + _opts: &ExtractOpts, + ) -> Result { + if !Path::new(to).exists() { + let _res = fs::create_dir_all(to); + } + let target = to.join( + archive + .file_stem() + .ok_or_else(|| DecompressError::Error("cannot compose a file name".to_string()))?, + ); + let mut outfile = fs::File::create(&target)?; + + let mut fd = BufReader::new(File::open(archive)?); + lzma_rs::lzma_decompress(&mut fd, &mut outfile) + .map_err(|e| DecompressError::Error(format!("LZMA decompression error: {}", e)))?; + + Ok(Decompression { + id: "lzma", + files: vec![target.to_string_lossy().to_string()], + }) + } +} diff --git a/3rdparty/decompress/src/decompressors/mod.rs b/3rdparty/decompress/src/decompressors/mod.rs new file mode 100755 index 00000000..6f68b9ba --- /dev/null +++ b/3rdparty/decompress/src/decompressors/mod.rs @@ -0,0 +1,15 @@ +pub mod ar; +pub mod bz2; +pub mod gz; +pub mod lzma; +mod tar_common; +pub mod tarball; +pub mod tarbz; +pub mod targz; +pub mod tarlzma; +pub mod tarxz; +pub mod tarzst; +mod utils; +pub mod xz; +pub mod zip; +pub mod zstd; diff --git a/3rdparty/decompress/src/decompressors/tar_common.rs b/3rdparty/decompress/src/decompressors/tar_common.rs new file mode 100755 index 00000000..10b08a43 --- /dev/null +++ b/3rdparty/decompress/src/decompressors/tar_common.rs @@ -0,0 +1,83 @@ +use std::borrow::Cow; +use std::{ + fs::{self}, + io::{self, BufReader, Read}, + path::{Path, PathBuf}, +}; + +use crate::decompressors::utils::normalize_mode; +use crate::{DecompressError, ExtractOpts}; +use tar::Archive; + +pub fn tar_list(out: &mut Archive>) -> Result, DecompressError> { + Ok(out + .entries()? + .collect::, _>>()? + .iter() + .map(tar::Entry::path) + .collect::, _>>()? + .iter() + .map(|p| p.to_string_lossy().to_string()) + .collect::>()) +} + +pub fn tar_extract( + out: &mut Archive>, + to: &Path, + opts: &ExtractOpts, +) -> Result, DecompressError> { + let mut files = vec![]; + if !to.exists() { + fs::create_dir_all(to)?; + } + + // alternative impl: just unpack, and then mv everything back X levels + for entry in out.entries()? { + let entry = entry?; + let filepath = entry.path()?; + + // strip prefixed components. this can be 0 parts, in which case strip does not happen. + // it's done for when archives contain an enclosing folder + let filepath = filepath.components().skip(opts.strip).collect::(); + + // because we potentially stripped a component, we may have an empty path, in which case + // the joined target will be identical to the target folder + // we take this approach to avoid hardcoding a check against empty "" + let outpath = to.join(filepath); + if to == outpath { + continue; + } + + if !(opts.filter)(outpath.as_path()) { + continue; + } + + let outpath: Cow<'_, Path> = (opts.map)(outpath.as_path()); + + if entry.header().entry_type() != tar::EntryType::Directory { + if let Some(p) = outpath.parent() { + if !p.exists() { + fs::create_dir_all(p)?; + } + } + + let mut outfile = fs::File::create(&outpath)?; + + #[cfg(unix)] + let h = entry.header().mode(); + + io::copy(&mut BufReader::new(entry), &mut outfile)?; + files.push(outpath.to_string_lossy().to_string()); + + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + if let Ok(mode) = h { + let mode = normalize_mode(mode); + fs::set_permissions(&outpath, fs::Permissions::from_mode(mode))?; + } + } + } + } + Ok(files) +} diff --git a/3rdparty/decompress/src/decompressors/tarball.rs b/3rdparty/decompress/src/decompressors/tarball.rs new file mode 100755 index 00000000..19750e96 --- /dev/null +++ b/3rdparty/decompress/src/decompressors/tarball.rs @@ -0,0 +1,70 @@ +use crate::decompressors::tar_common::tar_extract; +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::{ + fs::File, + io::{BufReader, Read}, + path::Path, +}; +use tar::Archive; + +use super::tar_common::tar_list; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.tar$").unwrap(); +} + +fn build_archive(archive: &Path) -> Result>, DecompressError> { + let fd = BufReader::new(File::open(archive)?); + let out: tar::Archive> = tar::Archive::new(Box::new(fd)); + Ok(out) +} + +#[derive(Default)] +pub struct Tarball { + re: Option, +} + +impl Tarball { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Tarball { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/x-tar" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "tarball", + entries: tar_list(&mut build_archive(archive)?)?, + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + opts: &ExtractOpts, + ) -> Result { + Ok(Decompression { + id: "tarball", + files: tar_extract(&mut build_archive(archive)?, to, opts)?, + }) + } +} diff --git a/3rdparty/decompress/src/decompressors/tarbz.rs b/3rdparty/decompress/src/decompressors/tarbz.rs new file mode 100755 index 00000000..5bf22302 --- /dev/null +++ b/3rdparty/decompress/src/decompressors/tarbz.rs @@ -0,0 +1,70 @@ +use crate::decompressors::tar_common::tar_extract; +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::{ + fs::File, + io::{BufReader, Read}, + path::Path, +}; +use tar::Archive; + +use super::tar_common::tar_list; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.t(ar\.bz2|bz)$").unwrap(); +} + +fn build_archive(archive: &Path) -> Result>, DecompressError> { + let fd = BufReader::new(File::open(archive)?); + let out: Archive> = Archive::new(Box::new(bzip2::bufread::BzDecoder::new(fd))); + Ok(out) +} + +#[derive(Default)] +pub struct Tarbz { + re: Option, +} + +impl Tarbz { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Tarbz { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/x-bzip2" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "tarbz", + entries: tar_list(&mut build_archive(archive)?)?, + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + opts: &ExtractOpts, + ) -> Result { + Ok(Decompression { + id: "tarbz", + files: tar_extract(&mut build_archive(archive)?, to, opts)?, + }) + } +} diff --git a/3rdparty/decompress/src/decompressors/targz.rs b/3rdparty/decompress/src/decompressors/targz.rs new file mode 100755 index 00000000..ad352187 --- /dev/null +++ b/3rdparty/decompress/src/decompressors/targz.rs @@ -0,0 +1,70 @@ +use crate::decompressors::tar_common::tar_extract; +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::{ + fs::File, + io::{BufReader, Read}, + path::Path, +}; +use tar::Archive; + +use super::tar_common::tar_list; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.t(ar\.gz|gz)$").unwrap(); +} + +fn build_archive(archive: &Path) -> Result>, DecompressError> { + let fd = BufReader::new(File::open(archive)?); + let out: Archive> = Archive::new(Box::new(flate2::bufread::GzDecoder::new(fd))); + Ok(out) +} + +#[derive(Default)] +pub struct Targz { + re: Option, +} + +impl Targz { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Targz { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/gzip" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "targz", + entries: tar_list(&mut build_archive(archive)?)?, + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + opts: &ExtractOpts, + ) -> Result { + Ok(Decompression { + id: "targz", + files: tar_extract(&mut build_archive(archive)?, to, opts)?, + }) + } +} diff --git a/3rdparty/decompress/src/decompressors/tarlzma.rs b/3rdparty/decompress/src/decompressors/tarlzma.rs new file mode 100755 index 00000000..876645dc --- /dev/null +++ b/3rdparty/decompress/src/decompressors/tarlzma.rs @@ -0,0 +1,73 @@ +use crate::decompressors::tar_common::tar_extract; +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::{ + fs::File, + io::{BufReader, Read}, + path::Path, +}; +use tar::Archive; + +use super::tar_common::tar_list; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.t(ar\.lzma|lz)$").unwrap(); +} + +fn build_archive(archive: &Path) -> Result>, DecompressError> { + let mut fd = BufReader::new(File::open(archive)?); + let mut decompressed = Vec::new(); + lzma_rs::lzma_decompress(&mut fd, &mut decompressed) + .map_err(|e| DecompressError::Error(format!("LZMA decompression error: {}", e)))?; + let out: Archive> = Archive::new(Box::new(std::io::Cursor::new(decompressed))); + Ok(out) +} + +#[derive(Default)] +pub struct Tarlzma { + re: Option, +} + +impl Tarlzma { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Tarlzma { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/x-lzma" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "tarlzma", + entries: tar_list(&mut build_archive(archive)?)?, + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + opts: &ExtractOpts, + ) -> Result { + Ok(Decompression { + id: "tarlzma", + files: tar_extract(&mut build_archive(archive)?, to, opts)?, + }) + } +} diff --git a/3rdparty/decompress/src/decompressors/tarxz.rs b/3rdparty/decompress/src/decompressors/tarxz.rs new file mode 100755 index 00000000..d99482f7 --- /dev/null +++ b/3rdparty/decompress/src/decompressors/tarxz.rs @@ -0,0 +1,70 @@ +use crate::decompressors::tar_common::tar_extract; +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::{ + fs::File, + io::{BufReader, Read}, + path::Path, +}; +use tar::Archive; + +use super::tar_common::tar_list; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.t(ar\.xz|xz)$").unwrap(); +} + +fn build_archive(archive: &Path) -> Result>, DecompressError> { + let fd = BufReader::new(File::open(archive)?); + let out: Archive> = Archive::new(Box::new(xz2::bufread::XzDecoder::new(fd))); + Ok(out) +} + +#[derive(Default)] +pub struct Tarxz { + re: Option, +} + +impl Tarxz { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Tarxz { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/x-xz" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "tarxz", + entries: tar_list(&mut build_archive(archive)?)?, + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + opts: &ExtractOpts, + ) -> Result { + Ok(Decompression { + id: "tarxz", + files: tar_extract(&mut build_archive(archive)?, to, opts)?, + }) + } +} diff --git a/3rdparty/decompress/src/decompressors/tarzst.rs b/3rdparty/decompress/src/decompressors/tarzst.rs new file mode 100755 index 00000000..3e32f922 --- /dev/null +++ b/3rdparty/decompress/src/decompressors/tarzst.rs @@ -0,0 +1,70 @@ +use crate::decompressors::tar_common::tar_extract; +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::{ + fs::File, + io::{BufReader, Read}, + path::Path, +}; +use tar::Archive; + +use super::tar_common::tar_list; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.t(ar\.zst|zst)$").unwrap(); +} + +fn build_archive(archive: &Path) -> Result>, DecompressError> { + let fd = BufReader::new(File::open(archive)?); + let out: Archive> = Archive::new(Box::new(zstd::stream::read::Decoder::new(fd)?)); + Ok(out) +} + +#[derive(Default)] +pub struct Tarzst { + re: Option, +} + +impl Tarzst { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Tarzst { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/x-bzip2" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "tarzst", + entries: tar_list(&mut build_archive(archive)?)?, + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + opts: &ExtractOpts, + ) -> Result { + Ok(Decompression { + id: "tarzst", + files: tar_extract(&mut build_archive(archive)?, to, opts)?, + }) + } +} diff --git a/3rdparty/decompress/src/decompressors/utils.rs b/3rdparty/decompress/src/decompressors/utils.rs new file mode 100755 index 00000000..6bb79937 --- /dev/null +++ b/3rdparty/decompress/src/decompressors/utils.rs @@ -0,0 +1,7 @@ +pub fn normalize_mode(mode: u32) -> u32 { + if mode == 0 { + 0o644 + } else { + mode + } +} diff --git a/3rdparty/decompress/src/decompressors/xz.rs b/3rdparty/decompress/src/decompressors/xz.rs new file mode 100755 index 00000000..082b853b --- /dev/null +++ b/3rdparty/decompress/src/decompressors/xz.rs @@ -0,0 +1,73 @@ +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::{fs, fs::File, io, io::BufReader, path::Path}; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.xz$").unwrap(); +} + +#[derive(Default)] +pub struct Xz { + re: Option, +} + +impl Xz { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Xz { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/x-xz" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "xz", + entries: vec![archive + .file_stem() + .ok_or_else(|| DecompressError::Error("cannot compose a file name".into()))? + .to_string_lossy() + .to_string()], + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + _opts: &ExtractOpts, + ) -> Result { + let fd = BufReader::new(File::open(archive)?); + let dec = xz2::bufread::XzDecoder::new(fd); + if !Path::new(to).exists() { + let _res = fs::create_dir_all(to); + } + let target = to.join( + archive + .file_stem() + .ok_or_else(|| DecompressError::Error("cannot compose a file name".to_string()))?, + ); + let mut outfile = fs::File::create(&target)?; + + io::copy(&mut BufReader::new(dec), &mut outfile)?; + Ok(Decompression { + id: "xz", + files: vec![target.to_string_lossy().to_string()], + }) + } +} diff --git a/3rdparty/decompress/src/decompressors/zip.rs b/3rdparty/decompress/src/decompressors/zip.rs new file mode 100755 index 00000000..232f3291 --- /dev/null +++ b/3rdparty/decompress/src/decompressors/zip.rs @@ -0,0 +1,132 @@ +use std::{ + fs::File, + io::{self, BufReader}, + path::{Path, PathBuf}, +}; + +use lazy_static::lazy_static; +use regex::Regex; +use zip::ZipArchive; + +use crate::{ + decompressors::utils::normalize_mode, DecompressError, Decompression, Decompressor, + ExtractOpts, Listing, +}; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.zip$").unwrap(); +} + +fn build_archive(archive: &Path) -> Result>, DecompressError> { + let rdr = ZipArchive::new(BufReader::new(File::open(archive)?)) + .map_err(|err| DecompressError::Error(err.to_string()))?; + + Ok(rdr) +} +#[derive(Default)] +pub struct Zip { + re: Option, +} +impl Zip { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Zip { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/zip" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + let mut rdr = build_archive(archive)?; + let mut entries = vec![]; + for i in 0..rdr.len() { + let file = rdr + .by_index(i) + .map_err(|err| DecompressError::Error(err.to_string()))?; + let filepath = file + .enclosed_name() + .ok_or_else(|| DecompressError::Error("Invalid file path".to_string()))?; + entries.push(filepath.to_string_lossy().to_string()); + } + Ok(Listing { id: "zip", entries }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + opts: &ExtractOpts, + ) -> Result { + use std::fs; + + let mut files = vec![]; + let mut rdr = build_archive(archive)?; + if !to.exists() { + fs::create_dir_all(to)?; + } + + for i in 0..rdr.len() { + let mut file = rdr + .by_index(i) + .map_err(|err| DecompressError::Error(err.to_string()))?; + let filepath = file + .enclosed_name() + .ok_or_else(|| DecompressError::Error("Invalid file path".to_string()))?; + + // strip prefixed components. this can be 0 parts, in which case strip does not happen. + // it's done for when archives contain an enclosing folder + let filepath = filepath.components().skip(opts.strip).collect::(); + + // because we potentially stripped a component, we may have an empty path, in which case + // the joined target will be identical to the target folder + // we take this approach to avoid hardcoding a check against empty "" + let outpath = to.join(filepath); + if outpath == to { + continue; + } + + if !(opts.filter)(outpath.as_path()) { + continue; + } + + let outpath = (opts.map)(outpath.as_path()); + + if file.name().ends_with('/') { + fs::create_dir_all(&outpath)?; + } else { + if let Some(p) = outpath.parent() { + if !p.exists() { + fs::create_dir_all(p)?; + } + } + let mut outfile = fs::File::create(&outpath)?; + io::copy(&mut file, &mut outfile)?; + files.push(outpath.to_string_lossy().to_string()); + } + // Get and Set permissions + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + if let Some(mode) = file.unix_mode() { + let mode = normalize_mode(mode); + fs::set_permissions(&outpath, fs::Permissions::from_mode(mode))?; + } + } + } + Ok(Decompression { id: "zip", files }) + } +} diff --git a/3rdparty/decompress/src/decompressors/zstd.rs b/3rdparty/decompress/src/decompressors/zstd.rs new file mode 100755 index 00000000..07b7aa8e --- /dev/null +++ b/3rdparty/decompress/src/decompressors/zstd.rs @@ -0,0 +1,73 @@ +use crate::{DecompressError, Decompression, Decompressor, ExtractOpts, Listing}; +use lazy_static::lazy_static; +use regex::Regex; +use std::{fs, fs::File, io, io::BufReader, path::Path}; + +lazy_static! { + static ref RE: Regex = Regex::new(r"(?i)\.zst$").unwrap(); +} + +#[derive(Default)] +pub struct Zstd { + re: Option, +} + +impl Zstd { + #[must_use] + pub fn new(re: Option) -> Self { + Self { re } + } + #[must_use] + pub fn build(re: Option) -> Box { + Box::new(Self::new(re)) + } +} + +impl Decompressor for Zstd { + fn test_mimetype(&self, archive: &str) -> bool { + archive == "application/zstd" + } + + fn test(&self, archive: &Path) -> bool { + archive + .file_name() + .and_then(std::ffi::OsStr::to_str) + .map_or(false, |f| self.re.as_ref().unwrap_or(&*RE).is_match(f)) + } + + fn list(&self, archive: &Path) -> Result { + Ok(Listing { + id: "zst", + entries: vec![archive + .file_stem() + .ok_or_else(|| DecompressError::Error("cannot compose a file name".into()))? + .to_string_lossy() + .to_string()], + }) + } + + fn decompress( + &self, + archive: &Path, + to: &Path, + _opts: &ExtractOpts, + ) -> Result { + let fd = BufReader::new(File::open(archive)?); + let dec = zstd::stream::read::Decoder::new(fd)?; + if !Path::new(to).exists() { + let _res = fs::create_dir_all(to); + } + let target = to.join( + archive + .file_stem() + .ok_or_else(|| DecompressError::Error("cannot compose a file name".to_string()))?, + ); + let mut outfile = fs::File::create(&target)?; + + io::copy(&mut BufReader::new(dec), &mut outfile)?; + Ok(Decompression { + id: "zst", + files: vec![target.to_string_lossy().to_string()], + }) + } +} diff --git a/3rdparty/decompress/src/lib.rs b/3rdparty/decompress/src/lib.rs new file mode 100755 index 00000000..63d32321 --- /dev/null +++ b/3rdparty/decompress/src/lib.rs @@ -0,0 +1,264 @@ +#![allow(clippy::missing_const_for_fn)] +#![allow(clippy::module_name_repetitions)] +pub mod decompressors; + +use derive_builder::Builder; +use std::borrow::Cow; +use std::{convert::Infallible, io, path::Path}; +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum DecompressError { + #[error("could not decompress: `{0}`")] + IO(#[from] io::Error), + + #[error("could not decompress: `{0}`")] + Error(String), + + #[error("could not decompress: `{0}`")] + Infallible(#[from] Infallible), + + #[error("no compressor found")] + MissingCompressor, +} + +pub type FilterFn = dyn Fn(&Path) -> bool; +pub type MapFn = dyn Fn(&Path) -> Cow<'_, Path>; + +#[derive(Builder)] +#[builder(pattern = "owned")] +pub struct ExtractOpts { + #[builder(default)] + pub detect_content: bool, + + #[builder(default)] + pub strip: usize, + + #[builder(setter(custom), default = "Box::new(|_| true)")] + pub filter: Box, + + #[builder(setter(custom), default = "Box::new(|path| Cow::from(path))")] + pub map: Box, +} + +impl ExtractOptsBuilder { + /// Given a predicate, filter a path in. + #[must_use] + pub fn filter(mut self, value: impl Fn(&Path) -> bool + 'static) -> Self { + self.filter = Some(Box::new(value)); + self + } + /// Given a mapping function, transform a path into a different or similar path + #[must_use] + pub fn map(mut self, value: impl Fn(&Path) -> Cow<'_, Path> + 'static) -> Self { + self.map = Some(Box::new(value)); + self + } +} + +#[derive(Debug)] +pub struct Decompression { + pub id: &'static str, + pub files: Vec, +} + +#[derive(Debug)] +pub struct Listing { + pub id: &'static str, + pub entries: Vec, +} + +/// +/// `Decompressor` is a trait that you can implement to add your own decompressor type. +/// A `Decompressor` is inserted into a stack, where given a potential archive file, +/// many decompressors may attempt to test if they're capable of unpacking it. +/// The first `Decompressor` which will test true will be the one selected to unpack. +/// +/// It is _recommended_ to let a user pick a regex for testing against a `Path`, although +/// there is no limit to what you can do, as long as a user can override the Decompressor +/// decision when building a custom stack. +/// +pub trait Decompressor { + /// + /// Test if this `Decompressor` can unpack an archive, given a mimetype. + fn test_mimetype(&self, mimetype: &str) -> bool; + + /// + /// Test if this `Decompressor` can unpack an archive, given a path. + /// The convention is to use `Regex` internally to test a path, because this is + /// a convenient way for end users to override the behavior. + /// You may choose to implement a different, but configurable, testing strategy. + fn test(&self, archive: &Path) -> bool; + + /// + /// List an archive + /// + /// # Errors + /// + /// This function will return an error if unpacking fails. + fn list(&self, archive: &Path) -> Result; + + /// + /// Decompress an archive + /// + /// # Errors + /// + /// This function will return an error if unpacking fails. + fn decompress( + &self, + archive: &Path, + to: &Path, + opts: &ExtractOpts, + ) -> Result; +} + +/// +/// Represent a stack of decompressors with a default stack preconfigured when calling `new` +/// +pub struct Decompress { + decompressors: Vec>, +} + +impl Default for Decompress { + fn default() -> Self { + Self { + decompressors: vec![ + Box::::default(), + Box::::default(), + Box::::default(), + Box::::default(), + Box::::default(), + Box::::default(), + Box::::default(), + // order is important, `gz` is placed only after the targz variant did not match + // if it's placed above targz, it will unpack and leave a tar archive. + Box::::default(), + Box::::default(), + Box::::default(), + Box::::default(), + Box::::default(), + Box::::default(), + ], + } + } +} + +impl Decompress { + /// Find a decompressor from the stack + /// + /// # Errors + /// + /// This function will return an error if IO fails + #[allow(clippy::borrowed_box)] + pub fn find_decompressor>( + &self, + archive: P, + detect_content: bool, + ) -> Result<&Box, DecompressError> { + if detect_content { + let res = infer::get_from_path(archive.as_ref())?; + let mt = res.map(|t| t.mime_type()); + mt.and_then(|mt| self.decompressors.iter().find(|dec| dec.test_mimetype(mt))) + } else { + println!("f: {:?} ", archive.as_ref()); + self.decompressors + .iter() + .find(|dec| dec.test(archive.as_ref())) + } + .ok_or(DecompressError::MissingCompressor) + } + + /// Build given a custom stack of decompressors + #[must_use] + pub fn build(decompressors: Vec>) -> Self { + Self { decompressors } + } + + /// List + /// + /// # Errors + /// + /// This function will return an error if an IO or parsing error happened + pub fn list>( + &self, + archive: P, + opts: &ExtractOpts, + ) -> Result { + self.find_decompressor(archive.as_ref(), opts.detect_content) + .and_then(|dec| dec.list(archive.as_ref())) + } + + /// Decompress with a decompressor that is selected based on file name (cheaper) + /// + /// # Errors + /// + /// This function will return an error if an IO or parsing error happened + pub fn decompress>( + &self, + archive: P, + to: P, + opts: &ExtractOpts, + ) -> Result { + self.find_decompressor(archive.as_ref(), opts.detect_content) + .and_then(|dec| dec.decompress(archive.as_ref(), to.as_ref(), opts)) + } + + /// Returns `true` if any of the decompressors in the stack can decompress this + /// specific archive based on its content (reads first 8kb) + /// + /// # Errors + /// May fail if cannot read the file + pub fn can_decompress_content>( + &self, + archive: P, + ) -> Result { + match self.find_decompressor(archive.as_ref(), true) { + Ok(_) => Ok(true), + Err(DecompressError::MissingCompressor) => Ok(false), + Err(e) => Err(e), + } + } + + /// Returns `true` if any of the decompressors in the stack can decompress this + /// specific archive based on its path (no file opening) + pub fn can_decompress>(&self, archive: P) -> bool { + self.find_decompressor(archive.as_ref(), false).is_ok() + } +} + +/// Decompress an archive with default decompressor set up +/// +/// # Errors +/// +/// This function will return an error if IO or parsing failed +pub fn decompress>( + archive: P, + to: P, + opts: &ExtractOpts, +) -> Result { + Decompress::default().decompress(archive, to, opts) +} + +/// List an archive with default decompressor set up +/// +/// # Errors +/// +/// This function will return an error if IO or parsing failed +pub fn list>(archive: P, opts: &ExtractOpts) -> Result { + Decompress::default().list(archive, opts) +} + +/// Returns `true` if any of the decompressors in the stack can decompress this +/// specific archive based on its path (no file opening) +pub fn can_decompress>(archive: P) -> bool { + Decompress::default().can_decompress(archive) +} + +/// Returns `true` if any of the decompressors in the stack can decompress this +/// specific archive based on its content (reads first 8kb) +/// +/// # Errors +/// May fail if cannot read the file +pub fn can_decompress_content>(archive: P) -> Result { + Decompress::default().can_decompress_content(archive) +} diff --git a/3rdparty/omnisette/Cargo.toml b/3rdparty/omnisette/Cargo.toml new file mode 100644 index 00000000..d3d10fa0 --- /dev/null +++ b/3rdparty/omnisette/Cargo.toml @@ -0,0 +1,54 @@ +[package] +name = "omnisette" +edition.workspace = true +version.workspace = true +authors.workspace = true +license.workspace = true +repository.workspace = true + +[features] +remote-anisette = [] +async = ["dep:async-trait"] +default = ["remote-anisette", "dep:remove-async-await"] +remote-anisette-v3 = [ + "async", + "dep:serde", + "dep:serde_json", + "dep:tokio-tungstenite", + "dep:futures-util", + "dep:chrono", +] +aos-kit = [] + +[dependencies] +sha2.workspace = true +base64.workspace = true +rand.workspace = true +plist.workspace = true +thiserror.workspace = true + +hex.workspace = true +reqwest.workspace = true +uuid.workspace = true +android-loader = { git = "https://github.com/Dadoum/android-loader", branch = "bigger_pages" } +libc = "0.2" +log.workspace = true +async-trait = { version = "0.1", optional = true } +remove-async-await = { version = "1.0", optional = true } +serde = { workspace = true, optional = true } +serde_json = { workspace = true, optional = true } +tokio-tungstenite = { version = "0.27.0", optional = true, features = [ + "rustls-tls-webpki-roots", +] } +futures-util = { version = "0.3.28", optional = true } +chrono = { workspace = true, optional = true } +anyhow = "1.0" + +[target.'cfg(target_os = "macos")'.dependencies] +dlopen2 = "0.4" +objc = "0.2" +objc-foundation = "0.1" + +[dev-dependencies] +tokio.workspace = true +simplelog = "0.12" diff --git a/3rdparty/omnisette/LICENSE b/3rdparty/omnisette/LICENSE new file mode 100644 index 00000000..a612ad98 --- /dev/null +++ b/3rdparty/omnisette/LICENSE @@ -0,0 +1,373 @@ +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. diff --git a/3rdparty/omnisette/src/adi_proxy.rs b/3rdparty/omnisette/src/adi_proxy.rs new file mode 100755 index 00000000..4511f9bf --- /dev/null +++ b/3rdparty/omnisette/src/adi_proxy.rs @@ -0,0 +1,383 @@ +use crate::AnisetteError; +use crate::adi_proxy::ProvisioningError::InvalidResponse; +use crate::anisette_headers_provider::AnisetteHeadersProvider; +use base64::Engine; +use base64::engine::general_purpose::STANDARD as base64_engine; +use log::debug; +use plist::{Dictionary, Value}; +use rand::RngCore; +#[cfg(not(feature = "async"))] +use reqwest::blocking::{Client, ClientBuilder, Response}; +use reqwest::header::{HeaderMap, HeaderValue, InvalidHeaderValue}; +#[cfg(feature = "async")] +use reqwest::{Client, ClientBuilder, Response}; +use sha2::{Digest, Sha256}; +use std::collections::HashMap; +use std::fmt::{Display, Formatter}; +use std::io::{self, Read, Write}; +use std::path::PathBuf; +use thiserror::Error; + +#[derive(Debug)] +pub struct ServerError { + pub code: i64, + pub description: String, +} + +#[derive(Debug)] +pub enum ProvisioningError { + InvalidResponse, + ServerError(ServerError), +} + +impl std::fmt::Display for ProvisioningError { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{self:?}") + } +} + +impl std::error::Error for ProvisioningError {} + +#[derive(Debug, Error)] +pub enum ADIError { + Unknown(i32), + ProvisioningError(#[from] ProvisioningError), + PlistError(#[from] plist::Error), + ReqwestError(#[from] reqwest::Error), + Base64Error(#[from] base64::DecodeError), + InvalidHeaderValue(#[from] InvalidHeaderValue), + IOError(#[from] io::Error), +} + +impl ADIError { + pub fn resolve(error_number: i32) -> ADIError { + ADIError::Unknown(error_number) + } +} + +#[cfg_attr(feature = "async", async_trait::async_trait)] +trait ToPlist { + #[cfg_attr(not(feature = "async"), remove_async_await::remove_async_await)] + async fn plist(self) -> Result; +} + +#[cfg_attr(feature = "async", async_trait::async_trait)] +impl ToPlist for Response { + #[cfg_attr(not(feature = "async"), remove_async_await::remove_async_await)] + async fn plist(self) -> Result { + if let Ok(property_list) = Value::from_reader_xml(&*self.bytes().await?) { + Ok(property_list.as_dictionary().unwrap().to_owned()) + } else { + Err(ProvisioningError::InvalidResponse.into()) + } + } +} + +impl Display for ADIError { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{self:?}") + } +} + +pub struct SynchronizeData { + pub mid: Vec, + pub srm: Vec, +} + +pub struct StartProvisioningData { + pub cpim: Vec, + pub session: u32, +} + +pub struct RequestOTPData { + pub otp: Vec, + pub mid: Vec, +} + +#[cfg_attr(feature = "async", async_trait::async_trait(?Send))] +pub trait ADIProxy: Send + Sync { + fn erase_provisioning(&mut self, ds_id: i64) -> Result<(), ADIError>; + fn synchronize(&mut self, ds_id: i64, sim: &[u8]) -> Result; + fn destroy_provisioning_session(&mut self, session: u32) -> Result<(), ADIError>; + fn end_provisioning(&mut self, session: u32, ptm: &[u8], tk: &[u8]) -> Result<(), ADIError>; + fn start_provisioning( + &mut self, + ds_id: i64, + spim: &[u8], + ) -> Result; + fn is_machine_provisioned(&self, ds_id: i64) -> bool; + fn request_otp(&self, ds_id: i64) -> Result; + + fn set_local_user_uuid(&mut self, local_user_uuid: String); + fn set_device_identifier(&mut self, device_identifier: String) -> Result<(), ADIError>; + + fn get_local_user_uuid(&self) -> String; + fn get_device_identifier(&self) -> String; + fn get_serial_number(&self) -> String; +} + +pub trait ConfigurableADIProxy: ADIProxy { + fn set_identifier(&mut self, identifier: &str) -> Result<(), ADIError>; + fn set_provisioning_path(&mut self, path: &str) -> Result<(), ADIError>; +} + +pub const AKD_USER_AGENT: &str = "akd/1.0 CFNetwork/808.1.4"; +pub const CLIENT_INFO_HEADER: &str = + " "; +pub const DS_ID: i64 = -2; +pub const IDENTIFIER_LENGTH: usize = 16; +pub type Identifier = [u8; IDENTIFIER_LENGTH]; + +trait AppleRequestResult { + fn check_status(&self) -> Result<(), ADIError>; + fn get_response(&self) -> Result<&Dictionary, ADIError>; +} + +impl AppleRequestResult for Dictionary { + fn check_status(&self) -> Result<(), ADIError> { + let status = self + .get("Status") + .ok_or(InvalidResponse)? + .as_dictionary() + .unwrap(); + let code = status.get("ec").unwrap().as_signed_integer().unwrap(); + if code != 0 { + let description = status.get("em").unwrap().as_string().unwrap().to_string(); + Err(ProvisioningError::ServerError(ServerError { code, description }).into()) + } else { + Ok(()) + } + } + + fn get_response(&self) -> Result<&Dictionary, ADIError> { + if let Some(response) = self.get("Response") { + let response = response.as_dictionary().unwrap(); + response.check_status()?; + Ok(response) + } else { + Err(InvalidResponse.into()) + } + } +} + +impl dyn ADIProxy { + fn make_http_client(&mut self) -> Result { + let mut headers = HeaderMap::new(); + headers.insert("Content-Type", HeaderValue::from_str("text/x-xml-plist")?); + + headers.insert( + "X-Mme-Client-Info", + HeaderValue::from_str(CLIENT_INFO_HEADER)?, + ); + headers.insert( + "X-Mme-Device-Id", + HeaderValue::from_str(self.get_device_identifier().as_str())?, + ); + headers.insert( + "X-Apple-I-MD-LU", + HeaderValue::from_str(self.get_local_user_uuid().as_str())?, + ); + headers.insert( + "X-Apple-I-SRL-NO", + HeaderValue::from_str(self.get_serial_number().as_str())?, + ); + + debug!("Headers sent: {headers:?}"); + + let http_client = ClientBuilder::new() + .http1_title_case_headers() + .danger_accept_invalid_certs(true) // TODO: pin the apple certificate + .user_agent(AKD_USER_AGENT) + .default_headers(headers) + .build()?; + + Ok(http_client) + } + + #[cfg_attr(not(feature = "async"), remove_async_await::remove_async_await)] + async fn provision_device(&mut self) -> Result<(), ADIError> { + let client = self.make_http_client()?; + + let url_bag_res = client + .get("https://gsa.apple.com/grandslam/GsService2/lookup") + .send() + .await? + .plist() + .await?; + + let urls = url_bag_res.get("urls").unwrap().as_dictionary().unwrap(); + + let start_provisioning_url = urls + .get("midStartProvisioning") + .unwrap() + .as_string() + .unwrap(); + let finish_provisioning_url = urls + .get("midFinishProvisioning") + .unwrap() + .as_string() + .unwrap(); + + let mut body = plist::Dictionary::new(); + body.insert( + "Header".to_string(), + plist::Value::Dictionary(plist::Dictionary::new()), + ); + body.insert( + "Request".to_string(), + plist::Value::Dictionary(plist::Dictionary::new()), + ); + + let mut sp_request = Vec::new(); + plist::Value::Dictionary(body).to_writer_xml(&mut sp_request)?; + + debug!("First provisioning request..."); + let response = client + .post(start_provisioning_url) + .body(sp_request) + .send() + .await? + .plist() + .await?; + + let response = response.get_response()?; + + let spim = response + .get("spim") + .unwrap() + .as_string() + .unwrap() + .to_owned(); + + let spim = base64_engine.decode(spim)?; + let first_step = self.start_provisioning(DS_ID, spim.as_slice())?; + + let mut body = Dictionary::new(); + let mut request = Dictionary::new(); + request.insert( + "cpim".to_owned(), + Value::String(base64_engine.encode(first_step.cpim)), + ); + body.insert("Header".to_owned(), Value::Dictionary(Dictionary::new())); + body.insert("Request".to_owned(), Value::Dictionary(request)); + + let mut fp_request = Vec::new(); + Value::Dictionary(body).to_writer_xml(&mut fp_request)?; + + debug!("Second provisioning request..."); + let response = client + .post(finish_provisioning_url) + .body(fp_request) + .send() + .await? + .plist() + .await?; + + let response = response.get_response()?; + + let ptm = base64_engine.decode(response.get("ptm").unwrap().as_string().unwrap())?; + let tk = base64_engine.decode(response.get("tk").unwrap().as_string().unwrap())?; + + self.end_provisioning(first_step.session, ptm.as_slice(), tk.as_slice())?; + debug!("Done."); + + Ok(()) + } +} + +pub struct ADIProxyAnisetteProvider { + adi_proxy: ProxyType, +} + +impl ADIProxyAnisetteProvider { + /// If you use this method, you are expected to set the identifier yourself. + pub fn without_identifier( + adi_proxy: ProxyType, + ) -> Result, ADIError> { + Ok(ADIProxyAnisetteProvider { adi_proxy }) + } + + pub fn new( + mut adi_proxy: ProxyType, + configuration_path: PathBuf, + ) -> Result, ADIError> { + let identifier_file_path = configuration_path.join("identifier"); + let mut identifier_file = std::fs::OpenOptions::new() + .create(true) + .read(true) + .write(true) + .open(identifier_file_path)?; + let mut identifier = [0u8; IDENTIFIER_LENGTH]; + if identifier_file.metadata()?.len() == IDENTIFIER_LENGTH as u64 { + identifier_file.read_exact(&mut identifier)?; + } else { + rand::thread_rng().fill_bytes(&mut identifier); + identifier_file.write_all(&identifier)?; + } + + let mut local_user_uuid_hasher = Sha256::new(); + local_user_uuid_hasher.update(identifier); + + adi_proxy.set_device_identifier( + uuid::Uuid::from_bytes(identifier) + .to_string() + .to_uppercase(), + )?; // UUID, uppercase + adi_proxy + .set_local_user_uuid(hex::encode(local_user_uuid_hasher.finalize()).to_uppercase()); // 64 uppercase character hex + + Ok(ADIProxyAnisetteProvider { adi_proxy }) + } + + pub fn adi_proxy(&mut self) -> &mut ProxyType { + &mut self.adi_proxy + } +} + +#[cfg_attr(feature = "async", async_trait::async_trait)] +impl AnisetteHeadersProvider + for ADIProxyAnisetteProvider +{ + #[cfg_attr(not(feature = "async"), remove_async_await::remove_async_await)] + async fn get_anisette_headers( + &mut self, + skip_provisioning: bool, + ) -> Result, AnisetteError> { + let adi_proxy = &mut self.adi_proxy as &mut dyn ADIProxy; + + if !adi_proxy.is_machine_provisioned(DS_ID) && !skip_provisioning { + adi_proxy.provision_device().await?; + } + + let machine_data = adi_proxy.request_otp(DS_ID)?; + + let mut headers = HashMap::new(); + headers.insert( + "X-Apple-I-MD".to_string(), + base64_engine.encode(machine_data.otp), + ); + headers.insert( + "X-Apple-I-MD-M".to_string(), + base64_engine.encode(machine_data.mid), + ); + headers.insert("X-Apple-I-MD-RINFO".to_string(), "17106176".to_string()); + headers.insert( + "X-Apple-I-MD-LU".to_string(), + adi_proxy.get_local_user_uuid(), + ); + headers.insert( + "X-Apple-I-SRL-NO".to_string(), + adi_proxy.get_serial_number(), + ); + headers.insert( + "X-Mme-Client-Info".to_string(), + CLIENT_INFO_HEADER.to_string(), + ); + headers.insert( + "X-Mme-Device-Id".to_string(), + adi_proxy.get_device_identifier(), + ); + + Ok(headers) + } +} diff --git a/3rdparty/omnisette/src/anisette_headers_provider.rs b/3rdparty/omnisette/src/anisette_headers_provider.rs new file mode 100755 index 00000000..903203ea --- /dev/null +++ b/3rdparty/omnisette/src/anisette_headers_provider.rs @@ -0,0 +1,31 @@ + +use std::collections::HashMap; + +use crate::AnisetteError; + +#[cfg_attr(feature = "async", async_trait::async_trait)] +pub trait AnisetteHeadersProvider: Send + Sync { + #[cfg_attr(not(feature = "async"), remove_async_await::remove_async_await)] + async fn get_anisette_headers( + &mut self, + skip_provisioning: bool, + ) -> Result, AnisetteError>; + + #[cfg_attr(not(feature = "async"), remove_async_await::remove_async_await)] + async fn get_authentication_headers(&mut self) -> Result, AnisetteError> { + let headers = self.get_anisette_headers(false).await?; + Ok(self.normalize_headers(headers)) + } + + /// Normalizes headers to ensure that all the required headers are given. + fn normalize_headers( + &mut self, + mut headers: HashMap, + ) -> HashMap { + if let Some(client_info) = headers.remove("X-MMe-Client-Info") { + headers.insert("X-Mme-Client-Info".to_string(), client_info); + } + + headers + } +} diff --git a/3rdparty/omnisette/src/lib.rs b/3rdparty/omnisette/src/lib.rs new file mode 100755 index 00000000..4e6b1cea --- /dev/null +++ b/3rdparty/omnisette/src/lib.rs @@ -0,0 +1,211 @@ +//! A library to generate "anisette" data. Docs are coming soon. +//! +//! If you want an async API, enable the `async` feature. +//! +//! If you want remote anisette, make sure the `remote-anisette` feature is enabled. (it's currently on by default) + +use crate::adi_proxy::{ADIProxyAnisetteProvider, ConfigurableADIProxy}; +use crate::anisette_headers_provider::AnisetteHeadersProvider; +use adi_proxy::ADIError; +use std::io; +use std::path::PathBuf; +use thiserror::Error; + +pub mod adi_proxy; +pub mod anisette_headers_provider; +pub mod store_services_core; + +#[cfg(feature = "remote-anisette-v3")] +pub mod remote_anisette_v3; + +#[allow(dead_code)] +pub struct AnisetteHeaders; + +#[allow(dead_code)] +#[derive(Debug, Error)] +pub enum AnisetteError { + #[allow(dead_code)] + #[error("Unsupported device")] + UnsupportedDevice, + #[error("Invalid argument {0}")] + InvalidArgument(String), + #[error("Anisette not provisioned!")] + AnisetteNotProvisioned, + #[error("Plist serialization error {0}")] + PlistError(#[from] plist::Error), + #[error("Request Error {0}")] + ReqwestError(#[from] reqwest::Error), + #[cfg(feature = "remote-anisette-v3")] + #[error("Provisioning socket error {0}")] + WsError(#[from] tokio_tungstenite::tungstenite::error::Error), + #[cfg(feature = "remote-anisette-v3")] + #[error("JSON error {0}")] + SerdeError(#[from] serde_json::Error), + #[error("IO error {0}")] + IOError(#[from] io::Error), + #[error("ADI error {0}")] + ADIError(#[from] ADIError), + #[error("Invalid library format")] + InvalidLibraryFormat, + #[error("Misc")] + Misc, + #[error("Missing Libraries")] + MissingLibraries, + #[error("{0}")] + Anyhow(#[from] anyhow::Error), +} + +pub const DEFAULT_ANISETTE_URL: &str = "https://ani.f1sh.me/"; + +pub const DEFAULT_ANISETTE_URL_V3: &str = "https://ani.stikstore.app"; + +#[derive(Clone, Debug)] +pub struct AnisetteConfiguration { + anisette_url: String, + anisette_url_v3: String, + configuration_path: PathBuf, + macos_serial: String, +} + +impl Default for AnisetteConfiguration { + fn default() -> Self { + AnisetteConfiguration::new() + } +} + +impl AnisetteConfiguration { + pub fn new() -> AnisetteConfiguration { + AnisetteConfiguration { + anisette_url: DEFAULT_ANISETTE_URL.to_string(), + anisette_url_v3: DEFAULT_ANISETTE_URL_V3.to_string(), + configuration_path: PathBuf::new(), + macos_serial: "0".to_string(), + } + } + + pub fn anisette_url(&self) -> &String { + &self.anisette_url + } + + pub fn configuration_path(&self) -> &PathBuf { + &self.configuration_path + } + + pub fn set_anisette_url(mut self, anisette_url: String) -> AnisetteConfiguration { + self.anisette_url = anisette_url; + self + } + + pub fn set_macos_serial(mut self, macos_serial: String) -> AnisetteConfiguration { + self.macos_serial = macos_serial; + self + } + + pub fn set_configuration_path(mut self, configuration_path: PathBuf) -> AnisetteConfiguration { + self.configuration_path = configuration_path; + self + } +} + +pub enum AnisetteHeadersProviderType { + Local, + Remote, +} + +pub struct AnisetteHeadersProviderRes { + pub provider: Box, + pub provider_type: AnisetteHeadersProviderType, +} + +impl AnisetteHeadersProviderRes { + pub fn local(provider: Box) -> AnisetteHeadersProviderRes { + AnisetteHeadersProviderRes { + provider, + provider_type: AnisetteHeadersProviderType::Local, + } + } + + pub fn remote(provider: Box) -> AnisetteHeadersProviderRes { + AnisetteHeadersProviderRes { + provider, + provider_type: AnisetteHeadersProviderType::Remote, + } + } +} + +impl AnisetteHeaders { + pub fn get_anisette_headers_provider( + configuration: AnisetteConfiguration, + ) -> Result { + // TODO: handle Err because it will just go to remote anisette and not tell the user anything + if let Ok(ssc_anisette_headers_provider) = + AnisetteHeaders::get_ssc_anisette_headers_provider(configuration.clone()) + { + return Ok(ssc_anisette_headers_provider); + } + + #[cfg(feature = "remote-anisette-v3")] + return Ok(AnisetteHeadersProviderRes::remote(Box::new( + remote_anisette_v3::RemoteAnisetteProviderV3::new( + configuration.anisette_url_v3, + configuration.configuration_path.clone(), + configuration.macos_serial.clone(), + ), + ))); + } + + pub fn get_ssc_anisette_headers_provider( + configuration: AnisetteConfiguration, + ) -> Result { + let mut ssc_adi_proxy = store_services_core::StoreServicesCoreADIProxy::new( + configuration.configuration_path(), + )?; + let config_path = configuration.configuration_path(); + ssc_adi_proxy.set_provisioning_path(config_path.to_str().ok_or( + AnisetteError::InvalidArgument("configuration.configuration_path".to_string()), + )?)?; + Ok(AnisetteHeadersProviderRes::local(Box::new( + ADIProxyAnisetteProvider::new(ssc_adi_proxy, config_path.to_path_buf())?, + ))) + } +} + +#[cfg(test)] +mod tests { + use log::LevelFilter; + use simplelog::{ColorChoice, ConfigBuilder, TermLogger, TerminalMode}; + + pub fn init_logger() { + if TermLogger::init( + LevelFilter::Trace, + ConfigBuilder::new() + .set_target_level(LevelFilter::Error) + .add_filter_allow_str("omnisette") + .build(), + TerminalMode::Mixed, + ColorChoice::Auto, + ) + .is_ok() + {} + } + + #[cfg(not(feature = "async"))] + #[test] + fn fetch_anisette_auto() -> Result<()> { + use crate::{AnisetteConfiguration, AnisetteHeaders}; + use log::info; + use std::path::PathBuf; + + crate::tests::init_logger(); + + let mut provider = AnisetteHeaders::get_anisette_headers_provider( + AnisetteConfiguration::new() + .set_configuration_path(PathBuf::new().join("anisette_test")), + )?; + info!( + "Headers: {:?}", + provider.provider.get_authentication_headers()? + ); + Ok(()) + } +} diff --git a/3rdparty/omnisette/src/remote_anisette_v3.rs b/3rdparty/omnisette/src/remote_anisette_v3.rs new file mode 100755 index 00000000..4ecb95f6 --- /dev/null +++ b/3rdparty/omnisette/src/remote_anisette_v3.rs @@ -0,0 +1,542 @@ +// Implementing the SideStore Anisette v3 protocol + +use std::{collections::HashMap, fs, io::Cursor, path::PathBuf}; + +use async_trait::async_trait; +use base64::Engine; +use base64::engine::general_purpose; +use chrono::{DateTime, SubsecRound, Utc}; +use futures_util::{SinkExt, stream::StreamExt}; +use log::debug; +use plist::{Data, Dictionary}; +use reqwest::{Client, ClientBuilder, RequestBuilder}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use sha2::{Digest, Sha256}; +use std::fmt::Write; +use tokio_tungstenite::{connect_async, tungstenite::Message}; +use uuid::Uuid; + +use crate::{AnisetteError, anisette_headers_provider::AnisetteHeadersProvider}; + +fn plist_to_string(value: &T) -> Result { + plist_to_buf(value).map(|val| String::from_utf8(val).unwrap()) +} + +fn plist_to_buf(value: &T) -> Result, plist::Error> { + let mut buf: Vec = Vec::new(); + let writer = Cursor::new(&mut buf); + plist::to_writer_xml(writer, &value)?; + Ok(buf) +} + +fn bin_serialize(x: &[u8], s: S) -> Result +where + S: Serializer, +{ + s.serialize_bytes(x) +} + +fn bin_serialize_opt(x: &Option>, s: S) -> Result +where + S: Serializer, +{ + x.clone().map(|i| Data::new(i)).serialize(s) +} + +fn bin_deserialize_opt<'de, D>(d: D) -> Result>, D::Error> +where + D: Deserializer<'de>, +{ + let s: Option = Deserialize::deserialize(d)?; + Ok(s.map(|i| i.into())) +} + +fn bin_deserialize_16<'de, D>(d: D) -> Result<[u8; 16], D::Error> +where + D: Deserializer<'de>, +{ + let s: Data = Deserialize::deserialize(d)?; + let s: Vec = s.into(); + Ok(s.try_into().unwrap()) +} + +fn encode_hex(bytes: &[u8]) -> String { + let mut s = String::with_capacity(bytes.len() * 2); + for &b in bytes { + write!(&mut s, "{:02x}", b).unwrap(); + } + s +} +fn base64_encode(data: &[u8]) -> String { + general_purpose::STANDARD.encode(data) +} + +fn base64_decode(data: &str) -> Vec { + general_purpose::STANDARD.decode(data.trim()).unwrap() +} + +#[derive(Deserialize)] +struct AnisetteClientInfo { + client_info: String, + user_agent: String, +} + +#[derive(Serialize, Deserialize)] +pub struct AnisetteState { + #[serde( + serialize_with = "bin_serialize", + deserialize_with = "bin_deserialize_16" + )] + keychain_identifier: [u8; 16], + #[serde( + serialize_with = "bin_serialize_opt", + deserialize_with = "bin_deserialize_opt" + )] + adi_pb: Option>, +} + +impl Default for AnisetteState { + fn default() -> Self { + AnisetteState { + keychain_identifier: rand::random::<[u8; 16]>(), + adi_pb: None, + } + } +} + +impl AnisetteState { + pub fn new() -> AnisetteState { + AnisetteState::default() + } + + pub fn is_provisioned(&self) -> bool { + self.adi_pb.is_some() + } + + fn md_lu(&self) -> [u8; 32] { + let mut hasher = Sha256::new(); + hasher.update(&self.keychain_identifier); + hasher.finalize().into() + } + + fn device_id(&self) -> String { + Uuid::from_bytes(self.keychain_identifier).to_string() + } +} +pub struct AnisetteClient { + client_info: AnisetteClientInfo, + url: String, +} + +#[derive(Serialize)] +#[serde(rename_all = "PascalCase")] +struct ProvisionBodyData { + header: Dictionary, + request: Dictionary, +} + +#[derive(Debug)] +pub struct AnisetteData { + machine_id: String, + one_time_password: String, + routing_info: String, + device_description: String, + local_user_id: String, + device_unique_identifier: String, +} + +impl AnisetteData { + pub fn get_headers(&self, serial: String) -> HashMap { + let dt: DateTime = Utc::now().round_subsecs(0); + + HashMap::from_iter( + [ + ( + "X-Apple-I-Client-Time".to_string(), + dt.format("%+").to_string().replace("+00:00", "Z"), + ), + ("X-Apple-I-SRL-NO".to_string(), serial), + ("X-Apple-I-TimeZone".to_string(), "UTC".to_string()), + ("X-Apple-Locale".to_string(), "en_US".to_string()), + ("X-Apple-I-MD-RINFO".to_string(), self.routing_info.clone()), + ("X-Apple-I-MD-LU".to_string(), self.local_user_id.clone()), + ( + "X-Mme-Device-Id".to_string(), + self.device_unique_identifier.clone(), + ), + ("X-Apple-I-MD".to_string(), self.one_time_password.clone()), + ("X-Apple-I-MD-M".to_string(), self.machine_id.clone()), + ( + "X-Mme-Client-Info".to_string(), + self.device_description.clone(), + ), + ] + .into_iter(), + ) + } +} + +fn make_reqwest() -> Result { + Ok(ClientBuilder::new() + .http1_title_case_headers() + .danger_accept_invalid_certs(true) // TODO: pin the apple certificate + .build()?) +} + +impl AnisetteClient { + pub async fn new(url: String) -> Result { + let path = format!("{}/v3/client_info", url); + let http_client = make_reqwest()?; + let client_info = http_client + .get(path) + .send() + .await? + .json::() + .await?; + Ok(AnisetteClient { client_info, url }) + } + + fn build_apple_request( + &self, + state: &AnisetteState, + builder: RequestBuilder, + ) -> RequestBuilder { + let dt: DateTime = Utc::now().round_subsecs(0); + + builder + .header("X-Mme-Client-Info", &self.client_info.client_info) + .header("User-Agent", &self.client_info.user_agent) + .header("Content-Type", "text/x-xml-plist") + .header("X-Apple-I-MD-LU", encode_hex(&state.md_lu())) + .header("X-Mme-Device-Id", state.device_id()) + .header("X-Apple-I-Client-Time", dt.format("%+").to_string()) + .header("X-Apple-I-TimeZone", "UTC") + .header("X-Apple-Locale", "en_US") + } + + pub async fn get_headers(&self, state: &AnisetteState) -> Result { + let path = format!("{}/v3/get_headers", self.url); + let http_client = make_reqwest()?; + + #[derive(Serialize)] + struct GetHeadersBody { + identifier: String, + adi_pb: String, + } + let body = GetHeadersBody { + identifier: base64_encode(&state.keychain_identifier), + adi_pb: base64_encode( + state + .adi_pb + .as_ref() + .ok_or(AnisetteError::AnisetteNotProvisioned)?, + ), + }; + + #[derive(Deserialize)] + #[serde(tag = "result")] + enum AnisetteHeaders { + GetHeadersError { + message: String, + }, + Headers { + #[serde(rename = "X-Apple-I-MD-M")] + machine_id: String, + #[serde(rename = "X-Apple-I-MD")] + one_time_password: String, + #[serde(rename = "X-Apple-I-MD-RINFO")] + routing_info: String, + }, + } + + let headers = http_client + .post(path) + .json(&body) + .send() + .await? + .json::() + .await?; + match headers { + AnisetteHeaders::GetHeadersError { message } => { + if message.contains("-45061") { + Err(AnisetteError::AnisetteNotProvisioned) + } else { + panic!("Unknown error {}", message) + } + } + AnisetteHeaders::Headers { + machine_id, + one_time_password, + routing_info, + } => Ok(AnisetteData { + machine_id, + one_time_password, + routing_info, + device_description: self.client_info.client_info.clone(), + local_user_id: encode_hex(&state.md_lu()), + device_unique_identifier: state.device_id(), + }), + } + } + + pub async fn provision(&self, state: &mut AnisetteState) -> Result<(), AnisetteError> { + debug!("Provisioning Anisette"); + let http_client = make_reqwest()?; + let resp = self + .build_apple_request( + &state, + http_client.get("https://gsa.apple.com/grandslam/GsService2/lookup"), + ) + .send() + .await?; + let text = resp.text().await?; + + let protocol_val = plist::Value::from_reader(Cursor::new(text.as_str()))?; + let urls = protocol_val + .as_dictionary() + .unwrap() + .get("urls") + .unwrap() + .as_dictionary() + .unwrap(); + + let start_provisioning_url = urls + .get("midStartProvisioning") + .unwrap() + .as_string() + .unwrap(); + let end_provisioning_url = urls + .get("midFinishProvisioning") + .unwrap() + .as_string() + .unwrap(); + debug!( + "Got provisioning urls: {} and {}", + start_provisioning_url, end_provisioning_url + ); + + let provision_ws_url = + format!("{}/v3/provisioning_session", self.url).replace("https://", "wss://"); + let (mut connection, _) = connect_async(&provision_ws_url).await?; + + #[derive(Deserialize)] + #[serde(tag = "result")] + enum ProvisionInput { + GiveIdentifier, + GiveStartProvisioningData, + GiveEndProvisioningData { + #[allow(dead_code)] // it's not even dead, rust just has problems + cpim: String, + }, + ProvisioningSuccess { + #[allow(dead_code)] // it's not even dead, rust just has problems + adi_pb: String, + }, + } + + loop { + let Some(Ok(data)) = connection.next().await else { + continue; + }; + if data.is_text() { + let txt = data.to_text().unwrap(); + let msg: ProvisionInput = serde_json::from_str(txt)?; + match msg { + ProvisionInput::GiveIdentifier => { + #[derive(Serialize)] + struct Identifier { + identifier: String, // base64 + } + let identifier = Identifier { + identifier: base64_encode(&state.keychain_identifier), + }; + connection + .send(Message::Text(serde_json::to_string(&identifier)?.into())) + .await?; + } + ProvisionInput::GiveStartProvisioningData => { + let http_client = make_reqwest()?; + let body_data = ProvisionBodyData { + header: Dictionary::new(), + request: Dictionary::new(), + }; + let resp = self + .build_apple_request(state, http_client.post(start_provisioning_url)) + .body(plist_to_string(&body_data)?) + .send() + .await?; + let text = resp.text().await?; + + let protocol_val = plist::Value::from_reader(Cursor::new(text.as_str()))?; + let spim = protocol_val + .as_dictionary() + .unwrap() + .get("Response") + .unwrap() + .as_dictionary() + .unwrap() + .get("spim") + .unwrap() + .as_string() + .unwrap(); + + debug!("GiveStartProvisioningData"); + #[derive(Serialize)] + struct Spim { + spim: String, // base64 + } + let spim = Spim { + spim: spim.to_string(), + }; + connection + .send(Message::Text(serde_json::to_string(&spim)?.into())) + .await?; + } + ProvisionInput::GiveEndProvisioningData { cpim } => { + let http_client = make_reqwest()?; + let body_data = ProvisionBodyData { + header: Dictionary::new(), + request: Dictionary::from_iter([("cpim", cpim)].into_iter()), + }; + let resp = self + .build_apple_request(state, http_client.post(end_provisioning_url)) + .body(plist_to_string(&body_data)?) + .send() + .await?; + let text = resp.text().await?; + + let protocol_val = plist::Value::from_reader(Cursor::new(text.as_str()))?; + let response = protocol_val + .as_dictionary() + .unwrap() + .get("Response") + .unwrap() + .as_dictionary() + .unwrap(); + + debug!("GiveEndProvisioningData"); + + #[derive(Serialize)] + struct EndProvisioning<'t> { + ptm: &'t str, + tk: &'t str, + } + let end_provisioning = EndProvisioning { + ptm: response.get("ptm").unwrap().as_string().unwrap(), + tk: response.get("tk").unwrap().as_string().unwrap(), + }; + connection + .send(Message::Text( + serde_json::to_string(&end_provisioning)?.into(), + )) + .await?; + } + ProvisionInput::ProvisioningSuccess { adi_pb } => { + debug!("ProvisioningSuccess"); + state.adi_pb = Some(base64_decode(&adi_pb)); + connection.close(None).await?; + break; + } + } + } else if data.is_close() { + break; + } + } + + Ok(()) + } +} + +pub struct RemoteAnisetteProviderV3 { + client_url: String, + client: Option, + pub state: Option, + configuration_path: PathBuf, + serial: String, +} + +impl RemoteAnisetteProviderV3 { + pub fn new( + url: String, + configuration_path: PathBuf, + serial: String, + ) -> RemoteAnisetteProviderV3 { + RemoteAnisetteProviderV3 { + client_url: url, + client: None, + state: None, + configuration_path, + serial, + } + } +} + +#[async_trait] +impl AnisetteHeadersProvider for RemoteAnisetteProviderV3 { + async fn get_anisette_headers( + &mut self, + _skip_provisioning: bool, + ) -> Result, AnisetteError> { + if self.client.is_none() { + self.client = Some(AnisetteClient::new(self.client_url.clone()).await?); + } + let client = self.client.as_ref().unwrap(); + + fs::create_dir_all(&self.configuration_path)?; + + let config_path = self.configuration_path.join("state.plist"); + if self.state.is_none() { + self.state = Some(if let Ok(text) = plist::from_file(&config_path) { + text + } else { + AnisetteState::new() + }); + } + + let state = self.state.as_mut().unwrap(); + if !state.is_provisioned() { + client.provision(state).await?; + plist::to_file_xml(&config_path, state)?; + } + let data = match client.get_headers(&state).await { + Ok(data) => data, + Err(err) => { + if matches!(err, AnisetteError::AnisetteNotProvisioned) { + state.adi_pb = None; + client.provision(state).await?; + plist::to_file_xml(config_path, state)?; + client.get_headers(&state).await? + } else { + panic!() + } + } + }; + Ok(data.get_headers(self.serial.clone())) + } +} + +#[cfg(test)] +mod tests { + use crate::anisette_headers_provider::AnisetteHeadersProvider; + use crate::remote_anisette_v3::RemoteAnisetteProviderV3; + use crate::{AnisetteError, DEFAULT_ANISETTE_URL_V3}; + use log::info; + + #[tokio::test] + async fn fetch_anisette_remote_v3() -> Result<(), AnisetteError> { + crate::tests::init_logger(); + + let mut provider = RemoteAnisetteProviderV3::new( + DEFAULT_ANISETTE_URL_V3.to_string(), + "anisette_test".into(), + "0".to_string(), + ); + info!( + "Remote headers: {:?}", + (&mut provider as &mut dyn AnisetteHeadersProvider) + .get_authentication_headers() + .await? + ); + Ok(()) + } +} diff --git a/3rdparty/omnisette/src/store_services_core.rs b/3rdparty/omnisette/src/store_services_core.rs new file mode 100755 index 00000000..c988dbbd --- /dev/null +++ b/3rdparty/omnisette/src/store_services_core.rs @@ -0,0 +1,448 @@ +#[cfg(target_os = "macos")] +mod posix_macos; +#[cfg(target_family = "windows")] +mod posix_windows; + +use crate::AnisetteError; +use crate::adi_proxy::{ + ADIError, ADIProxy, ConfigurableADIProxy, RequestOTPData, StartProvisioningData, + SynchronizeData, +}; + +use android_loader::android_library::AndroidLibrary; +use android_loader::sysv64_type; +use android_loader::{hook_manager, sysv64}; +use std::collections::HashMap; +use std::ffi::{CString, c_char}; +use std::path::PathBuf; + +pub struct StoreServicesCoreADIProxy<'lt> { + #[allow(dead_code)] + store_services_core: AndroidLibrary<'lt>, + + local_user_uuid: String, + device_identifier: String, + + adi_set_android_id: sysv64_type!(fn(id: *const u8, length: u32) -> i32), + adi_set_provisioning_path: sysv64_type!(fn(path: *const u8) -> i32), + + adi_provisioning_erase: sysv64_type!(fn(ds_id: i64) -> i32), + adi_synchronize: sysv64_type!( + fn( + ds_id: i64, + sim: *const u8, + sim_length: u32, + out_mid: *mut *const u8, + out_mid_length: *mut u32, + out_srm: *mut *const u8, + out_srm_length: *mut u32, + ) -> i32 + ), + adi_provisioning_destroy: sysv64_type!(fn(session: u32) -> i32), + adi_provisioning_end: sysv64_type!( + fn(session: u32, ptm: *const u8, ptm_length: u32, tk: *const u8, tk_length: u32) -> i32 + ), + adi_provisioning_start: sysv64_type!( + fn( + ds_id: i64, + spim: *const u8, + spim_length: u32, + out_cpim: *mut *const u8, + out_cpim_length: *mut u32, + out_session: *mut u32, + ) -> i32 + ), + adi_get_login_code: sysv64_type!(fn(ds_id: i64) -> i32), + adi_dispose: sysv64_type!(fn(ptr: *const u8) -> i32), + adi_otp_request: sysv64_type!( + fn( + ds_id: i64, + out_mid: *mut *const u8, + out_mid_size: *mut u32, + out_otp: *mut *const u8, + out_otp_size: *mut u32, + ) -> i32 + ), +} + +impl StoreServicesCoreADIProxy<'_> { + pub fn new<'lt>( + library_path: &PathBuf, + ) -> Result, AnisetteError> { + Self::with_custom_provisioning_path(library_path, library_path) + } + + pub fn with_custom_provisioning_path<'lt>( + library_path: &PathBuf, + provisioning_path: &PathBuf, + ) -> Result, AnisetteError> { + // Should be safe if the library is correct. + unsafe { + LoaderHelpers::setup_hooks(); + + if !library_path.exists() { + std::fs::create_dir(library_path)?; + return Err(AnisetteError::MissingLibraries.into()); + } + + let library_path = library_path.canonicalize()?; + + #[cfg(target_arch = "x86_64")] + const ARCH: &str = "x86_64"; + #[cfg(target_arch = "x86")] + const ARCH: &str = "x86"; + #[cfg(target_arch = "arm")] + const ARCH: &str = "armeabi-v7a"; + #[cfg(target_arch = "aarch64")] + const ARCH: &str = "arm64-v8a"; + + let native_library_path = library_path.join("lib").join(ARCH); + + let path = native_library_path.join("libstoreservicescore.so"); + let path = path.to_str().ok_or(AnisetteError::Misc)?; + let store_services_core = AndroidLibrary::load(path)?; + + let adi_load_library_with_path: sysv64_type!(fn(path: *const u8) -> i32) = + std::mem::transmute( + store_services_core + .get_symbol("kq56gsgHG6") + .ok_or(AnisetteError::InvalidLibraryFormat)?, + ); + + let path = + CString::new(native_library_path.to_str().ok_or(AnisetteError::Misc)?).unwrap(); + assert_eq!((adi_load_library_with_path)(path.as_ptr() as *const u8), 0); + + let adi_set_android_id = store_services_core + .get_symbol("Sph98paBcz") + .ok_or(AnisetteError::InvalidLibraryFormat)?; + let adi_set_provisioning_path = store_services_core + .get_symbol("nf92ngaK92") + .ok_or(AnisetteError::InvalidLibraryFormat)?; + + let adi_provisioning_erase = store_services_core + .get_symbol("p435tmhbla") + .ok_or(AnisetteError::InvalidLibraryFormat)?; + let adi_synchronize = store_services_core + .get_symbol("tn46gtiuhw") + .ok_or(AnisetteError::InvalidLibraryFormat)?; + let adi_provisioning_destroy = store_services_core + .get_symbol("fy34trz2st") + .ok_or(AnisetteError::InvalidLibraryFormat)?; + let adi_provisioning_end = store_services_core + .get_symbol("uv5t6nhkui") + .ok_or(AnisetteError::InvalidLibraryFormat)?; + let adi_provisioning_start = store_services_core + .get_symbol("rsegvyrt87") + .ok_or(AnisetteError::InvalidLibraryFormat)?; + let adi_get_login_code = store_services_core + .get_symbol("aslgmuibau") + .ok_or(AnisetteError::InvalidLibraryFormat)?; + let adi_dispose = store_services_core + .get_symbol("jk24uiwqrg") + .ok_or(AnisetteError::InvalidLibraryFormat)?; + let adi_otp_request = store_services_core + .get_symbol("qi864985u0") + .ok_or(AnisetteError::InvalidLibraryFormat)?; + + let mut proxy = StoreServicesCoreADIProxy { + store_services_core, + + local_user_uuid: String::new(), + device_identifier: String::new(), + + adi_set_android_id: std::mem::transmute(adi_set_android_id), + adi_set_provisioning_path: std::mem::transmute(adi_set_provisioning_path), + + adi_provisioning_erase: std::mem::transmute(adi_provisioning_erase), + adi_synchronize: std::mem::transmute(adi_synchronize), + adi_provisioning_destroy: std::mem::transmute(adi_provisioning_destroy), + adi_provisioning_end: std::mem::transmute(adi_provisioning_end), + adi_provisioning_start: std::mem::transmute(adi_provisioning_start), + adi_get_login_code: std::mem::transmute(adi_get_login_code), + adi_dispose: std::mem::transmute(adi_dispose), + adi_otp_request: std::mem::transmute(adi_otp_request), + }; + + proxy.set_provisioning_path(provisioning_path.to_str().ok_or(AnisetteError::Misc)?)?; + + Ok(proxy) + } + } +} + +impl ADIProxy for StoreServicesCoreADIProxy<'_> { + fn erase_provisioning(&mut self, ds_id: i64) -> Result<(), ADIError> { + match (self.adi_provisioning_erase)(ds_id) { + 0 => Ok(()), + err => Err(ADIError::resolve(err)), + } + } + + fn synchronize(&mut self, ds_id: i64, sim: &[u8]) -> Result { + unsafe { + let sim_size = sim.len() as u32; + let sim_ptr = sim.as_ptr(); + + let mut mid_size: u32 = 0; + let mut mid_ptr: *const u8 = std::ptr::null(); + let mut srm_size: u32 = 0; + let mut srm_ptr: *const u8 = std::ptr::null(); + + match (self.adi_synchronize)( + ds_id, + sim_ptr, + sim_size, + &mut mid_ptr, + &mut mid_size, + &mut srm_ptr, + &mut srm_size, + ) { + 0 => { + let mut mid = vec![0; mid_size as usize]; + let mut srm = vec![0; srm_size as usize]; + + mid.copy_from_slice(std::slice::from_raw_parts(mid_ptr, mid_size as usize)); + srm.copy_from_slice(std::slice::from_raw_parts(srm_ptr, srm_size as usize)); + + (self.adi_dispose)(mid_ptr); + (self.adi_dispose)(srm_ptr); + + Ok(SynchronizeData { mid, srm }) + } + err => Err(ADIError::resolve(err)), + } + } + } + + fn destroy_provisioning_session(&mut self, session: u32) -> Result<(), ADIError> { + match (self.adi_provisioning_destroy)(session) { + 0 => Ok(()), + err => Err(ADIError::resolve(err)), + } + } + + fn end_provisioning(&mut self, session: u32, ptm: &[u8], tk: &[u8]) -> Result<(), ADIError> { + let ptm_size = ptm.len() as u32; + let ptm_ptr = ptm.as_ptr(); + + let tk_size = tk.len() as u32; + let tk_ptr = tk.as_ptr(); + + match (self.adi_provisioning_end)(session, ptm_ptr, ptm_size, tk_ptr, tk_size) { + 0 => Ok(()), + err => Err(ADIError::resolve(err)), + } + } + + fn start_provisioning( + &mut self, + ds_id: i64, + spim: &[u8], + ) -> Result { + unsafe { + let spim_size = spim.len() as u32; + let spim_ptr = spim.as_ptr(); + + let mut cpim_size: u32 = 0; + let mut cpim_ptr: *const u8 = std::ptr::null(); + + let mut session: u32 = 0; + + match (self.adi_provisioning_start)( + ds_id, + spim_ptr, + spim_size, + &mut cpim_ptr, + &mut cpim_size, + &mut session, + ) { + 0 => { + let mut cpim = vec![0; cpim_size as usize]; + + cpim.copy_from_slice(std::slice::from_raw_parts(cpim_ptr, cpim_size as usize)); + + (self.adi_dispose)(cpim_ptr); + + Ok(StartProvisioningData { cpim, session }) + } + err => Err(ADIError::resolve(err)), + } + } + } + + fn is_machine_provisioned(&self, ds_id: i64) -> bool { + (self.adi_get_login_code)(ds_id) == 0 + } + + fn request_otp(&self, ds_id: i64) -> Result { + unsafe { + let mut mid_size: u32 = 0; + let mut mid_ptr: *const u8 = std::ptr::null(); + let mut otp_size: u32 = 0; + let mut otp_ptr: *const u8 = std::ptr::null(); + + match (self.adi_otp_request)( + ds_id, + &mut mid_ptr, + &mut mid_size, + &mut otp_ptr, + &mut otp_size, + ) { + 0 => { + let mut mid = vec![0; mid_size as usize]; + let mut otp = vec![0; otp_size as usize]; + + mid.copy_from_slice(std::slice::from_raw_parts(mid_ptr, mid_size as usize)); + otp.copy_from_slice(std::slice::from_raw_parts(otp_ptr, otp_size as usize)); + + (self.adi_dispose)(mid_ptr); + (self.adi_dispose)(otp_ptr); + + Ok(RequestOTPData { mid, otp }) + } + err => Err(ADIError::resolve(err)), + } + } + } + + fn set_local_user_uuid(&mut self, local_user_uuid: String) { + self.local_user_uuid = local_user_uuid; + } + + fn set_device_identifier(&mut self, device_identifier: String) -> Result<(), ADIError> { + self.set_identifier(&device_identifier[0..16])?; + self.device_identifier = device_identifier; + Ok(()) + } + + fn get_local_user_uuid(&self) -> String { + self.local_user_uuid.clone() + } + + fn get_device_identifier(&self) -> String { + self.device_identifier.clone() + } + + fn get_serial_number(&self) -> String { + "0".to_string() + } +} + +impl ConfigurableADIProxy for StoreServicesCoreADIProxy<'_> { + fn set_identifier(&mut self, identifier: &str) -> Result<(), ADIError> { + match (self.adi_set_android_id)(identifier.as_ptr(), identifier.len() as u32) { + 0 => Ok(()), + err => Err(ADIError::resolve(err)), + } + } + + fn set_provisioning_path(&mut self, path: &str) -> Result<(), ADIError> { + let path = CString::new(path).unwrap(); + match (self.adi_set_provisioning_path)(path.as_ptr() as *const u8) { + 0 => Ok(()), + err => Err(ADIError::resolve(err)), + } + } +} + +struct LoaderHelpers; + +#[cfg(all(target_family = "unix", not(target_os = "macos")))] +use libc::{ + chmod, close, free, fstat, ftruncate, gettimeofday, lstat, malloc, mkdir, open, read, strncpy, + umask, write, +}; +#[cfg(target_os = "macos")] +use posix_macos::*; + +static mut ERRNO: i32 = 0; + +#[allow(unreachable_code)] +#[sysv64] +unsafe fn __errno_location() -> *mut i32 { + ERRNO = std::io::Error::last_os_error().raw_os_error().unwrap_or(0); + &mut ERRNO +} + +#[sysv64] +fn arc4random() -> u32 { + rand::random() +} + +#[sysv64] +unsafe fn __system_property_get(_name: *const c_char, value: *mut c_char) -> i32 { + *value = '0' as c_char; + return 1; +} + +#[cfg(target_family = "windows")] +use posix_windows::*; + +impl LoaderHelpers { + pub fn setup_hooks() { + let mut hooks = HashMap::new(); + hooks.insert("arc4random".to_owned(), arc4random as usize); + hooks.insert("chmod".to_owned(), chmod as usize); + hooks.insert( + "__system_property_get".to_owned(), + __system_property_get as usize, + ); + hooks.insert("__errno".to_owned(), __errno_location as usize); + hooks.insert("close".to_owned(), close as usize); + hooks.insert("free".to_owned(), free as usize); + hooks.insert("fstat".to_owned(), fstat as usize); + hooks.insert("ftruncate".to_owned(), ftruncate as usize); + hooks.insert("gettimeofday".to_owned(), gettimeofday as usize); + hooks.insert("lstat".to_owned(), lstat as usize); + hooks.insert("malloc".to_owned(), malloc as usize); + hooks.insert("mkdir".to_owned(), mkdir as usize); + hooks.insert("open".to_owned(), open as usize); + hooks.insert("read".to_owned(), read as usize); + hooks.insert("strncpy".to_owned(), strncpy as usize); + hooks.insert("umask".to_owned(), umask as usize); + hooks.insert("write".to_owned(), write as usize); + + hook_manager::add_hooks(hooks); + } +} + +#[cfg(test)] +mod tests { + use crate::AnisetteError; + use crate::{AnisetteConfiguration, AnisetteHeaders}; + use log::info; + use std::path::PathBuf; + + #[cfg(not(feature = "async"))] + #[test] + fn fetch_anisette_ssc() -> Result<(), AnisetteError> { + crate::tests::init_logger(); + + let mut provider = AnisetteHeaders::get_ssc_anisette_headers_provider( + AnisetteConfiguration::new() + .set_configuration_path(PathBuf::new().join("anisette_test")), + )?; + info!( + "Headers: {:?}", + provider.provider.get_authentication_headers()? + ); + Ok(()) + } + + #[cfg(feature = "async")] + #[tokio::test] + async fn fetch_anisette_ssc_async() -> Result<(), AnisetteError> { + crate::tests::init_logger(); + + let mut provider = AnisetteHeaders::get_ssc_anisette_headers_provider( + AnisetteConfiguration::new() + .set_configuration_path(PathBuf::new().join("anisette_test")), + )?; + info!( + "Headers: {:?}", + provider.provider.get_authentication_headers().await? + ); + Ok(()) + } +} diff --git a/3rdparty/omnisette/src/store_services_core/posix_macos.rs b/3rdparty/omnisette/src/store_services_core/posix_macos.rs new file mode 100755 index 00000000..840a0395 --- /dev/null +++ b/3rdparty/omnisette/src/store_services_core/posix_macos.rs @@ -0,0 +1,102 @@ +pub use libc::{chmod, close, free, ftruncate, gettimeofday, malloc, mkdir, read, strncpy, umask, write}; + +use libc::{lstat as lstat_macos, fstat as fstat_macos, stat as stat_macos, open as open_macos, O_CREAT, O_WRONLY, O_RDWR, O_RDONLY}; + +use android_loader::sysv64; + +#[repr(C)] +pub struct StatLinux { + pub st_dev: u64, + pub st_ino: u64, + pub st_nlink: u64, + pub st_mode: u32, + pub st_uid: u32, + pub st_gid: u32, + __pad0: libc::c_int, + pub st_rdev: u64, + pub st_size: i64, + pub st_blksize: i64, + pub st_blocks: i64, + pub st_atime: i64, + pub st_atime_nsec: i64, + pub st_mtime: i64, + pub st_mtime_nsec: i64, + pub st_ctime: i64, + pub st_ctime_nsec: i64, + __unused: [i64; 3], +} + +#[sysv64] +pub unsafe fn lstat(path: *const libc::c_char, buf: *mut StatLinux) -> libc::c_int { + let mut st: stat_macos = std::mem::zeroed(); + lstat_macos(path, &mut st); + *buf = StatLinux { + st_dev: st.st_dev as _, + st_ino: st.st_ino as _, + st_nlink: st.st_nlink as _, + st_mode: st.st_mode as _, + st_uid: st.st_uid as _, + st_gid: st.st_gid as _, + __pad0: 0 as _, + st_rdev: st.st_rdev as _, + st_size: st.st_size as _, + st_blksize: st.st_blksize as _, + st_blocks: st.st_blocks as _, + st_atime: st.st_atime as _, + st_atime_nsec: st.st_atime_nsec as _, + st_mtime: st.st_mtime as _, + st_mtime_nsec: st.st_mtime_nsec as _, + st_ctime: st.st_ctime as _, + st_ctime_nsec: st.st_ctime_nsec as _, + __unused: [0, 0, 0], + }; + 0 +} + +#[sysv64] +pub unsafe fn fstat(fildes: libc::c_int, buf: *mut StatLinux) -> libc::c_int { + let mut st: stat_macos = std::mem::zeroed(); + fstat_macos(fildes, &mut st); + *buf = StatLinux { + st_dev: st.st_dev as _, + st_ino: st.st_ino as _, + st_nlink: st.st_nlink as _, + st_mode: st.st_mode as _, + st_uid: st.st_uid as _, + st_gid: st.st_gid as _, + __pad0: 0 as _, + st_rdev: st.st_rdev as _, + st_size: st.st_size as _, + st_blksize: st.st_blksize as _, + st_blocks: st.st_blocks as _, + st_atime: st.st_atime as _, + st_atime_nsec: st.st_atime_nsec as _, + st_mtime: st.st_mtime as _, + st_mtime_nsec: st.st_mtime_nsec as _, + st_ctime: st.st_ctime as _, + st_ctime_nsec: st.st_ctime_nsec as _, + __unused: [0, 0, 0], + }; + 0 +} + +#[sysv64] +pub unsafe fn open(path: *const libc::c_char, oflag: libc::c_int) -> libc::c_int { + let mut win_flag = 0; // binary mode + + if oflag & 0o100 != 0 { + win_flag |= O_CREAT; + } + + if oflag & 0o1 == 1 { + win_flag |= O_WRONLY; + } else if oflag & 0o2 != 0 { + win_flag |= O_RDWR; + } else { + win_flag |= O_RDONLY; + } + + let val = open_macos(path, win_flag); + + val +} diff --git a/3rdparty/omnisette/src/store_services_core/posix_windows.rs b/3rdparty/omnisette/src/store_services_core/posix_windows.rs new file mode 100755 index 00000000..e6912d1e --- /dev/null +++ b/3rdparty/omnisette/src/store_services_core/posix_windows.rs @@ -0,0 +1,268 @@ +use android_loader::sysv64; +use libc::{O_CREAT, O_RDONLY, O_RDWR, O_WRONLY}; +use log::debug; +use std::ffi::{CStr, CString}; +use std::mem::MaybeUninit; + +#[link(name = "ucrt")] +unsafe extern "C" { + fn _errno() -> *mut libc::c_int; + fn _timespec64_get(__ts: *mut libc::timespec, __base: libc::c_int) -> libc::c_int; + fn _chsize(handle: i64, length: u64) -> usize; +} + +// took from cosmopolitan libc +#[sysv64] +pub unsafe fn umask(mask: usize) -> usize { + debug!("umask: Windows specific implementation called!"); + mask +} + +#[sysv64] +pub unsafe fn ftruncate(handle: i64, length: u64) -> usize { + debug!( + "ftruncate: Windows translate-call. handle: {}, length: {}", + handle, length + ); + let ftr = _chsize(handle, length); + + ftr +} + +#[repr(C)] +pub struct PosixTimeval { + tv_sec: u64, + tv_usec: u64, /* microseconds */ +} + +#[repr(C)] +pub struct PosixTimespec { + tv_sec: i64, + tv_nsec: i64, /* microseconds */ +} + +#[repr(C)] +pub struct PosixTimezone { + tz_minuteswest: u32, + tz_dsttime: u32, /* microseconds */ +} + +static HECTONANOSECONDS: u64 = 10000000; + +impl PosixTimespec { + pub fn from_windows_time(time: u64) -> PosixTimespec { + PosixTimespec { + tv_sec: (time / HECTONANOSECONDS) as i64, + tv_nsec: (time % HECTONANOSECONDS) as i64 * 100, + } + } +} + +#[sysv64] +pub unsafe fn gettimeofday(timeval: *mut PosixTimeval, _tz: *mut PosixTimezone) -> isize { + debug!("gettimeofday: Windows specific implementation called!"); + let mut ts = MaybeUninit::::zeroed(); + + let ret = _timespec64_get(ts.as_mut_ptr(), 1); + let ts = ts.assume_init(); + + *timeval = PosixTimeval { + tv_sec: ts.tv_sec as _, + tv_usec: (ts.tv_nsec / 1000) as _, + }; + + ret as _ +} + +#[repr(C)] +pub struct StatLinux { + pub st_dev: u64, + pub st_ino: u64, + pub st_nlink: u64, + pub st_mode: u32, + pub st_uid: u32, + pub st_gid: u32, + __pad0: libc::c_int, + pub st_rdev: u64, + pub st_size: i64, + pub st_blksize: i64, + pub st_blocks: i64, + pub st_atime: i64, + pub st_atime_nsec: i64, + pub st_mtime: i64, + pub st_mtime_nsec: i64, + pub st_ctime: i64, + pub st_ctime_nsec: i64, + __unused: [i64; 3], +} + +trait ToWindows { + unsafe fn to_windows(&self) -> T; +} + +impl ToWindows for CStr { + unsafe fn to_windows(&self) -> CString { + let path = self + .to_str() + .unwrap() + .to_string() + .chars() + .map(|x| match x { + '/' => '\\', + c => c, + }) + .collect::(); + + let path = path.trim_start_matches("\\\\?\\").to_string(); + + CString::new(path).unwrap() + } +} + +#[sysv64] +pub unsafe fn lstat(path: *const libc::c_char, buf: *mut StatLinux) -> libc::c_int { + debug!( + "lstat: Windows translate-call, path: {:?}", + CStr::from_ptr(path) + ); + let mut stat_win = MaybeUninit::::zeroed(); + let path = CStr::from_ptr(path).to_windows(); + + let ret = libc::stat(path.as_ptr(), stat_win.as_mut_ptr()); + let stat_win = stat_win.assume_init(); + + *buf = stat_win.to_windows(); + + ret +} + +impl ToWindows for libc::stat { + unsafe fn to_windows(&self) -> StatLinux { + let atime = PosixTimespec::from_windows_time(self.st_atime as u64); + let mtime = PosixTimespec::from_windows_time(self.st_mtime as u64); + let ctime = PosixTimespec::from_windows_time(self.st_ctime as u64); + + let mut mode = 0o555; + let win_mode = self.st_mode; + + if win_mode & 0b11 != 0 { + mode |= 0o200; + } + + if win_mode & 0x4000 != 0 { + mode |= 0o40000; + } + + StatLinux { + st_dev: self.st_dev as _, + st_ino: self.st_ino as _, + st_nlink: self.st_nlink as _, + st_mode: mode as _, + st_uid: self.st_uid as _, + st_gid: self.st_gid as _, + __pad0: 0, + st_rdev: self.st_rdev as _, + st_size: self.st_size as _, + st_blksize: 0, + st_blocks: 0, + st_atime: atime.tv_sec, + st_atime_nsec: 0, + st_mtime: mtime.tv_sec, + st_mtime_nsec: 0, + st_ctime: ctime.tv_sec, + st_ctime_nsec: 0, + __unused: [0, 0, 0], + } + } +} + +#[sysv64] +pub unsafe fn fstat(fildes: libc::c_int, buf: *mut StatLinux) -> libc::c_int { + debug!("fstat: Windows translate-call"); + let mut stat_win = MaybeUninit::::zeroed(); + let ret = libc::fstat(fildes, stat_win.as_mut_ptr()); + let stat_win = stat_win.assume_init(); + + *buf = stat_win.to_windows(); + + ret +} + +#[sysv64] +pub unsafe fn malloc(size: libc::size_t) -> *mut libc::c_void { + // debug!("malloc: Windows translate-call"); + libc::malloc(size) +} + +#[sysv64] +pub unsafe fn free(p: *mut libc::c_void) { + // debug!("free: Windows translate-call"); + libc::free(p) +} + +#[sysv64] +pub unsafe fn strncpy( + dst: *mut libc::c_char, + src: *const libc::c_char, + n: libc::size_t, +) -> *mut libc::c_char { + debug!("strncpy: Windows translate-call"); + libc::strncpy(dst, src, n) +} + +#[sysv64] +pub unsafe fn chmod(path: *const libc::c_char, mode: libc::c_int) -> libc::c_int { + debug!("chmod: Windows translate-call"); + libc::chmod(path, mode) +} + +#[sysv64] +pub unsafe fn mkdir(path: *const libc::c_char) -> libc::c_int { + debug!("mkdir: Windows translate-call"); + libc::mkdir(path) +} + +#[sysv64] +pub unsafe fn open(path: *const libc::c_char, oflag: libc::c_int) -> libc::c_int { + debug!("open: Windows translate-call oflag 0o{:o}", oflag); + + let path = CStr::from_ptr(path).to_windows(); + + let mut win_flag = 0x8000; // binary mode + + if oflag & 0o100 != 0 { + win_flag |= O_CREAT; + } + + if oflag & 0o1 == 1 { + win_flag |= O_WRONLY; + } else if oflag & 0o2 != 0 { + win_flag |= O_RDWR; + } else { + win_flag |= O_RDONLY; + } + + let val = libc::open(path.as_ptr(), win_flag); + + val +} + +#[sysv64] +pub unsafe fn close(fd: libc::c_int) -> libc::c_int { + debug!("close: Windows translate-call"); + libc::close(fd) +} + +#[sysv64] +pub unsafe fn read(fd: libc::c_int, buf: *mut libc::c_void, count: libc::c_uint) -> libc::c_int { + debug!("read: Windows translate-call"); + + let r = libc::read(fd, buf, count); + r +} + +#[sysv64] +pub unsafe fn write(fd: libc::c_int, buf: *const libc::c_void, count: libc::c_uint) -> libc::c_int { + debug!("write: Windows translate-call"); + libc::write(fd, buf, count) +} diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1aed4471..44811f5b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -16,14 +16,15 @@ Impactor is a sideloading app meant to be used on stock versions, to keep compat The project is seperated in multiple modules, all serve single or multiple uses depending on their importance. -| Module | Description | -| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------- | -| `apps/plumeimpactor` | GUI interface for the crates shown below, backend using Iced. | -| `apps/plumesign` | Simple CLI interface for signing, using `clap`. | -| `crates/plume_core`. | Handles all api request used for communicating with Apple developer services, along with providing auth for Apple's grandslam | -| `crates/plume_gestalt` | Wrapper for `libMobileGestalt.dylib`, used for obtaining your Mac's UDID for Apple Silicon sideloading. | -| `crates/plume_utils` | Shared code between GUI and CLI, contains signing and modification logic, and helpers. | -| `crates/plume_shared` | Shared code between GUI and CLI, contains keychain functionality and shared datapaths. | +| Module | Description | +| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | +| `apps/plumeimpactor` | GUI interface for the crates shown below, backend using Iced. | +| `apps/plumesign` | Simple CLI interface for signing, using `clap`. | +| `crates/plume_compression`. | Handles compression logic, copied and modified from https://github.com/rusty-ferris-club/decompress. | +| `crates/plume_core`. | Handles all api request used for communicating with Apple developer services, along with providing auth for Apple's grandslam. | +| `crates/plume_gestalt` | Wrapper for `libMobileGestalt.dylib`, used for obtaining your Mac's UDID for Apple Silicon sideloading. | +| `crates/plume_utils` | Shared code between GUI and CLI, contains signing and modification logic, and helpers. | +| `crates/plume_shared` | Shared code between GUI and CLI, contains keychain functionality and shared datapaths. | ### Building diff --git a/Cargo.lock b/Cargo.lock index 6449c1c9..b34f6624 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -18,15 +18,6 @@ version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618" -[[package]] -name = "addr2line" -version = "0.24.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1" -dependencies = [ - "gimli", -] - [[package]] name = "adler2" version = "2.0.1" @@ -39,7 +30,7 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" dependencies = [ - "crypto-common 0.1.6", + "crypto-common 0.1.7", "generic-array", ] @@ -49,7 +40,7 @@ version = "0.6.0-rc.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6b657e772794c6b04730ea897b66a058ccd866c16d1967da05eeeecec39043fe" dependencies = [ - "crypto-common 0.2.0", + "crypto-common 0.2.1", "inout 0.2.2", ] @@ -66,13 +57,13 @@ dependencies = [ [[package]] name = "aes" -version = "0.9.0-rc.4" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "04097e08a47d9ad181c2e1f4a5fabc9ae06ce8839a333ba9a949bcb0d31fd2a3" +checksum = "66bd29a732b644c0431c6140f370d097879203d79b80c94a6747ba0872adaef8" dependencies = [ - "cipher 0.5.0", + "cipher 0.5.1", "cpubits", - "cpufeatures 0.2.17", + "cpufeatures 0.3.0", ] [[package]] @@ -82,8 +73,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e22c0c90bbe8d4f77c3ca9ddabe41a1f8382d6fc1f7cea89459d0f320371f972" dependencies = [ "aead 0.6.0-rc.10", - "aes 0.9.0-rc.4", - "cipher 0.5.0", + "aes 0.9.0", + "cipher 0.5.1", "ctr", "ghash", "subtle", @@ -96,7 +87,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" dependencies = [ "cfg-if", - "getrandom 0.3.3", + "getrandom 0.3.4", "once_cell", "version_check", "zerocopy", @@ -104,32 +95,30 @@ dependencies = [ [[package]] name = "aho-corasick" -version = "1.1.3" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" dependencies = [ "memchr", ] [[package]] name = "android-activity" -version = "0.6.0" +version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef6978589202a00cd7e118380c448a08b6ed394c3a8df3a430d0898e3a42d046" +checksum = "0f2a1bb052857d5dd49572219344a7332b31b76405648eabac5bc68978251bcd" dependencies = [ "android-properties", - "bitflags 2.9.4", + "bitflags 2.11.1", "cc", - "cesu8", "jni", - "jni-sys", "libc", "log", "ndk", "ndk-context", "ndk-sys", "num_enum", - "thiserror 1.0.69", + "thiserror 2.0.18", ] [[package]] @@ -151,7 +140,7 @@ dependencies = [ "libc", "log", "memmap2 0.5.10", - "rand 0.8.5", + "rand 0.8.6", "region", "sysv64", "xmas-elf", @@ -175,9 +164,9 @@ dependencies = [ [[package]] name = "anstream" -version = "0.6.20" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192" +checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d" dependencies = [ "anstyle", "anstyle-parse", @@ -190,44 +179,44 @@ dependencies = [ [[package]] name = "anstyle" -version = "1.0.11" +version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" [[package]] name = "anstyle-parse" -version = "0.2.7" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2" +checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e" dependencies = [ "utf8parse", ] [[package]] name = "anstyle-query" -version = "1.1.4" +version = "1.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2" +checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc" dependencies = [ - "windows-sys 0.60.2", + "windows-sys 0.61.2", ] [[package]] name = "anstyle-wincon" -version = "3.0.10" +version = "3.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a" +checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d" dependencies = [ "anstyle", "once_cell_polyfill", - "windows-sys 0.60.2", + "windows-sys 0.61.2", ] [[package]] name = "anyhow" -version = "1.0.100" +version = "1.0.102" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61" +checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" [[package]] name = "apple-bundles" @@ -251,7 +240,7 @@ dependencies = [ "apple-xar", "base64 0.22.1", "bcder", - "bitflags 2.9.4", + "bitflags 2.11.1", "bytes", "chrono", "clap", @@ -281,11 +270,11 @@ dependencies = [ "pkcs1", "pkcs8", "plist", - "rand 0.8.5", + "rand 0.8.6", "rasn", "rayon", "regex", - "reqwest 0.12.23", + "reqwest 0.12.28", "ring", "rsa", "scroll", @@ -302,7 +291,7 @@ dependencies = [ "spki", "subtle", "tempfile", - "thiserror 2.0.17", + "thiserror 2.0.18", "tokio", "tungstenite 0.24.0", "uuid", @@ -329,7 +318,7 @@ dependencies = [ "scroll", "serde", "serde-xml-rs", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -339,22 +328,22 @@ source = "git+https://github.com/PlumeImpactor/plume-apple-platform-rs?rev=428b4 dependencies = [ "base64 0.22.1", "bcder", - "bzip2", + "bzip2 0.4.4", "chrono", "cryptographic-message-syntax", "digest 0.10.7", "flate2", "log", "md-5", - "rand 0.8.5", - "reqwest 0.12.23", + "rand 0.8.6", + "reqwest 0.12.28", "scroll", "serde", "serde-xml-rs", - "sha1", + "sha1 0.10.6", "sha2 0.10.9", "signature", - "thiserror 2.0.17", + "thiserror 2.0.18", "url", "x509-certificate", "xml-rs", @@ -409,21 +398,21 @@ version = "0.38.0+1.3.281" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f" dependencies = [ - "libloading 0.8.8", + "libloading 0.8.9", ] [[package]] name = "ashpd" -version = "0.11.0" +version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6cbdf310d77fd3aaee6ea2093db7011dc2d35d2eb3481e5607f1f8d942ed99df" +checksum = "d2f3f79755c74fd155000314eb349864caa787c6592eace6c6882dad873d9c39" dependencies = [ "async-fs", "async-net", "enumflags2", "futures-channel", "futures-util", - "rand 0.9.2", + "rand 0.9.4", "raw-window-handle", "serde", "serde_repr", @@ -461,7 +450,7 @@ dependencies = [ "nom", "num-traits", "rusticata-macros", - "thiserror 2.0.17", + "thiserror 2.0.18", "time", ] @@ -473,7 +462,7 @@ checksum = "965c2d33e53cb6b267e148a4cb0760bc01f4904c1cd4bb4002a085bb016d1490" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", "synstructure", ] @@ -485,7 +474,7 @@ checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", "synstructure", ] @@ -497,7 +486,7 @@ checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -526,13 +515,12 @@ dependencies = [ [[package]] name = "async-compression" -version = "0.4.32" +version = "0.4.42" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a89bce6054c720275ac2432fbba080a66a2106a44a1b804553930ca6909f4e0" +checksum = "e79b3f8a79cccc2898f31920fc69f304859b3bd567490f75ebf51ae1c792a9ac" dependencies = [ "compression-codecs", "compression-core", - "futures-core", "futures-io", "pin-project-lite", "tokio", @@ -540,9 +528,9 @@ dependencies = [ [[package]] name = "async-executor" -version = "1.13.3" +version = "1.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "497c00e0fd83a72a79a39fcbd8e3e2f055d6f6c7e025f3b3d91f4f8e76527fb8" +checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a" dependencies = [ "async-task", "concurrent-queue", @@ -576,7 +564,7 @@ dependencies = [ "futures-lite", "parking", "polling", - "rustix 1.1.2", + "rustix 1.1.4", "slab", "windows-sys 0.61.2", ] @@ -618,7 +606,7 @@ dependencies = [ "cfg-if", "event-listener", "futures-lite", - "rustix 1.1.2", + "rustix 1.1.4", ] [[package]] @@ -629,14 +617,14 @@ checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "async-signal" -version = "0.2.13" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43c070bbf59cd3570b6b2dd54cd772527c7c3620fce8be898406dd3ed6adc64c" +checksum = "52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485" dependencies = [ "async-io", "async-lock", @@ -644,7 +632,7 @@ dependencies = [ "cfg-if", "futures-core", "futures-io", - "rustix 1.1.2", + "rustix 1.1.4", "signal-hook-registry", "slab", "windows-sys 0.61.2", @@ -669,7 +657,7 @@ checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -686,7 +674,7 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -699,7 +687,7 @@ dependencies = [ "crc32fast", "futures-lite", "pin-project", - "thiserror 2.0.17", + "thiserror 2.0.18", "tokio", "tokio-util", ] @@ -749,8 +737,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "aa871af263fe9f0150d234d1e265a1117e0348ff6409ffcced0d387bdf087ac9" dependencies = [ "dirs 6.0.0", - "thiserror 2.0.17", - "windows-registry", + "thiserror 2.0.18", + "windows-registry 0.5.3", "windows-result 0.3.4", ] @@ -762,9 +750,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" [[package]] name = "aws-lc-rs" -version = "1.16.2" +version = "1.16.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc" +checksum = "0ec6fb3fe69024a75fa7e1bfb48aa6cf59706a101658ea01bfd33b2b248a038f" dependencies = [ "aws-lc-sys", "zeroize", @@ -772,9 +760,9 @@ dependencies = [ [[package]] name = "aws-lc-sys" -version = "0.39.1" +version = "0.40.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83a25cf98105baa966497416dbd42565ce3a8cf8dbfd59803ec9ad46f3126399" +checksum = "f50037ee5e1e41e7b8f9d161680a725bd1626cb6f8c7e901f91f942850852fe7" dependencies = [ "cc", "cmake", @@ -782,21 +770,6 @@ dependencies = [ "fs_extra", ] -[[package]] -name = "backtrace" -version = "0.3.75" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002" -dependencies = [ - "addr2line", - "cfg-if", - "libc", - "miniz_oxide", - "object", - "rustc-demangle", - "windows-targets 0.52.6", -] - [[package]] name = "base16ct" version = "0.2.0" @@ -829,9 +802,9 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" [[package]] name = "base64ct" -version = "1.8.0" +version = "1.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55248b47b0caf0546f7988906588779981c43bb1bc9d0c44087278f80cdb44ba" +checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" [[package]] name = "bcder" @@ -866,11 +839,11 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.9.4" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" dependencies = [ - "serde", + "serde_core", ] [[package]] @@ -912,11 +885,12 @@ dependencies = [ [[package]] name = "block-buffer" -version = "0.11.0" +version = "0.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96eb4cdd6cf1b31d671e9efe75c5d1ec614776856cefbe109ca373554a6d514f" +checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be" dependencies = [ "hybrid-array", + "zeroize", ] [[package]] @@ -952,7 +926,7 @@ version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5" dependencies = [ - "objc2 0.6.3", + "objc2 0.6.4", ] [[package]] @@ -980,15 +954,15 @@ dependencies = [ [[package]] name = "bumpalo" -version = "3.19.0" +version = "3.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" +checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" [[package]] name = "bytemuck" -version = "1.24.0" +version = "1.25.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4" +checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec" dependencies = [ "bytemuck_derive", ] @@ -1001,7 +975,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -1018,9 +992,9 @@ checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495" [[package]] name = "bytes" -version = "1.10.1" +version = "1.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" [[package]] name = "bytesize" @@ -1038,6 +1012,15 @@ dependencies = [ "libc", ] +[[package]] +name = "bzip2" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c" +dependencies = [ + "libbz2-rs-sys", +] + [[package]] name = "bzip2-sys" version = "0.1.13+1.0.8" @@ -1054,7 +1037,7 @@ version = "0.18.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ca26ef0159422fb77631dc9d17b102f253b876fe1586b03b803e63a309b4ee2" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "cairo-sys-rs", "glib", "libc", @@ -1079,7 +1062,7 @@ version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b99da2f8558ca23c71f4fd15dc57c906239752dd27ff3c00a1d56b685b7cbfec" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "log", "polling", "rustix 0.38.44", @@ -1089,13 +1072,13 @@ dependencies = [ [[package]] name = "calloop" -version = "0.14.3" +version = "0.14.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb9f6e1368bd4621d2c86baa7e37de77a938adf5221e5dd3d6133340101b309e" +checksum = "4dbf9978365bac10f54d1d4b04f7ce4427e51f71d61f2fe15e3fed5166474df7" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "polling", - "rustix 1.1.2", + "rustix 1.1.4", "slab", "tracing", ] @@ -1118,8 +1101,8 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "138efcf0940a02ebf0cc8d1eff41a1682a46b431630f4c52450d6265876021fa" dependencies = [ - "calloop 0.14.3", - "rustix 1.1.2", + "calloop 0.14.4", + "rustix 1.1.4", "wayland-backend", "wayland-client", ] @@ -1135,18 +1118,18 @@ dependencies = [ [[package]] name = "cbc" -version = "0.2.0-rc.3" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85742c5f1d0dda799d2e582c76b82b817d3e4d6434dd285e48e90ed0c963b667" +checksum = "98db6aeaef0eeef2c1e3ce9a27b739218825dae116076352ac3777076aa22225" dependencies = [ - "cipher 0.5.0", + "cipher 0.5.1", ] [[package]] name = "cc" -version = "1.2.38" +version = "1.2.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "80f41ae168f955c12fb8960b057d70d0ca153fb83182b57d86380443527be7e9" +checksum = "d16d90359e986641506914ba71350897565610e87ce0ad9e6f28569db3dd5c6d" dependencies = [ "find-msvc-tools", "jobserver", @@ -1154,12 +1137,6 @@ dependencies = [ "shlex", ] -[[package]] -name = "cesu8" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" - [[package]] name = "cfb" version = "0.7.3" @@ -1183,9 +1160,9 @@ dependencies = [ [[package]] name = "cfg-if" -version = "1.0.3" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" [[package]] name = "cfg_aliases" @@ -1212,7 +1189,7 @@ checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601" dependencies = [ "cfg-if", "cpufeatures 0.3.0", - "rand_core 0.10.0", + "rand_core 0.10.1", ] [[package]] @@ -1230,9 +1207,9 @@ dependencies = [ [[package]] name = "chrono" -version = "0.4.42" +version = "0.4.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2" +checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0" dependencies = [ "iana-time-zone", "js-sys", @@ -1248,27 +1225,27 @@ version = "0.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" dependencies = [ - "crypto-common 0.1.6", + "crypto-common 0.1.7", "inout 0.1.4", "zeroize", ] [[package]] name = "cipher" -version = "0.5.0" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64727038c8c5e2bb503a15b9f5b9df50a1da9a33e83e1f93067d914f2c6604a5" +checksum = "e34d8227fe1ba289043aeb13792056ff80fd6de1a9f49137a5f499de8e8c78ea" dependencies = [ - "block-buffer 0.11.0", - "crypto-common 0.2.0", + "block-buffer 0.12.0", + "crypto-common 0.2.1", "inout 0.2.2", ] [[package]] name = "clap" -version = "4.5.49" +version = "4.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4512b90fa68d3a9932cea5184017c5d200f5921df706d45e853537dea51508f" +checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51" dependencies = [ "clap_builder", "clap_derive", @@ -1276,33 +1253,33 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.49" +version = "4.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0025e98baa12e766c67ba13ff4695a887a1eba19569aad00a472546795bd6730" +checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f" dependencies = [ "anstream", "anstyle", "clap_lex", - "strsim 0.11.1", + "strsim", ] [[package]] name = "clap_derive" -version = "4.5.49" +version = "4.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671" +checksum = "f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9" dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "clap_lex" -version = "0.7.6" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d" +checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9" [[package]] name = "clipboard-win" @@ -1339,24 +1316,24 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bd63e33452ffdafd39924c4f05a5dd1e94db646c779c6bd59148a3d95fff5ad4" dependencies = [ - "thiserror 2.0.17", + "thiserror 2.0.18", "x11rb", ] [[package]] name = "cmake" -version = "0.1.54" +version = "0.1.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7caa3f9de89ddbe2c607f4101924c5abec803763ae9534e4f4d7d8f84aa81f0" +checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678" dependencies = [ "cc", ] [[package]] name = "cmov" -version = "0.5.2" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "de0758edba32d61d1fd9f4d69491b47604b91ee2f7e6b33de7e54ca4ebe55dc3" +checksum = "3f88a43d011fc4a6876cb7344703e297c71dda42494fee094d5f7c76bf13f746" [[package]] name = "cms" @@ -1383,9 +1360,9 @@ dependencies = [ [[package]] name = "colorchoice" -version = "1.0.4" +version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" +checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" [[package]] name = "combine" @@ -1399,9 +1376,9 @@ dependencies = [ [[package]] name = "compression-codecs" -version = "0.4.31" +version = "0.4.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef8a506ec4b81c460798f572caead636d57d3d7e940f998160f52bd254bf2d23" +checksum = "ce2548391e9c1929c21bf6aa2680af86fe4c1b33e6cea9ac1cfeec0bd11218cf" dependencies = [ "compression-core", "flate2", @@ -1410,9 +1387,9 @@ dependencies = [ [[package]] name = "compression-core" -version = "0.4.29" +version = "0.4.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e47641d3deaf41fb1538ac1f54735925e275eaf3bf4d55c81b137fba797e5cbb" +checksum = "cc14f565cf027a105f7a44ccf9e5b424348421a1d8952a8fc9d499d313107789" [[package]] name = "concurrent-queue" @@ -1438,13 +1415,12 @@ dependencies = [ [[package]] name = "console" -version = "0.16.1" +version = "0.16.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b430743a6eb14e9764d4260d4c0d8123087d504eeb9c48f2b2a5e810dd369df4" +checksum = "d64e8af5551369d19cf50138de61f1c42074ab970f74e99be916646777f8fc87" dependencies = [ "encode_unicode", "libc", - "once_cell", "unicode-width", "windows-sys 0.61.2", ] @@ -1472,9 +1448,9 @@ dependencies = [ [[package]] name = "constant_time_eq" -version = "0.1.5" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" +checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" [[package]] name = "cookie-factory" @@ -1541,7 +1517,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "core-foundation 0.10.1", "libc", ] @@ -1561,7 +1537,7 @@ version = "0.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "173852283a9a57a3cbe365d86e74dc428a09c50421477d5ad6fe9d9509e37737" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "fontdb", "harfrust", "linebender_resource_handle", @@ -1569,7 +1545,7 @@ dependencies = [ "rangemap", "rustc-hash 1.1.0", "self_cell", - "skrifa", + "skrifa 0.37.0", "smol_str", "swash", "sys-locale", @@ -1587,14 +1563,14 @@ dependencies = [ "chrono", "is_executable", "simple-file-manifest", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] name = "cpubits" -version = "0.1.0" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ef0c543070d296ea414df2dd7625d1b24866ce206709d8a4a424f28377f5861" +checksum = "15b85f9c39137c3a891689859392b1bd49812121d0d61c9caf00d46ed5ce06ae" [[package]] name = "cpufeatures" @@ -1625,9 +1601,9 @@ dependencies = [ [[package]] name = "crc-catalog" -version = "2.4.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5" +checksum = "217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853" [[package]] name = "crc32fast" @@ -1683,13 +1659,14 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" [[package]] name = "crossfire" -version = "2.1.6" +version = "2.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6b5ad0a8e719cef020e136986d534068ffd35df287ab1635ff242585c02213e" +checksum = "fd901251b9b46c1752c85edfee0aee718c03a85a065f4126d32e5d6d419edf48" dependencies = [ "crossbeam-queue", "crossbeam-utils", - "futures", + "enum_dispatch", + "futures-core", "parking_lot", ] @@ -1708,7 +1685,7 @@ dependencies = [ "cosmic-text", "etagere", "lru", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "wgpu", ] @@ -1726,23 +1703,23 @@ dependencies = [ [[package]] name = "crypto-bigint" -version = "0.7.0-rc.25" +version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cba9eeeb213f7fd29353032f71f7c173e5f6d95d85151cb3a47197b0ea7e8be7" +checksum = "42a0d26b245348befa0c121944541476763dcc46ede886c88f9d12e1697d27c3" dependencies = [ "cpubits", "ctutils", - "getrandom 0.4.1", + "getrandom 0.4.2", "num-traits", - "rand_core 0.10.0", + "rand_core 0.10.1", "serdect", ] [[package]] name = "crypto-common" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" dependencies = [ "generic-array", "rand_core 0.6.4", @@ -1751,13 +1728,13 @@ dependencies = [ [[package]] name = "crypto-common" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "211f05e03c7d03754740fd9e585de910a095d6b99f8bcfffdef8319fa02a8331" +checksum = "77727bb15fa921304124b128af125e7e3b968275d1b108b379190264f4423710" dependencies = [ - "getrandom 0.4.1", + "getrandom 0.4.2", "hybrid-array", - "rand_core 0.10.0", + "rand_core 0.10.1", ] [[package]] @@ -1771,32 +1748,35 @@ dependencies = [ "chrono", "hex", "pem", - "reqwest 0.12.23", + "reqwest 0.12.28", "ring", "signature", "x509-certificate", ] [[package]] -name = "ctor-lite" -version = "0.1.0" +name = "ctor" +version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f791803201ab277ace03903de1594460708d2d54df6053f2d9e82f592b19e3b" +checksum = "83cf0d42651b16c6dfe68685716d18480d18a9c39c62d76e8cf3eb6ed5d8bcbf" +dependencies = [ + "dtor", +] [[package]] name = "ctr" -version = "0.10.0-rc.3" +version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65ea71550d18331d179854662ab330bb54306b9b56020d0466aae2a58f4e17c1" +checksum = "17469f8eb9bdbfad10f71f4cfddfd38b01143520c0e717d8796ccb4d44d44e42" dependencies = [ - "cipher 0.5.0", + "cipher 0.5.1", ] [[package]] name = "ctutils" -version = "0.4.0" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1005a6d4446f5120ef475ad3d2af2b30c49c2c9c6904258e3bb30219bebed5e4" +checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e" dependencies = [ "cmov", ] @@ -1844,14 +1824,14 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "darling" -version = "0.14.4" +version = "0.20.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b750cb3417fd1b327431a470f388520309479ab0bf5e323505daf0290cd3850" +checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee" dependencies = [ "darling_core", "darling_macro", @@ -1859,42 +1839,41 @@ dependencies = [ [[package]] name = "darling_core" -version = "0.14.4" +version = "0.20.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "109c1ca6e6b7f82cc233a97004ea8ed7ca123a9af07a8230878fcfda9b158bf0" +checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e" dependencies = [ "fnv", "ident_case", "proc-macro2", "quote", - "strsim 0.10.0", - "syn 1.0.109", + "strsim", + "syn 2.0.117", ] [[package]] name = "darling_macro" -version = "0.14.4" +version = "0.20.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4aab4dbc9f7611d8b55048a3a16d2d010c2c8334e46304b40ac1cc14bf3b48e" +checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" dependencies = [ "darling_core", "quote", - "syn 1.0.109", + "syn 2.0.117", ] [[package]] name = "data-encoding" -version = "2.9.0" +version = "2.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476" +checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8" [[package]] name = "decompress" -version = "0.6.0" -source = "git+https://github.com/PlumeImpactor/decompress?rev=75a3016#75a301656fc8323c4fc96bdfcb09e8cf66043477" +version = "2.3.0" dependencies = [ "ar", - "bzip2", + "bzip2 0.6.1", "derive_builder", "flate2", "infer", @@ -1902,12 +1881,18 @@ dependencies = [ "lzma-rs", "regex", "tar", - "thiserror 1.0.69", + "thiserror 2.0.18", "xz2", - "zip 0.6.6", - "zstd 0.12.4", + "zip 8.6.0", + "zstd", ] +[[package]] +name = "deflate64" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac6b926516df9c60bfa16e107b21086399f8285a44ca9711344b9e553c5146e2" + [[package]] name = "der" version = "0.7.10" @@ -1943,14 +1928,14 @@ checksum = "8034092389675178f570469e6c3b0465d3d30b4505c294a6550db47f3c17ad18" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "deranged" -version = "0.5.3" +version = "0.5.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d630bccd429a5bb5a64b5e94f693bfc48c9f8566418fda4c494cc94f911f87cc" +checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c" dependencies = [ "powerfmt", ] @@ -1963,38 +1948,38 @@ checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "derive_builder" -version = "0.12.0" +version = "0.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d67778784b508018359cbc8696edb3db78160bab2c2a28ba7f56ef6932997f8" +checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947" dependencies = [ "derive_builder_macro", ] [[package]] name = "derive_builder_core" -version = "0.12.0" +version = "0.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c11bdc11a0c47bc7d37d582b5285da6849c96681023680b906673c5707af7b0f" +checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8" dependencies = [ "darling", "proc-macro2", "quote", - "syn 1.0.109", + "syn 2.0.117", ] [[package]] name = "derive_builder_macro" -version = "0.12.0" +version = "0.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebcda35c7a396850a55ffeac740804b40ffec779b98fffbb1738f4033f0ee79e" +checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c" dependencies = [ "derive_builder_core", - "syn 1.0.109", + "syn 2.0.117", ] [[package]] @@ -2025,7 +2010,7 @@ version = "0.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "25f104b501bf2364e78d0d3974cbc774f738f5865306ed128e1e0d7499c0ad96" dependencies = [ - "console 0.16.1", + "console 0.16.3", "shell-words", "tempfile", "zeroize", @@ -2045,20 +2030,21 @@ checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" dependencies = [ "block-buffer 0.10.4", "const-oid 0.9.6", - "crypto-common 0.1.6", + "crypto-common 0.1.7", "subtle", ] [[package]] name = "digest" -version = "0.11.0-rc.11" +version = "0.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02b42f1d9edf5207c137646b568a0168ca0ec25b7f9eaf7f9961da51a3d91cea" +checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2" dependencies = [ - "block-buffer 0.11.0", + "block-buffer 0.12.0", "const-oid 0.10.2", - "crypto-common 0.2.0", - "subtle", + "crypto-common 0.2.1", + "ctutils", + "zeroize", ] [[package]] @@ -2111,14 +2097,14 @@ checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b" [[package]] name = "dispatch2" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89a09f22a6c6069a18470eb92d2298acf25463f14256d24778e1230d789a2aec" +checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.6.2", "libc", - "objc2 0.6.3", + "objc2 0.6.4", ] [[package]] @@ -2129,16 +2115,16 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "dlib" -version = "0.5.2" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412" +checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a" dependencies = [ - "libloading 0.8.8", + "libloading 0.8.9", ] [[package]] @@ -2185,6 +2171,12 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76" +[[package]] +name = "dtor" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edf234dd1594d6dd434a8fb8cada51ddbbc593e40e4a01556a0b31c62da2775b" + [[package]] name = "dunce" version = "1.0.5" @@ -2275,6 +2267,18 @@ version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099" +[[package]] +name = "enum_dispatch" +version = "0.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd" +dependencies = [ + "once_cell", + "proc-macro2", + "quote", + "syn 2.0.117", +] + [[package]] name = "enumflags2" version = "0.7.12" @@ -2293,14 +2297,14 @@ checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "env_filter" -version = "0.1.3" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0" +checksum = "32e90c2accc4b07a8456ea0debdc2e7587bdd890680d71173a15d4ae604f6eef" dependencies = [ "log", "regex", @@ -2308,9 +2312,9 @@ dependencies = [ [[package]] name = "env_logger" -version = "0.11.8" +version = "0.11.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f" +checksum = "0621c04f2196ac3f488dd583365b9c09be011a4ab8b9f37248ffcc8f6198b56a" dependencies = [ "anstream", "anstyle", @@ -2353,9 +2357,9 @@ dependencies = [ [[package]] name = "euclid" -version = "0.22.11" +version = "0.22.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ad9cdb4b747e485a12abb0e6566612956c7a1bafa3bdb8d682c5b6d403589e48" +checksum = "f1a05365e3b1c6d1650318537c7460c6923f1abdd272ad6842baa2b509957a06" dependencies = [ "num-traits", ] @@ -2383,9 +2387,9 @@ dependencies = [ [[package]] name = "fastrand" -version = "2.3.0" +version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" [[package]] name = "fdeflate" @@ -2438,21 +2442,20 @@ dependencies = [ [[package]] name = "filetime" -version = "0.2.26" +version = "0.2.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc0505cd1b6fa6580283f6bdf70a73fcf4aba1184038c90902b92b3dd0df63ed" +checksum = "f98844151eee8917efc50bd9e8318cb963ae8b297431495d3f758616ea5c57db" dependencies = [ "cfg-if", "libc", "libredox", - "windows-sys 0.60.2", ] [[package]] name = "find-msvc-tools" -version = "0.1.2" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ced73b1dacfc750a6db6c0a0c3a3853c8b41997e2e2c563dc90804ae6867959" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" [[package]] name = "flagset" @@ -2462,13 +2465,13 @@ checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe" [[package]] name = "flate2" -version = "1.1.5" +version = "1.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" dependencies = [ "crc32fast", - "libz-rs-sys", "miniz_oxide", + "zlib-rs", ] [[package]] @@ -2498,6 +2501,15 @@ dependencies = [ "bytemuck", ] +[[package]] +name = "font-types" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b38ad915f6dadd993ced50848a8291a543bd41ca62bc10740d5e64e2ab4cfd7" +dependencies = [ + "bytemuck", +] + [[package]] name = "fontconfig-parser" version = "0.5.8" @@ -2515,7 +2527,7 @@ checksum = "457e789b3d1202543297a350643cf459f836cade38934e7a4cf6a39e7cde2905" dependencies = [ "fontconfig-parser", "log", - "memmap2 0.9.9", + "memmap2 0.9.10", "slotmap", "tinyvec", "ttf-parser", @@ -2548,7 +2560,7 @@ checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -2586,9 +2598,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" [[package]] name = "futures" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d" dependencies = [ "futures-channel", "futures-core", @@ -2601,9 +2613,9 @@ dependencies = [ [[package]] name = "futures-channel" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d" dependencies = [ "futures-core", "futures-sink", @@ -2611,27 +2623,26 @@ dependencies = [ [[package]] name = "futures-core" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" [[package]] name = "futures-executor" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d" dependencies = [ "futures-core", "futures-task", "futures-util", - "num_cpus", ] [[package]] name = "futures-io" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" +checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718" [[package]] name = "futures-lite" @@ -2648,32 +2659,32 @@ dependencies = [ [[package]] name = "futures-macro" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "futures-sink" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" +checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" [[package]] name = "futures-task" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" [[package]] name = "futures-util" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" dependencies = [ "futures-channel", "futures-core", @@ -2683,7 +2694,6 @@ dependencies = [ "futures-task", "memchr", "pin-project-lite", - "pin-utils", "slab", ] @@ -2758,70 +2768,66 @@ dependencies = [ [[package]] name = "gethostname" -version = "1.0.2" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc257fdb4038301ce4b9cd1b3b51704509692bb3ff716a410cbd07925d9dae55" +checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8" dependencies = [ - "rustix 1.1.2", - "windows-targets 0.52.6", + "rustix 1.1.4", + "windows-link 0.2.1", ] [[package]] name = "getrandom" -version = "0.2.16" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" dependencies = [ "cfg-if", "js-sys", "libc", - "wasi 0.11.1+wasi-snapshot-preview1", + "wasi", "wasm-bindgen", ] [[package]] name = "getrandom" -version = "0.3.3" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" dependencies = [ "cfg-if", "js-sys", "libc", - "r-efi", - "wasi 0.14.7+wasi-0.2.4", + "r-efi 5.3.0", + "wasip2", "wasm-bindgen", ] [[package]] name = "getrandom" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec" +checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" dependencies = [ "cfg-if", + "js-sys", "libc", - "r-efi", - "rand_core 0.10.0", + "r-efi 6.0.0", + "rand_core 0.10.1", "wasip2", "wasip3", + "wasm-bindgen", ] [[package]] name = "ghash" -version = "0.6.0-rc.5" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f484be0236661c5ba22d445ed75d3624ba5544541c647549f867fb576e55b2a2" +checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5" dependencies = [ "polyval", ] -[[package]] -name = "gimli" -version = "0.31.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f" - [[package]] name = "gio" version = "0.18.4" @@ -2877,7 +2883,7 @@ version = "0.18.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "233daaf6e83ae6a12a52055f568f9d7cf4671dabb78ff9560ab6da230ce00ee5" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "futures-channel", "futures-core", "futures-executor", @@ -2905,7 +2911,7 @@ dependencies = [ "proc-macro-error", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -2997,7 +3003,7 @@ version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fbcd2dba93594b227a1f57ee09b8b9da8892c34d55aa332e034a228d0fe6a171" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "gpu-alloc-types", ] @@ -3007,7 +3013,7 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "98ff03b468aa837d70984d55f5d3f846f6ec31fe34bbb97c4f85219caeee1ca4" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", ] [[package]] @@ -3028,7 +3034,7 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b89c83349105e3732062a895becfc71a8f921bb71ecbbdd8ff99263e3b53a0ca" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "gpu-descriptor-types", "hashbrown 0.15.5", ] @@ -3039,7 +3045,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", ] [[package]] @@ -3102,7 +3108,7 @@ dependencies = [ "proc-macro-error", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -3117,35 +3123,16 @@ dependencies = [ [[package]] name = "h2" -version = "0.3.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d" -dependencies = [ - "bytes", - "fnv", - "futures-core", - "futures-sink", - "futures-util", - "http 0.2.12", - "indexmap", - "slab", - "tokio", - "tokio-util", - "tracing", -] - -[[package]] -name = "h2" -version = "0.4.12" +version = "0.4.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3c0b69cfcb4e1b9f1bf2f53f95f766e4661169728ec61cd3fe5a0166f2d1386" +checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54" dependencies = [ "atomic-waker", "bytes", "fnv", "futures-core", "futures-sink", - "http 1.3.1", + "http", "indexmap", "slab", "tokio", @@ -3171,10 +3158,10 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92c020db12c71d8a12a3fe7607873cade3a01a6287e29d540c8723276221b9d8" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "bytemuck", "core_maths", - "read-fonts", + "read-fonts 0.35.0", "smallvec", ] @@ -3198,13 +3185,19 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.16.0" +version = "0.16.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" dependencies = [ "foldhash 0.2.0", ] +[[package]] +name = "hashbrown" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51" + [[package]] name = "heck" version = "0.4.1" @@ -3255,46 +3248,23 @@ dependencies = [ [[package]] name = "hmac" -version = "0.13.0-rc.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef451d73f36d8a3f93ad32c332ea01146c9650e1ec821a9b0e46c01277d544f8" -dependencies = [ - "digest 0.11.0-rc.11", -] - -[[package]] -name = "http" -version = "0.2.12" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" +checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f" dependencies = [ - "bytes", - "fnv", - "itoa", + "digest 0.11.3", ] [[package]] name = "http" -version = "1.3.1" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565" +checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" dependencies = [ "bytes", - "fnv", "itoa", ] -[[package]] -name = "http-body" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2" -dependencies = [ - "bytes", - "http 0.2.12", - "pin-project-lite", -] - [[package]] name = "http-body" version = "1.0.1" @@ -3302,7 +3272,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" dependencies = [ "bytes", - "http 1.3.1", + "http", ] [[package]] @@ -3313,8 +3283,8 @@ checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a" dependencies = [ "bytes", "futures-core", - "http 1.3.1", - "http-body 1.0.1", + "http", + "http-body", "pin-project-lite", ] @@ -3324,62 +3294,31 @@ version = "1.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" -[[package]] -name = "httpdate" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" - [[package]] name = "hybrid-array" -version = "0.4.7" +version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1b229d73f5803b562cc26e4da0396c8610a4ee209f4fac8fa4f8d709166dc45" +checksum = "08d46837a0ed51fe95bd3b05de33cd64a1ee88fc797477ca48446872504507c5" dependencies = [ "typenum", ] [[package]] name = "hyper" -version = "0.14.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7" -dependencies = [ - "bytes", - "futures-channel", - "futures-core", - "futures-util", - "h2 0.3.27", - "http 0.2.12", - "http-body 0.4.6", - "httparse", - "httpdate", - "itoa", - "pin-project-lite", - "socket2 0.5.10", - "tokio", - "tower-service", - "tracing", - "want", -] - -[[package]] -name = "hyper" -version = "1.7.0" +version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e" +checksum = "6299f016b246a94207e63da54dbe807655bf9e00044f73ded42c3ac5305fbcca" dependencies = [ "atomic-waker", "bytes", "futures-channel", "futures-core", - "h2 0.4.12", - "http 1.3.1", - "http-body 1.0.1", + "h2", + "http", + "http-body", "httparse", "itoa", "pin-project-lite", - "pin-utils", "smallvec", "tokio", "want", @@ -3387,45 +3326,30 @@ dependencies = [ [[package]] name = "hyper-rustls" -version = "0.24.2" +version = "0.27.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" +checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f" dependencies = [ - "futures-util", - "http 0.2.12", - "hyper 0.14.32", - "rustls 0.21.12", + "http", + "hyper", + "hyper-util", + "rustls", + "rustls-native-certs 0.8.3", "tokio", - "tokio-rustls 0.24.1", + "tokio-rustls", + "tower-service", + "webpki-roots 1.0.7", ] [[package]] -name = "hyper-rustls" -version = "0.27.7" +name = "hyper-tls" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58" -dependencies = [ - "http 1.3.1", - "hyper 1.7.0", - "hyper-util", - "rustls 0.23.32", - "rustls-native-certs 0.8.2", - "rustls-pki-types", - "tokio", - "tokio-rustls 0.26.3", - "tower-service", - "webpki-roots 1.0.3", -] - -[[package]] -name = "hyper-tls" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0" +checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0" dependencies = [ "bytes", "http-body-util", - "hyper 1.7.0", + "hyper", "hyper-util", "native-tls", "tokio", @@ -3435,35 +3359,34 @@ dependencies = [ [[package]] name = "hyper-util" -version = "0.1.17" +version = "0.1.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8" +checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0" dependencies = [ "base64 0.22.1", "bytes", "futures-channel", - "futures-core", "futures-util", - "http 1.3.1", - "http-body 1.0.1", - "hyper 1.7.0", + "http", + "http-body", + "hyper", "ipnet", "libc", "percent-encoding", "pin-project-lite", - "socket2 0.6.0", - "system-configuration 0.6.1", + "socket2", + "system-configuration", "tokio", "tower-service", "tracing", - "windows-registry", + "windows-registry 0.6.1", ] [[package]] name = "iana-time-zone" -version = "0.1.64" +version = "0.1.65" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" dependencies = [ "android_system_properties", "core-foundation-sys", @@ -3497,7 +3420,7 @@ dependencies = [ "iced_widget", "iced_winit", "image", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -3506,15 +3429,15 @@ version = "0.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "91ab1937d699403e7e69252ae743a902bcee9f4ab2052cc4c9a46fcf34729d85" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "bytes", "glam", "lilt", "log", "num-traits", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "smol_str", - "thiserror 2.0.17", + "thiserror 2.0.18", "web-time", ] @@ -3538,7 +3461,7 @@ dependencies = [ "futures", "iced_core", "log", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "wasm-bindgen-futures", "wasmtimer", ] @@ -3549,7 +3472,7 @@ version = "0.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "234ca1c2cec4155055f68fa5fad1b5242c496ac8238d80a259bca382fb44a102" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "bytemuck", "cosmic-text", "half", @@ -3559,8 +3482,8 @@ dependencies = [ "kamadak-exif", "log", "raw-window-handle", - "rustc-hash 2.1.1", - "thiserror 2.0.17", + "rustc-hash 2.1.2", + "thiserror 2.0.18", "unicode-segmentation", ] @@ -3584,7 +3507,7 @@ dependencies = [ "iced_tiny_skia", "iced_wgpu", "log", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -3597,7 +3520,7 @@ dependencies = [ "iced_core", "iced_futures", "raw-window-handle", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -3612,7 +3535,7 @@ dependencies = [ "iced_graphics", "kurbo", "log", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "softbuffer", "tiny-skia", ] @@ -3623,7 +3546,7 @@ version = "0.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ff144a999b0ca0f8a10257934500060240825c42e950ec0ebee9c8ae30561c13" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "bytemuck", "cryoglyph", "futures", @@ -3632,8 +3555,8 @@ dependencies = [ "iced_debug", "iced_graphics", "log", - "rustc-hash 2.1.1", - "thiserror 2.0.17", + "rustc-hash 2.1.2", + "thiserror 2.0.18", "wgpu", ] @@ -3646,8 +3569,8 @@ dependencies = [ "iced_renderer", "log", "num-traits", - "rustc-hash 2.1.1", - "thiserror 2.0.17", + "rustc-hash 2.1.2", + "thiserror 2.0.18", "unicode-segmentation", ] @@ -3661,8 +3584,8 @@ dependencies = [ "iced_program", "log", "mundy", - "rustc-hash 2.1.1", - "thiserror 2.0.17", + "rustc-hash 2.1.2", + "thiserror 2.0.18", "tracing", "wasm-bindgen-futures", "web-sys", @@ -3672,12 +3595,13 @@ dependencies = [ [[package]] name = "icu_collections" -version = "2.0.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" +checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c" dependencies = [ "displaydoc", "potential_utf", + "utf8_iter", "yoke", "zerofrom", "zerovec", @@ -3685,9 +3609,9 @@ dependencies = [ [[package]] name = "icu_locale_core" -version = "2.0.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" +checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29" dependencies = [ "displaydoc", "litemap", @@ -3698,11 +3622,10 @@ dependencies = [ [[package]] name = "icu_normalizer" -version = "2.0.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" +checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4" dependencies = [ - "displaydoc", "icu_collections", "icu_normalizer_data", "icu_properties", @@ -3713,42 +3636,38 @@ dependencies = [ [[package]] name = "icu_normalizer_data" -version = "2.0.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" +checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38" [[package]] name = "icu_properties" -version = "2.0.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" +checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de" dependencies = [ - "displaydoc", "icu_collections", "icu_locale_core", "icu_properties_data", "icu_provider", - "potential_utf", "zerotrie", "zerovec", ] [[package]] name = "icu_properties_data" -version = "2.0.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" +checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14" [[package]] name = "icu_provider" -version = "2.0.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" +checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421" dependencies = [ "displaydoc", "icu_locale_core", - "stable_deref_trait", - "tinystr", "writeable", "yoke", "zerofrom", @@ -3794,18 +3713,18 @@ dependencies = [ "ns-keyed-archive", "plist", "plist-macro", - "rand 0.10.0", - "reqwest 0.13.2", + "rand 0.10.1", + "reqwest 0.13.3", "rsa", - "rustls 0.23.32", + "rustls", "serde", "serde_json", - "sha1", + "sha1 0.10.6", "sha2 0.10.9", "siphasher", - "thiserror 2.0.17", + "thiserror 2.0.18", "tokio", - "tokio-rustls 0.26.3", + "tokio-rustls", "tracing", "uuid", "x25519-dalek", @@ -3839,9 +3758,9 @@ dependencies = [ [[package]] name = "idna_adapter" -version = "1.2.1" +version = "1.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714" dependencies = [ "icu_normalizer", "icu_properties", @@ -3865,36 +3784,36 @@ dependencies = [ [[package]] name = "image" -version = "0.25.9" +version = "0.25.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a" +checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104" dependencies = [ "bytemuck", "byteorder-lite", "moxcms", "num-traits", - "png 0.18.0", + "png 0.18.1", "zune-core", "zune-jpeg", ] [[package]] name = "indexmap" -version = "2.11.4" +version = "2.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" dependencies = [ "equivalent", - "hashbrown 0.16.0", + "hashbrown 0.17.0", "serde", "serde_core", ] [[package]] name = "infer" -version = "0.12.0" +version = "0.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a898e4b7951673fce96614ce5751d13c40fc5674bc2d759288e46c3ab62598b3" +checksum = "a588916bfdfd92e71cacef98a63d9b1f0d74d6599980d11894290e7ddefffcf7" dependencies = [ "cfb", ] @@ -3925,28 +3844,17 @@ dependencies = [ "hybrid-array", ] -[[package]] -name = "io-uring" -version = "0.7.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "046fa2d4d00aea763528b4950358d0ead425372445dc8ff86312b3c69ff7727b" -dependencies = [ - "bitflags 2.9.4", - "cfg-if", - "libc", -] - [[package]] name = "ipnet" -version = "2.11.0" +version = "2.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130" +checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2" [[package]] name = "iri-string" -version = "0.7.8" +version = "0.7.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2" +checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20" dependencies = [ "memchr", "serde", @@ -3982,9 +3890,9 @@ dependencies = [ [[package]] name = "is_terminal_polyfill" -version = "1.70.1" +version = "1.70.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" [[package]] name = "itertools" @@ -4006,68 +3914,104 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.15" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "jiff" -version = "0.2.15" +version = "0.2.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be1f93b8b1eb69c77f24bbb0afdf66f54b632ee39af40ca21c4365a1d7347e49" +checksum = "f00b5dbd620d61dfdcb6007c9c1f6054ebd75319f163d886a9055cec1155073d" dependencies = [ "jiff-static", "log", "portable-atomic", "portable-atomic-util", - "serde", + "serde_core", ] [[package]] name = "jiff-static" -version = "0.2.15" +version = "0.2.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03343451ff899767262ec32146f6d559dd759fdadf42ff0e227c7c48f72594b4" +checksum = "e000de030ff8022ea1da3f466fbb0f3a809f5e51ed31f6dd931c35181ad8e6d7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "jktcp" -version = "0.1.1" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a5e6f49d25ffd9617fde3b1f01b6bc349497affef78d5fc67f5b0f0b4b3924c" +checksum = "65b9d88c89c8fe802c7e7c2bf32b0fb85ef53187c30a8f130d41578b4362baa7" dependencies = [ "crossfire", "futures", - "rand 0.9.2", + "rand 0.9.4", "tokio", "tracing", ] [[package]] name = "jni" -version = "0.21.1" +version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97" +checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498" dependencies = [ - "cesu8", "cfg-if", "combine", - "jni-sys", + "jni-macros", + "jni-sys 0.4.1", "log", - "thiserror 1.0.69", + "simd_cesu8", + "thiserror 2.0.18", "walkdir", - "windows-sys 0.45.0", + "windows-link 0.2.1", +] + +[[package]] +name = "jni-macros" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3" +dependencies = [ + "proc-macro2", + "quote", + "rustc_version", + "simd_cesu8", + "syn 2.0.117", ] [[package]] name = "jni-sys" -version = "0.3.0" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258" +dependencies = [ + "jni-sys 0.4.1", +] + +[[package]] +name = "jni-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2" +dependencies = [ + "jni-sys-macros", +] + +[[package]] +name = "jni-sys-macros" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" +checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" +dependencies = [ + "quote", + "syn 2.0.117", +] [[package]] name = "jobserver" @@ -4075,16 +4019,18 @@ version = "0.1.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" dependencies = [ - "getrandom 0.3.3", + "getrandom 0.3.4", "libc", ] [[package]] name = "js-sys" -version = "0.3.80" +version = "0.3.97" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "852f13bec5eba4ba9afbeb93fd7c13fe56147f055939ae21c43a29a0ecb2702e" +checksum = "a1840c94c045fbcf8ba2812c95db44499f7c64910a912551aaaa541decebcacf" dependencies = [ + "cfg-if", + "futures-util", "once_cell", "wasm-bindgen", ] @@ -4110,7 +4056,7 @@ version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b750dcadc39a09dbadd74e118f6dd6598df77fa01df0cfcdc52c28dece74528a" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "serde", "unicode-segmentation", ] @@ -4122,7 +4068,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76" dependencies = [ "libc", - "libloading 0.8.8", + "libloading 0.8.9", "pkg-config", ] @@ -4134,9 +4080,9 @@ checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc" [[package]] name = "konst" -version = "0.3.16" +version = "0.3.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4381b9b00c55f251f2ebe9473aef7c117e96828def1a7cb3bd3f0f903c6894e9" +checksum = "97feab15b395d1860944abe6a8dd8ed9f8eadfae01750fada8427abda531d887" dependencies = [ "const_panic", "konst_kernel", @@ -4201,11 +4147,17 @@ dependencies = [ "once_cell", ] +[[package]] +name = "libbz2-rs-sys" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b3a6a8c165077efc8f3a971534c50ea6a1a18b329ef4a66e897a7e3a1494565f" + [[package]] name = "libc" -version = "0.2.177" +version = "0.2.186" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" [[package]] name = "libloading" @@ -4219,38 +4171,30 @@ dependencies = [ [[package]] name = "libloading" -version = "0.8.8" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" dependencies = [ "cfg-if", - "windows-targets 0.53.3", + "windows-link 0.2.1", ] [[package]] name = "libm" -version = "0.2.15" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" [[package]] name = "libredox" -version = "0.1.10" +version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb" +checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "libc", - "redox_syscall 0.5.17", -] - -[[package]] -name = "libz-rs-sys" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "840db8cf39d9ec4dd794376f38acc40d0fc65eec2a8f484f7fd375b84602becd" -dependencies = [ - "zlib-rs", + "plain", + "redox_syscall 0.7.4", ] [[package]] @@ -4276,15 +4220,15 @@ checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" [[package]] name = "linux-raw-sys" -version = "0.11.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" [[package]] name = "litemap" -version = "0.8.0" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" +checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0" [[package]] name = "litrs" @@ -4303,15 +4247,15 @@ dependencies = [ [[package]] name = "log" -version = "0.4.28" +version = "0.4.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" [[package]] name = "lru" -version = "0.16.3" +version = "0.16.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1dc47f592c06f33f8e3aea9591776ec7c9f9e4124778ff8a3c3b87159f7e593" +checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39" [[package]] name = "lru-slab" @@ -4329,6 +4273,15 @@ dependencies = [ "crc", ] +[[package]] +name = "lzma-rust2" +version = "0.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47bb1e988e6fb779cf720ad431242d3f03167c1b3f2b1aae7f1a94b2495b36ae" +dependencies = [ + "sha2 0.10.9", +] + [[package]] name = "lzma-sys" version = "0.1.20" @@ -4342,12 +4295,12 @@ dependencies = [ [[package]] name = "mac-notification-sys" -version = "0.6.9" +version = "0.6.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65fd3f75411f4725061682ed91f131946e912859d0044d39c4ec0aac818d7621" +checksum = "29a16783dd1a47849b8c8133c9cd3eb2112cfbc6901670af3dba47c8bbfb07d3" dependencies = [ "cc", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-foundation 0.3.2", "time", ] @@ -4382,9 +4335,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.7.5" +version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" [[package]] name = "memmap2" @@ -4397,9 +4350,9 @@ dependencies = [ [[package]] name = "memmap2" -version = "0.9.9" +version = "0.9.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490" +checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3" dependencies = [ "libc", ] @@ -4428,7 +4381,7 @@ version = "0.32.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "00c15a6f673ff72ddcc22394663290f870fb224c1bfce55734a75c414150e605" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block", "core-graphics-types 0.2.0", "foreign-types 0.5.0", @@ -4460,7 +4413,7 @@ checksum = "bd2209fff77f705b00c737016a48e73733d7fbccb8b007194db148f03561fb70" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -4481,20 +4434,20 @@ dependencies = [ [[package]] name = "mio" -version = "1.0.4" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c" +checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1" dependencies = [ "libc", - "wasi 0.11.1+wasi-snapshot-preview1", - "windows-sys 0.59.0", + "wasi", + "windows-sys 0.61.2", ] [[package]] name = "moxcms" -version = "0.7.11" +version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac9557c559cd6fc9867e122e20d2cbefc9ca29d80d027a8e39310920ed2f0a97" +checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b" dependencies = [ "num-traits", "pxfm", @@ -4502,29 +4455,29 @@ dependencies = [ [[package]] name = "muda" -version = "0.17.1" +version = "0.17.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "01c1738382f66ed56b3b9c8119e794a2e23148ac8ea214eda86622d4cb9d415a" +checksum = "7c9fec5a4e89860383d778d10563a605838f8f0b2f9303868937e5ff32e86177" dependencies = [ "crossbeam-channel", "dpi", "gtk", "keyboard-types", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-app-kit 0.3.2", "objc2-core-foundation", "objc2-foundation 0.3.2", "once_cell", "png 0.17.16", - "thiserror 2.0.17", + "thiserror 2.0.18", "windows-sys 0.60.2", ] [[package]] name = "mundy" -version = "0.2.2" +version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "523813c9e194ec43693805214eb112551f99382115b67f38600d724a692e7e8b" +checksum = "f32eb0db40f2df2bcfb05c93b8f73938d4c26ce9ac8881f1df0c8d3296921a73" dependencies = [ "android-build", "async-io", @@ -4534,7 +4487,7 @@ dependencies = [ "futures-lite", "jni", "ndk-context", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-app-kit 0.3.2", "objc2-foundation 0.3.2", "pin-project-lite", @@ -4559,12 +4512,12 @@ checksum = "066cf25f0e8b11ee0df221219010f213ad429855f57c494f995590c861a9a7d8" dependencies = [ "arrayvec", "bit-set", - "bitflags 2.9.4", + "bitflags 2.11.1", "cfg-if", "cfg_aliases", "codespan-reporting", "half", - "hashbrown 0.16.0", + "hashbrown 0.16.1", "hexf-parse", "indexmap", "libm", @@ -4573,7 +4526,7 @@ dependencies = [ "once_cell", "rustc-hash 1.1.0", "spirv", - "thiserror 2.0.17", + "thiserror 2.0.18", "unicode-ident", ] @@ -4589,7 +4542,7 @@ dependencies = [ "openssl-probe 0.2.1", "openssl-sys", "schannel", - "security-framework 3.5.1", + "security-framework 3.7.0", "security-framework-sys", "tempfile", ] @@ -4600,8 +4553,8 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4" dependencies = [ - "bitflags 2.9.4", - "jni-sys", + "bitflags 2.11.1", + "jni-sys 0.3.1", "log", "ndk-sys", "num_enum", @@ -4621,7 +4574,7 @@ version = "0.6.0+11769913" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873" dependencies = [ - "jni-sys", + "jni-sys 0.3.1", ] [[package]] @@ -4637,19 +4590,6 @@ dependencies = [ "memoffset 0.6.5", ] -[[package]] -name = "nix" -version = "0.30.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6" -dependencies = [ - "bitflags 2.9.4", - "cfg-if", - "cfg_aliases", - "libc", - "memoffset 0.9.1", -] - [[package]] name = "nom" version = "7.1.3" @@ -4671,9 +4611,9 @@ dependencies = [ [[package]] name = "notify-rust" -version = "4.11.7" +version = "4.16.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6442248665a5aa2514e794af3b39661a8e73033b1cc5e59899e1276117ee4400" +checksum = "3bdaf6120b9df005d37e58f6b75329be6255450453fbeba9ce4192324f921fb9" dependencies = [ "futures-lite", "log", @@ -4700,7 +4640,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "36c53158d1bf37bbbdd165f5220fda8bb5757c89eb700107992152c64c6cad7e" dependencies = [ "plist", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -4715,26 +4655,25 @@ dependencies = [ [[package]] name = "num-bigint-dig" -version = "0.8.4" +version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc84195820f291c7697304f3cbdadd1cb7199c0efc917ff5eafd71225c136151" +checksum = "e661dda6640fad38e827a6d4a310ff4763082116fe217f279885c97f511bb0b7" dependencies = [ - "byteorder", "lazy_static", "libm", "num-integer", "num-iter", "num-traits", - "rand 0.8.5", + "rand 0.8.6", "smallvec", "zeroize", ] [[package]] name = "num-conv" -version = "0.1.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" +checksum = "c6673768db2d862beb9b39a78fdcb1a69439615d5794a1be50caa9bc92c81967" [[package]] name = "num-integer" @@ -4766,21 +4705,11 @@ dependencies = [ "libm", ] -[[package]] -name = "num_cpus" -version = "1.17.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b" -dependencies = [ - "hermit-abi", - "libc", -] - [[package]] name = "num_enum" -version = "0.7.5" +version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c" +checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26" dependencies = [ "num_enum_derive", "rustversion", @@ -4788,14 +4717,23 @@ dependencies = [ [[package]] name = "num_enum_derive" -version = "0.7.5" +version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7" +checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8" dependencies = [ - "proc-macro-crate 3.4.0", + "proc-macro-crate 3.5.0", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", +] + +[[package]] +name = "num_threads" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9" +dependencies = [ + "libc", ] [[package]] @@ -4836,9 +4774,9 @@ dependencies = [ [[package]] name = "objc2" -version = "0.6.3" +version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7c2599ce0ec54857b29ce62166b0ed9b4f6f1a70ccc9a71165b6154caca8c05" +checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f" dependencies = [ "objc2-encode", ] @@ -4849,7 +4787,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.5.1", "libc", "objc2 0.5.2", @@ -4865,10 +4803,10 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.6.2", "libc", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-cloud-kit 0.3.2", "objc2-core-data 0.3.2", "objc2-core-foundation", @@ -4886,7 +4824,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.5.1", "objc2 0.5.2", "objc2-core-location", @@ -4899,8 +4837,8 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c" dependencies = [ - "bitflags 2.9.4", - "objc2 0.6.3", + "bitflags 2.11.1", + "objc2 0.6.4", "objc2-foundation 0.3.2", ] @@ -4921,7 +4859,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.5.1", "objc2 0.5.2", "objc2-foundation 0.2.2", @@ -4933,8 +4871,8 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa" dependencies = [ - "bitflags 2.9.4", - "objc2 0.6.3", + "bitflags 2.11.1", + "objc2 0.6.4", "objc2-foundation 0.3.2", ] @@ -4944,9 +4882,9 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "dispatch2", - "objc2 0.6.3", + "objc2 0.6.4", ] [[package]] @@ -4955,9 +4893,9 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "dispatch2", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-core-foundation", "objc2-io-surface", ] @@ -4980,7 +4918,7 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006" dependencies = [ - "objc2 0.6.3", + "objc2 0.6.4", "objc2-foundation 0.3.2", ] @@ -5002,8 +4940,8 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d" dependencies = [ - "bitflags 2.9.4", - "objc2 0.6.3", + "bitflags 2.11.1", + "objc2 0.6.4", "objc2-core-foundation", "objc2-core-graphics", ] @@ -5014,8 +4952,8 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d425caf1df73233f29fd8a5c3e5edbc30d2d4307870f802d18f00d83dc5141a6" dependencies = [ - "bitflags 2.9.4", - "objc2 0.6.3", + "bitflags 2.11.1", + "objc2 0.6.4", "objc2-core-foundation", "objc2-core-graphics", "objc2-io-surface", @@ -5033,7 +4971,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.5.1", "dispatch", "libc", @@ -5046,10 +4984,10 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.6.2", "libc", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-core-foundation", ] @@ -5059,8 +4997,8 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d" dependencies = [ - "bitflags 2.9.4", - "objc2 0.6.3", + "bitflags 2.11.1", + "objc2 0.6.4", "objc2-core-foundation", ] @@ -5082,7 +5020,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.5.1", "objc2 0.5.2", "objc2-foundation 0.2.2", @@ -5094,7 +5032,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.5.1", "objc2 0.5.2", "objc2-foundation 0.2.2", @@ -5107,8 +5045,8 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f" dependencies = [ - "bitflags 2.9.4", - "objc2 0.6.3", + "bitflags 2.11.1", + "objc2 0.6.4", "objc2-core-foundation", "objc2-foundation 0.3.2", ] @@ -5129,7 +5067,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.5.1", "objc2 0.5.2", "objc2-cloud-kit 0.2.2", @@ -5161,7 +5099,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.5.1", "objc2 0.5.2", "objc2-core-location", @@ -5211,8 +5149,7 @@ dependencies = [ [[package]] name = "omnisette" -version = "0.1.0" -source = "git+https://github.com/PlumeImpactor/omnisette?rev=c5c4cf2#c5c4cf29a4d0baea632bf50efbc161eb88df57b9" +version = "2.3.0" dependencies = [ "android-loader", "anyhow", @@ -5227,28 +5164,30 @@ dependencies = [ "objc", "objc-foundation", "plist", - "rand 0.9.2", + "rand 0.8.6", "remove-async-await", - "reqwest 0.11.27", + "reqwest 0.13.3", "serde", "serde_json", - "sha2 0.10.9", - "thiserror 2.0.17", + "sha2 0.11.0", + "simplelog", + "thiserror 2.0.18", + "tokio", "tokio-tungstenite", "uuid", ] [[package]] name = "once_cell" -version = "1.21.3" +version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" [[package]] name = "once_cell_polyfill" -version = "1.70.1" +version = "1.70.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" [[package]] name = "opaque-debug" @@ -5258,9 +5197,9 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" [[package]] name = "open" -version = "5.3.3" +version = "5.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43bb73a7fa3799b198970490a51174027ba0d4ec504b03cd08caf513d40024bc" +checksum = "9f3bab717c29a857abf75fcef718d441ec7cb2725f937343c734740a985d37fd" dependencies = [ "is-wsl", "libc", @@ -5269,11 +5208,11 @@ dependencies = [ [[package]] name = "openssl" -version = "0.10.76" +version = "0.10.78" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "951c002c75e16ea2c65b8c7e4d3d51d5530d8dfa7d060b4776828c88cfb18ecf" +checksum = "f38c4372413cdaaf3cc79dd92d29d7d9f5ab09b51b10dded508fb90bb70b9222" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "cfg-if", "foreign-types 0.3.2", "libc", @@ -5290,7 +5229,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -5307,9 +5246,9 @@ checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" [[package]] name = "openssl-sys" -version = "0.9.112" +version = "0.9.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57d55af3b3e226502be1526dfdba67ab0e9c96fc293004e79576b2b9edb0dbdb" +checksum = "13ce1245cd07fcc4cfdb438f7507b0c7e4f3849a69fd84d52374c66d83741bb6" dependencies = [ "cc", "libc", @@ -5325,18 +5264,19 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" [[package]] name = "orbclient" -version = "0.3.49" +version = "0.3.54" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "247ad146e19b9437f8604c21f8652423595cf710ad108af40e77d3ae6e96b827" +checksum = "a570f6bca41d29acb2139229a7c873ec99bc9a313bd10804081d89bfac8ff329" dependencies = [ + "libc", "libredox", ] [[package]] name = "ordered-float" -version = "4.6.0" +version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951" +checksum = "b7d950ca161dc355eaf28f82b11345ed76c6e1f6eb1f4f4479e0323b9e2fbd0e" dependencies = [ "num-traits", ] @@ -5369,19 +5309,19 @@ dependencies = [ "cbc 0.1.2", "cipher 0.4.4", "des", - "getrandom 0.2.16", + "getrandom 0.2.17", "hmac 0.12.1", "lazy_static", "rc2", - "sha1", + "sha1 0.10.6", "yasna", ] [[package]] name = "p12-keystore" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8d55319bae67f92141ce4da80c5392acd3d1323bd8312c1ffdfb018927d07d7" +checksum = "ffb9bf5222606eb712d3bb30e01bc9420545b00859970897e70c682353a034f2" dependencies = [ "base64 0.22.1", "cbc 0.1.2", @@ -5392,11 +5332,11 @@ dependencies = [ "hmac 0.12.1", "pkcs12", "pkcs5", - "rand 0.9.2", + "rand 0.10.1", "rc2", - "sha1", + "sha1 0.10.6", "sha2 0.10.9", - "thiserror 2.0.17", + "thiserror 2.0.18", "x509-parser", ] @@ -5460,22 +5400,11 @@ checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" dependencies = [ "cfg-if", "libc", - "redox_syscall 0.5.17", + "redox_syscall 0.5.18", "smallvec", "windows-link 0.2.1", ] -[[package]] -name = "password-hash" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7676374caaee8a325c9e7a2ae557f216c5563a171d6997b0ef8a65af35147700" -dependencies = [ - "base64ct", - "rand_core 0.6.4", - "subtle", -] - [[package]] name = "paste" version = "1.0.15" @@ -5488,18 +5417,6 @@ version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3" -[[package]] -name = "pbkdf2" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83a0692ec44e4cf1ef28ca317f14f8f07da2d95ec3fa01f86e4467b725e60917" -dependencies = [ - "digest 0.10.7", - "hmac 0.12.1", - "password-hash", - "sha2 0.10.9", -] - [[package]] name = "pbkdf2" version = "0.12.2" @@ -5512,12 +5429,12 @@ dependencies = [ [[package]] name = "pbkdf2" -version = "0.13.0-rc.9" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8dfa4e14084d963d35bfb4cdb38712cde78dcf83054c0e8b9b8e899150f374e" +checksum = "112d82ceb8c5bf524d9af484d4e4970c9fd5a0cc15ba14ad93dccd28873b0629" dependencies = [ - "digest 0.11.0-rc.11", - "hmac 0.13.0-rc.5", + "digest 0.11.3", + "hmac 0.13.0", ] [[package]] @@ -5540,7 +5457,7 @@ dependencies = [ "proc-macro2", "proc-macro2-diagnostics", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -5570,29 +5487,29 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" [[package]] name = "pin-project" -version = "1.1.10" +version = "1.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a" +checksum = "f1749c7ed4bcaf4c3d0a3efc28538844fb29bcdd7d2b67b2be7e20ba861ff517" dependencies = [ "pin-project-internal", ] [[package]] name = "pin-project-internal" -version = "1.1.10" +version = "1.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861" +checksum = "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "pin-project-lite" -version = "0.2.16" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" [[package]] name = "pin-utils" @@ -5602,9 +5519,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" [[package]] name = "piper" -version = "0.2.4" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066" +checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1" dependencies = [ "atomic-waker", "fastrand", @@ -5664,9 +5581,9 @@ dependencies = [ [[package]] name = "pkg-config" -version = "0.3.32" +version = "0.3.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" +checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" [[package]] name = "plain" @@ -5676,13 +5593,13 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" [[package]] name = "plist" -version = "1.8.0" +version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "740ebea15c5d1428f910cd1a5f52cebf8d25006245ed8ade92702f4943d91e07" +checksum = "092791278e026273c1b65bbdcfbba3a300f2994c896bd01ab01da613c29c46f1" dependencies = [ "base64 0.22.1", "indexmap", - "quick-xml 0.38.3", + "quick-xml 0.39.2", "serde", "time", ] @@ -5700,33 +5617,33 @@ dependencies = [ name = "plume_core" version = "2.3.0" dependencies = [ - "aes 0.9.0-rc.4", + "aes 0.9.0", "aes-gcm", "apple-codesign", "base64 0.22.1", - "cbc 0.2.0-rc.3", + "cbc 0.2.0", "goblin", "hex", - "hmac 0.13.0-rc.5", + "hmac 0.13.0", "log", "omnisette", "p12-keystore", - "pbkdf2 0.13.0-rc.9", + "pbkdf2 0.13.0", "pem", "pem-rfc7468", "plist", - "rand 0.8.5", + "rand 0.8.6", "rcgen", "regex", - "reqwest 0.13.2", + "reqwest 0.13.3", "rsa", - "rustls 0.23.32", + "rustls", "serde", "serde_json", - "sha1", - "sha2 0.11.0-rc.5", + "sha1 0.10.6", + "sha2 0.11.0", "srp", - "thiserror 2.0.17", + "thiserror 2.0.18", "tokio", "uuid", "x509-certificate", @@ -5761,10 +5678,10 @@ dependencies = [ "plist", "plume_core", "plume_store", - "thiserror 2.0.17", + "thiserror 2.0.18", "tokio", "uuid", - "zip 4.6.1", + "zip 8.6.0", ] [[package]] @@ -5782,7 +5699,7 @@ dependencies = [ "image", "log", "notify-rust", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-app-kit 0.3.2", "open", "plist", @@ -5792,9 +5709,9 @@ dependencies = [ "plume_utils", "rfd", "rust-i18n", - "rustls 0.23.32", + "rustls", "single-instance", - "thiserror 2.0.17", + "thiserror 2.0.18", "tiny-skia", "tokio", "tray-icon", @@ -5820,7 +5737,7 @@ dependencies = [ "plume_gestalt", "plume_store", "plume_utils", - "rustls 0.23.32", + "rustls", "tokio", ] @@ -5839,11 +5756,11 @@ dependencies = [ [[package]] name = "png" -version = "0.18.0" +version = "0.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97baced388464909d42d89643fe4361939af9b7ce7a31ee32a168f832a70f2a0" +checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "crc32fast", "fdeflate", "flate2", @@ -5860,7 +5777,7 @@ dependencies = [ "concurrent-queue", "hermit-abi", "pin-project-lite", - "rustix 1.1.2", + "rustix 1.1.4", "windows-sys 0.61.2", ] @@ -5883,35 +5800,35 @@ dependencies = [ [[package]] name = "polyval" -version = "0.7.0-rc.7" +version = "0.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63641a86fddf4b5274f31c43734458ec7acd3133016dbaa37e4e247e1e9acd46" +checksum = "7dfc63250416fea14f5749b90725916a6c903f599d51cb635aa7a52bfd03eede" dependencies = [ "cpubits", - "cpufeatures 0.2.17", - "universal-hash 0.6.0-rc.10", + "cpufeatures 0.3.0", + "universal-hash 0.6.1", ] [[package]] name = "portable-atomic" -version = "1.11.1" +version = "1.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483" +checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" [[package]] name = "portable-atomic-util" -version = "0.2.4" +version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507" +checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618" dependencies = [ "portable-atomic", ] [[package]] name = "potential_utf" -version = "0.1.3" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a" +checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564" dependencies = [ "zerovec", ] @@ -5922,6 +5839,12 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" +[[package]] +name = "ppmd-rust" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "efca4c95a19a79d1c98f791f10aebd5c1363b473244630bb7dbde1dc98455a24" + [[package]] name = "ppv-lite86" version = "0.2.21" @@ -5944,7 +5867,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -5972,16 +5895,16 @@ version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7e8366a6159044a37876a2b9817124296703c586a5c92e2c53751fa06d8d43e8" dependencies = [ - "toml_edit 0.20.2", + "toml_edit 0.20.7", ] [[package]] name = "proc-macro-crate" -version = "3.4.0" +version = "3.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983" +checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" dependencies = [ - "toml_edit 0.23.10+spec-1.0.0", + "toml_edit 0.25.11+spec-1.1.0", ] [[package]] @@ -6010,9 +5933,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.101" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] @@ -6025,7 +5948,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", "version_check", "yansi", ] @@ -6038,12 +5961,9 @@ checksum = "3eb8486b569e12e2c32ad3e204dbaba5e4b5b216e9367044f25f1dba42341773" [[package]] name = "pxfm" -version = "0.1.27" +version = "0.1.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7186d3822593aa4393561d186d1393b3923e9d6163d3fbfd6e825e3e6cf3e6a8" -dependencies = [ - "num-traits", -] +checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f" [[package]] name = "quick-xml" @@ -6056,9 +5976,9 @@ dependencies = [ [[package]] name = "quick-xml" -version = "0.38.3" +version = "0.39.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42a232e7487fc2ef313d96dde7948e7a3c05101870d8985e4fd8d26aedd27b89" +checksum = "958f21e8e7ceb5a1aa7fa87fab28e7c75976e0bfe7e23ff069e0a260f894067d" dependencies = [ "memchr", ] @@ -6074,10 +5994,10 @@ dependencies = [ "pin-project-lite", "quinn-proto", "quinn-udp", - "rustc-hash 2.1.1", - "rustls 0.23.32", - "socket2 0.6.0", - "thiserror 2.0.17", + "rustc-hash 2.1.2", + "rustls", + "socket2", + "thiserror 2.0.18", "tokio", "tracing", "web-time", @@ -6085,21 +6005,21 @@ dependencies = [ [[package]] name = "quinn-proto" -version = "0.11.13" +version = "0.11.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31" +checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098" dependencies = [ "aws-lc-rs", "bytes", - "getrandom 0.3.3", + "getrandom 0.3.4", "lru-slab", - "rand 0.9.2", + "rand 0.9.4", "ring", - "rustc-hash 2.1.1", - "rustls 0.23.32", + "rustc-hash 2.1.2", + "rustls", "rustls-pki-types", "slab", - "thiserror 2.0.17", + "thiserror 2.0.18", "tinyvec", "tracing", "web-time", @@ -6114,16 +6034,16 @@ dependencies = [ "cfg_aliases", "libc", "once_cell", - "socket2 0.6.0", + "socket2", "tracing", "windows-sys 0.60.2", ] [[package]] name = "quote" -version = "1.0.40" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] @@ -6134,6 +6054,12 @@ version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + [[package]] name = "radium" version = "0.7.0" @@ -6142,9 +6068,9 @@ checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" [[package]] name = "rand" -version = "0.8.5" +version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a" dependencies = [ "libc", "rand_chacha 0.3.1", @@ -6153,23 +6079,23 @@ dependencies = [ [[package]] name = "rand" -version = "0.9.2" +version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" +checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea" dependencies = [ "rand_chacha 0.9.0", - "rand_core 0.9.3", + "rand_core 0.9.5", ] [[package]] name = "rand" -version = "0.10.0" +version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc266eb313df6c5c09c1c7b1fbe2510961e5bcd3add930c1e31f7ed9da0feff8" +checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" dependencies = [ "chacha20 0.10.0", - "getrandom 0.4.1", - "rand_core 0.10.0", + "getrandom 0.4.2", + "rand_core 0.10.1", ] [[package]] @@ -6189,7 +6115,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" dependencies = [ "ppv-lite86", - "rand_core 0.9.3", + "rand_core 0.9.5", ] [[package]] @@ -6198,29 +6124,29 @@ version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" dependencies = [ - "getrandom 0.2.16", + "getrandom 0.2.17", ] [[package]] name = "rand_core" -version = "0.9.3" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" dependencies = [ - "getrandom 0.3.3", + "getrandom 0.3.4", ] [[package]] name = "rand_core" -version = "0.10.0" +version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba" +checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" [[package]] name = "range-alloc" -version = "0.1.4" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3d6831663a5098ea164f89cff59c6284e95f4e3c76ce9848d4529f5ccca9bde" +checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08" [[package]] name = "rangemap" @@ -6263,7 +6189,7 @@ dependencies = [ "proc-macro2", "quote", "rayon", - "syn 2.0.106", + "syn 2.0.117", "uuid", ] @@ -6275,9 +6201,9 @@ checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539" [[package]] name = "rayon" -version = "1.11.0" +version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f" +checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d" dependencies = [ "either", "rayon-core", @@ -6322,7 +6248,17 @@ checksum = "6717cf23b488adf64b9d711329542ba34de147df262370221940dfabc2c91358" dependencies = [ "bytemuck", "core_maths", - "font-types", + "font-types 0.10.1", +] + +[[package]] +name = "read-fonts" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b634fabf032fab15307ffd272149b622260f55974d9fad689292a5d33df02e5" +dependencies = [ + "bytemuck", + "font-types 0.11.3", ] [[package]] @@ -6336,11 +6272,20 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.5.17" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags 2.11.1", +] + +[[package]] +name = "redox_syscall" +version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5407465600fb0548f1442edf71dd20683c6ed326200ace4b1ef0763521bb3b77" +checksum = "f450ad9c3b1da563fb6948a8e0fb0fb9269711c9c73d9ea1de5058c79c8d643a" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", ] [[package]] @@ -6349,7 +6294,7 @@ version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43" dependencies = [ - "getrandom 0.2.16", + "getrandom 0.2.17", "libredox", "thiserror 1.0.69", ] @@ -6360,16 +6305,16 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" dependencies = [ - "getrandom 0.2.16", + "getrandom 0.2.17", "libredox", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] name = "regex" -version = "1.11.2" +version = "1.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23d7fd106d8c02486a8d64e778353d1cffe08ce79ac2e82f540c86d0facf6912" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" dependencies = [ "aho-corasick", "memchr", @@ -6379,9 +6324,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.10" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b9458fa0bfeeac22b5ca447c63aaf45f28439a709ccd244698632f9aa6394d6" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" dependencies = [ "aho-corasick", "memchr", @@ -6390,9 +6335,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.6" +version = "0.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001" +checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" [[package]] name = "region" @@ -6424,79 +6369,36 @@ checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832" [[package]] name = "reqwest" -version = "0.11.27" +version = "0.12.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" +checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147" dependencies = [ - "async-compression", - "base64 0.21.7", + "base64 0.22.1", "bytes", - "encoding_rs", + "futures-channel", "futures-core", "futures-util", - "h2 0.3.27", - "http 0.2.12", - "http-body 0.4.6", - "hyper 0.14.32", - "hyper-rustls 0.24.2", - "ipnet", - "js-sys", - "log", - "mime", - "once_cell", - "percent-encoding", - "pin-project-lite", - "rustls 0.21.12", - "rustls-pemfile 1.0.4", - "serde", - "serde_json", - "serde_urlencoded", - "sync_wrapper 0.1.2", - "system-configuration 0.5.1", - "tokio", - "tokio-rustls 0.24.1", - "tokio-util", - "tower-service", - "url", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", - "webpki-roots 0.25.4", - "winreg", -] - -[[package]] -name = "reqwest" -version = "0.12.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d429f34c8092b2d42c7c93cec323bb4adeb7c67698f70839adec842ec10c7ceb" -dependencies = [ - "base64 0.22.1", - "bytes", - "futures-channel", - "futures-core", - "futures-util", - "h2 0.4.12", - "http 1.3.1", - "http-body 1.0.1", - "http-body-util", - "hyper 1.7.0", - "hyper-rustls 0.27.7", - "hyper-util", + "h2", + "http", + "http-body", + "http-body-util", + "hyper", + "hyper-rustls", + "hyper-util", "js-sys", "log", "percent-encoding", "pin-project-lite", "quinn", - "rustls 0.23.32", - "rustls-native-certs 0.8.2", + "rustls", + "rustls-native-certs 0.8.3", "rustls-pki-types", "serde", "serde_json", "serde_urlencoded", - "sync_wrapper 1.0.2", + "sync_wrapper", "tokio", - "tokio-rustls 0.26.3", + "tokio-rustls", "tower", "tower-http", "tower-service", @@ -6504,14 +6406,14 @@ dependencies = [ "wasm-bindgen", "wasm-bindgen-futures", "web-sys", - "webpki-roots 1.0.3", + "webpki-roots 1.0.7", ] [[package]] name = "reqwest" -version = "0.13.2" +version = "0.13.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801" +checksum = "62e0021ea2c22aed41653bc7e1419abb2c97e038ff2c33d0e1309e49a97deec0" dependencies = [ "base64 0.22.1", "bytes", @@ -6519,12 +6421,12 @@ dependencies = [ "futures-channel", "futures-core", "futures-util", - "h2 0.4.12", - "http 1.3.1", - "http-body 1.0.1", + "h2", + "http", + "http-body", "http-body-util", - "hyper 1.7.0", - "hyper-rustls 0.27.7", + "hyper", + "hyper-rustls", "hyper-tls", "hyper-util", "js-sys", @@ -6534,15 +6436,15 @@ dependencies = [ "percent-encoding", "pin-project-lite", "quinn", - "rustls 0.23.32", + "rustls", "rustls-pki-types", "rustls-platform-verifier", "serde", "serde_json", - "sync_wrapper 1.0.2", + "sync_wrapper", "tokio", "tokio-native-tls", - "tokio-rustls 0.26.3", + "tokio-rustls", "tower", "tower-http", "tower-service", @@ -6563,7 +6465,7 @@ dependencies = [ "dispatch2", "js-sys", "log", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-app-kit 0.3.2", "objc2-core-foundation", "objc2-foundation 0.3.2", @@ -6584,7 +6486,7 @@ checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" dependencies = [ "cc", "cfg-if", - "getrandom 0.2.16", + "getrandom 0.2.17", "libc", "untrusted", "windows-sys 0.52.0", @@ -6598,9 +6500,9 @@ checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97" [[package]] name = "rsa" -version = "0.9.8" +version = "0.9.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78928ac1ed176a5ca1d17e578a1825f3d81ca54cf41053a592584b020cfd691b" +checksum = "b8573f03f5883dcaebdfcf4725caa1ecb9c15b2ef50c43a07b816e06799bb12d" dependencies = [ "const-oid 0.9.6", "digest 0.10.7", @@ -6643,7 +6545,7 @@ dependencies = [ "serde", "serde_json", "serde_yaml", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -6668,12 +6570,6 @@ dependencies = [ "triomphe", ] -[[package]] -name = "rustc-demangle" -version = "0.1.26" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace" - [[package]] name = "rustc-hash" version = "1.1.0" @@ -6682,9 +6578,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" [[package]] name = "rustc-hash" -version = "2.1.1" +version = "2.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" +checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe" [[package]] name = "rustc_version" @@ -6710,7 +6606,7 @@ version = "0.38.44" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "errno", "libc", "linux-raw-sys 0.4.15", @@ -6719,40 +6615,28 @@ dependencies = [ [[package]] name = "rustix" -version = "1.1.2" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "errno", "libc", - "linux-raw-sys 0.11.0", + "linux-raw-sys 0.12.1", "windows-sys 0.61.2", ] [[package]] name = "rustls" -version = "0.21.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e" -dependencies = [ - "log", - "ring", - "rustls-webpki 0.101.7", - "sct", -] - -[[package]] -name = "rustls" -version = "0.23.32" +version = "0.23.40" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd3c25631629d034ce7cd9940adc9d45762d46de2b0f57193c4443b92c6d4d40" +checksum = "ef86cd5876211988985292b91c96a8f2d298df24e75989a43a3c73f2d4d8168b" dependencies = [ "aws-lc-rs", "once_cell", "ring", "rustls-pki-types", - "rustls-webpki 0.103.6", + "rustls-webpki", "subtle", "zeroize", ] @@ -6764,7 +6648,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5bfb394eeed242e909609f56089eecfe5fda225042e8b171791b9c95f5931e5" dependencies = [ "openssl-probe 0.1.6", - "rustls-pemfile 2.2.0", + "rustls-pemfile", "rustls-pki-types", "schannel", "security-framework 2.11.1", @@ -6772,23 +6656,14 @@ dependencies = [ [[package]] name = "rustls-native-certs" -version = "0.8.2" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9980d917ebb0c0536119ba501e90834767bffc3d60641457fd84a1f3fd337923" +checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63" dependencies = [ - "openssl-probe 0.1.6", + "openssl-probe 0.2.1", "rustls-pki-types", "schannel", - "security-framework 3.5.1", -] - -[[package]] -name = "rustls-pemfile" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" -dependencies = [ - "base64 0.21.7", + "security-framework 3.7.0", ] [[package]] @@ -6802,9 +6677,9 @@ dependencies = [ [[package]] name = "rustls-pki-types" -version = "1.12.0" +version = "1.14.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79" +checksum = "30a7197ae7eb376e574fe940d068c30fe0462554a3ddbe4eca7838e049c937a9" dependencies = [ "web-time", "zeroize", @@ -6812,20 +6687,20 @@ dependencies = [ [[package]] name = "rustls-platform-verifier" -version = "0.6.2" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784" +checksum = "26d1e2536ce4f35f4846aa13bff16bd0ff40157cdb14cc056c7b14ba41233ba0" dependencies = [ "core-foundation 0.10.1", "core-foundation-sys", "jni", "log", "once_cell", - "rustls 0.23.32", - "rustls-native-certs 0.8.2", + "rustls", + "rustls-native-certs 0.8.3", "rustls-platform-verifier-android", - "rustls-webpki 0.103.6", - "security-framework 3.5.1", + "rustls-webpki", + "security-framework 3.7.0", "security-framework-sys", "webpki-root-certs", "windows-sys 0.61.2", @@ -6839,19 +6714,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f" [[package]] name = "rustls-webpki" -version = "0.101.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "rustls-webpki" -version = "0.103.6" +version = "0.103.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8572f3c2cb9934231157b45499fc41e1f58c589fdfb81a844ba873265e80f8eb" +checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e" dependencies = [ "aws-lc-rs", "ring", @@ -6876,9 +6741,9 @@ dependencies = [ [[package]] name = "ryu" -version = "1.0.20" +version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" [[package]] name = "salsa20" @@ -6900,9 +6765,9 @@ dependencies = [ [[package]] name = "schannel" -version = "0.1.28" +version = "0.1.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1" +checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939" dependencies = [ "windows-sys 0.61.2", ] @@ -6936,7 +6801,7 @@ checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -6950,16 +6815,6 @@ dependencies = [ "sha2 0.10.9", ] -[[package]] -name = "sct" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" -dependencies = [ - "ring", - "untrusted", -] - [[package]] name = "sctk-adwaita" version = "0.10.1" @@ -6968,7 +6823,7 @@ checksum = "b6277f0217056f77f1d8f49f2950ac6c278c0d607c45f5ee99328d792ede24ec" dependencies = [ "ab_glyph", "log", - "memmap2 0.9.9", + "memmap2 0.9.10", "smithay-client-toolkit 0.19.2", "tiny-skia", ] @@ -6993,7 +6848,7 @@ version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "core-foundation 0.9.4", "core-foundation-sys", "libc", @@ -7002,11 +6857,11 @@ dependencies = [ [[package]] name = "security-framework" -version = "3.5.1" +version = "3.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef" +checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "core-foundation 0.10.1", "core-foundation-sys", "libc", @@ -7015,9 +6870,9 @@ dependencies = [ [[package]] name = "security-framework-sys" -version = "2.15.0" +version = "2.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0" +checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3" dependencies = [ "core-foundation-sys", "libc", @@ -7031,9 +6886,9 @@ checksum = "b12e76d157a900eb52e81bc6e9f3069344290341720e9178cde2407113ac8d89" [[package]] name = "semver" -version = "1.0.27" +version = "1.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" [[package]] name = "serde" @@ -7074,20 +6929,20 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "serde_json" -version = "1.0.145" +version = "1.0.149" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" dependencies = [ "itoa", "memchr", - "ryu", "serde", "serde_core", + "zmij", ] [[package]] @@ -7098,7 +6953,7 @@ checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -7112,9 +6967,9 @@ dependencies = [ [[package]] name = "serde_spanned" -version = "1.0.4" +version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776" +checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26" dependencies = [ "serde_core", ] @@ -7165,6 +7020,17 @@ dependencies = [ "digest 0.10.7", ] +[[package]] +name = "sha1" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.0", + "digest 0.11.3", +] + [[package]] name = "sha2" version = "0.10.9" @@ -7178,20 +7044,20 @@ dependencies = [ [[package]] name = "sha2" -version = "0.11.0-rc.5" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7c5f3b1e2dc8aad28310d8410bd4d7e180eca65fca176c52ab00d364475d0024" +checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4" dependencies = [ "cfg-if", - "cpufeatures 0.2.17", - "digest 0.11.0-rc.11", + "cpufeatures 0.3.0", + "digest 0.11.3", ] [[package]] name = "shell-words" -version = "1.1.0" +version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde" +checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77" [[package]] name = "shlex" @@ -7201,10 +7067,11 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" [[package]] name = "signal-hook-registry" -version = "1.4.7" +version = "1.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7664a098b8e616bdfcc2dc0e9ac44eb231eedf41db4e9fe95d8d32ec728dedad" +checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" dependencies = [ + "errno", "libc", ] @@ -7220,9 +7087,25 @@ dependencies = [ [[package]] name = "simd-adler32" -version = "0.3.7" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214" + +[[package]] +name = "simd_cesu8" +version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" +checksum = "94f90157bb87cddf702797c5dadfa0be7d266cdf49e22da2fcaa32eff75b2c33" +dependencies = [ + "rustc_version", + "simdutf8", +] + +[[package]] +name = "simdutf8" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" [[package]] name = "simple-file-manifest" @@ -7230,6 +7113,17 @@ version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5dd19be0257552dd56d1bb6946f89f193c6e5b9f13cc9327c4bc84a357507c74" +[[package]] +name = "simplelog" +version = "0.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16257adbfaef1ee58b1363bdc0664c9b8e1e30aed86049635fb5f147d065a9c0" +dependencies = [ + "log", + "termcolor", + "time", +] + [[package]] name = "single-instance" version = "0.3.3" @@ -7237,7 +7131,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4637485391f8545c9d3dbf60f9d9aab27a90c789a700999677583bcb17c8795d" dependencies = [ "libc", - "nix 0.23.2", + "nix", "thiserror 1.0.69", "widestring 0.4.3", "winapi", @@ -7245,9 +7139,9 @@ dependencies = [ [[package]] name = "siphasher" -version = "1.0.2" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e" +checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649" [[package]] name = "skrifa" @@ -7256,14 +7150,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8c31071dedf532758ecf3fed987cdb4bd9509f900e026ab684b4ecb81ea49841" dependencies = [ "bytemuck", - "read-fonts", + "read-fonts 0.35.0", +] + +[[package]] +name = "skrifa" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fbdfe3d2475fbd7ddd1f3e5cf8288a30eb3e5f95832829570cd88115a7434ac" +dependencies = [ + "bytemuck", + "read-fonts 0.37.0", ] [[package]] name = "slab" -version = "0.4.11" +version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" [[package]] name = "slotmap" @@ -7286,13 +7190,13 @@ version = "0.19.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3457dea1f0eb631b4034d61d4d8c32074caa6cd1ab2d59f2327bd8461e2c0016" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "calloop 0.13.0", "calloop-wayland-source 0.3.0", "cursor-icon", "libc", "log", - "memmap2 0.9.9", + "memmap2 0.9.10", "rustix 0.38.44", "thiserror 1.0.69", "wayland-backend", @@ -7311,15 +7215,15 @@ version = "0.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0512da38f5e2b31201a93524adb8d3136276fa4fe4aafab4e1f727a82b534cc0" dependencies = [ - "bitflags 2.9.4", - "calloop 0.14.3", + "bitflags 2.11.1", + "calloop 0.14.4", "calloop-wayland-source 0.4.1", "cursor-icon", "libc", "log", - "memmap2 0.9.9", - "rustix 1.1.2", - "thiserror 2.0.17", + "memmap2 0.9.10", + "rustix 1.1.4", + "thiserror 2.0.18", "wayland-backend", "wayland-client", "wayland-csd-frame", @@ -7370,27 +7274,17 @@ dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.106", -] - -[[package]] -name = "socket2" -version = "0.5.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678" -dependencies = [ - "libc", - "windows-sys 0.52.0", + "syn 2.0.117", ] [[package]] name = "socket2" -version = "0.6.0" +version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807" +checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e" dependencies = [ "libc", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -7403,16 +7297,16 @@ dependencies = [ "bytemuck", "fastrand", "js-sys", - "memmap2 0.9.9", + "memmap2 0.9.10", "ndk", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-core-foundation", "objc2-core-graphics", "objc2-foundation 0.3.2", "objc2-quartz-core 0.3.2", "raw-window-handle", - "redox_syscall 0.5.17", - "rustix 1.1.2", + "redox_syscall 0.5.18", + "rustix 1.1.4", "tiny-xlib", "tracing", "wasm-bindgen", @@ -7448,7 +7342,7 @@ version = "0.3.0+sdk-1.3.268.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", ] [[package]] @@ -7463,21 +7357,21 @@ dependencies = [ [[package]] name = "srp" -version = "0.7.0-rc.1" +version = "0.7.0-rc.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a0b7d0b0d27b2475e779315c09af698ac9f6d40016bc011bf3fa0f0054ce38ed" +checksum = "4b5f622c2d21b826b3501f4c620ccc4696e4a09a6b51727fcb21036dec87c101" dependencies = [ - "crypto-bigint 0.7.0-rc.25", - "crypto-common 0.2.0", - "digest 0.11.0-rc.11", + "crypto-bigint 0.7.3", + "crypto-common 0.2.1", + "digest 0.11.3", "subtle", ] [[package]] name = "stable_deref_trait" -version = "1.2.0" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" [[package]] name = "static_assertions" @@ -7491,12 +7385,6 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731" -[[package]] -name = "strsim" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" - [[package]] name = "strsim" version = "0.11.1" @@ -7517,11 +7405,11 @@ checksum = "0193cc4331cfd2f3d2011ef287590868599a2f33c3e69bc22c1a3d3acf9e02fb" [[package]] name = "swash" -version = "0.2.6" +version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47846491253e976bdd07d0f9cc24b7daf24720d11309302ccbbc6e6b6e53550a" +checksum = "842f3cd369c2ba38966204f983eaa5e54a8e84a7d7159ed36ade2b6c335aae64" dependencies = [ - "skrifa", + "skrifa 0.40.0", "yazi", "zeno", ] @@ -7539,21 +7427,15 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.106" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] -[[package]] -name = "sync_wrapper" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" - [[package]] name = "sync_wrapper" version = "1.0.2" @@ -7571,7 +7453,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -7585,34 +7467,13 @@ dependencies = [ [[package]] name = "system-configuration" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7" -dependencies = [ - "bitflags 1.3.2", - "core-foundation 0.9.4", - "system-configuration-sys 0.5.0", -] - -[[package]] -name = "system-configuration" -version = "0.6.1" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b" +checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "core-foundation 0.9.4", - "system-configuration-sys 0.6.0", -] - -[[package]] -name = "system-configuration-sys" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9" -dependencies = [ - "core-foundation-sys", - "libc", + "system-configuration-sys", ] [[package]] @@ -7651,9 +7512,9 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" [[package]] name = "tar" -version = "0.4.44" +version = "0.4.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a" +checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973" dependencies = [ "filetime", "libc", @@ -7673,21 +7534,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b1e66e07de489fe43a46678dd0b8df65e0c973909df1b60ba33874e297ba9b9" dependencies = [ "quick-xml 0.37.5", - "thiserror 2.0.17", + "thiserror 2.0.18", "windows 0.61.3", "windows-version", ] [[package]] name = "tempfile" -version = "3.22.0" +version = "3.27.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "84fa4d11fadde498443cca10fd3ac23c951f0dc59e080e9f4b93d4df4e4eea53" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom 0.3.3", + "getrandom 0.4.2", "once_cell", - "rustix 1.1.2", + "rustix 1.1.4", "windows-sys 0.61.2", ] @@ -7711,11 +7572,11 @@ dependencies = [ [[package]] name = "thiserror" -version = "2.0.17" +version = "2.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" dependencies = [ - "thiserror-impl 2.0.17", + "thiserror-impl 2.0.18", ] [[package]] @@ -7726,46 +7587,49 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "thiserror-impl" -version = "2.0.17" +version = "2.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "time" -version = "0.3.44" +version = "0.3.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d" +checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c" dependencies = [ "deranged", "itoa", + "js-sys", + "libc", "num-conv", + "num_threads", "powerfmt", - "serde", + "serde_core", "time-core", "time-macros", ] [[package]] name = "time-core" -version = "0.1.6" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b" +checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca" [[package]] name = "time-macros" -version = "0.2.24" +version = "0.2.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3" +checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215" dependencies = [ "num-conv", "time-core", @@ -7799,22 +7663,22 @@ dependencies = [ [[package]] name = "tiny-xlib" -version = "0.2.4" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0324504befd01cab6e0c994f34b2ffa257849ee019d3fb3b64fb2c858887d89e" +checksum = "a90a0ca3ee6a69f2ad28fd11621a4c3f03b371f366be500b64df260c4ffbafb4" dependencies = [ "as-raw-xcb-connection", - "ctor-lite", - "libloading 0.8.8", + "ctor", + "libloading 0.8.9", "pkg-config", "tracing", ] [[package]] name = "tinystr" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" +checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d" dependencies = [ "displaydoc", "zerovec", @@ -7822,9 +7686,9 @@ dependencies = [ [[package]] name = "tinyvec" -version = "1.10.0" +version = "1.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa" +checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3" dependencies = [ "tinyvec_macros", ] @@ -7853,36 +7717,33 @@ checksum = "2d2e76690929402faae40aebdda620a2c0e25dd6d3b9afe48867dfd95991f4bd" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "tokio" -version = "1.47.1" +version = "1.52.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038" +checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6" dependencies = [ - "backtrace", "bytes", - "io-uring", "libc", "mio", "pin-project-lite", - "slab", - "socket2 0.6.0", + "socket2", "tokio-macros", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] name = "tokio-macros" -version = "2.5.0" +version = "2.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8" +checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -7897,21 +7758,11 @@ dependencies = [ [[package]] name = "tokio-rustls" -version = "0.24.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" -dependencies = [ - "rustls 0.21.12", - "tokio", -] - -[[package]] -name = "tokio-rustls" -version = "0.26.3" +version = "0.26.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05f63835928ca123f1bef57abbcd23bb2ba0ac9ae1235f1e65bda0d06e7786bd" +checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61" dependencies = [ - "rustls 0.23.32", + "rustls", "tokio", ] @@ -7923,19 +7774,19 @@ checksum = "489a59b6730eda1b0171fcfda8b121f4bee2b35cba8645ca35c5f7ba3eb736c1" dependencies = [ "futures-util", "log", - "rustls 0.23.32", + "rustls", "rustls-pki-types", "tokio", - "tokio-rustls 0.26.3", + "tokio-rustls", "tungstenite 0.27.0", "webpki-roots 0.26.11", ] [[package]] name = "tokio-util" -version = "0.7.16" +version = "0.7.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14307c986784f72ef81c89db7d9e28d6ac26d16213b109ea501696195e6e3ce5" +checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098" dependencies = [ "bytes", "futures-core", @@ -7959,17 +7810,17 @@ dependencies = [ [[package]] name = "toml" -version = "0.9.11+spec-1.1.0" +version = "1.1.2+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3afc9a848309fe1aaffaed6e1546a7a14de1f935dc9d89d32afd9a44bab7c46" +checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee" dependencies = [ "indexmap", "serde_core", - "serde_spanned 1.0.4", - "toml_datetime 0.7.5+spec-1.1.0", + "serde_spanned 1.1.1", + "toml_datetime 1.1.1+spec-1.1.0", "toml_parser", "toml_writer", - "winnow 0.7.13", + "winnow 1.0.2", ] [[package]] @@ -7983,9 +7834,9 @@ dependencies = [ [[package]] name = "toml_datetime" -version = "0.7.5+spec-1.1.0" +version = "1.1.1+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347" +checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7" dependencies = [ "serde_core", ] @@ -8003,9 +7854,9 @@ dependencies = [ [[package]] name = "toml_edit" -version = "0.20.2" +version = "0.20.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "396e4d48bbb2b7554c944bde63101b5ae446cff6ec4a24227428f15eb72ef338" +checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81" dependencies = [ "indexmap", "toml_datetime 0.6.11", @@ -8023,28 +7874,28 @@ dependencies = [ "serde_spanned 0.6.9", "toml_datetime 0.6.11", "toml_write", - "winnow 0.7.13", + "winnow 0.7.15", ] [[package]] name = "toml_edit" -version = "0.23.10+spec-1.0.0" +version = "0.25.11+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269" +checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b" dependencies = [ "indexmap", - "toml_datetime 0.7.5+spec-1.1.0", + "toml_datetime 1.1.1+spec-1.1.0", "toml_parser", - "winnow 0.7.13", + "winnow 1.0.2", ] [[package]] name = "toml_parser" -version = "1.0.6+spec-1.1.0" +version = "1.1.2+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44" +checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526" dependencies = [ - "winnow 0.7.13", + "winnow 1.0.2", ] [[package]] @@ -8055,20 +7906,20 @@ checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801" [[package]] name = "toml_writer" -version = "1.0.6+spec-1.1.0" +version = "1.1.1+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607" +checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db" [[package]] name = "tower" -version = "0.5.2" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9" +checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" dependencies = [ "futures-core", "futures-util", "pin-project-lite", - "sync_wrapper 1.0.2", + "sync_wrapper", "tokio", "tower-layer", "tower-service", @@ -8081,12 +7932,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" dependencies = [ "async-compression", - "bitflags 2.9.4", + "bitflags 2.11.1", "bytes", "futures-core", "futures-util", - "http 1.3.1", - "http-body 1.0.1", + "http", + "http-body", "http-body-util", "iri-string", "pin-project-lite", @@ -8111,9 +7962,9 @@ checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" [[package]] name = "tracing" -version = "0.1.41" +version = "0.1.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" dependencies = [ "log", "pin-project-lite", @@ -8129,36 +7980,36 @@ checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "tracing-core" -version = "0.1.34" +version = "0.1.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" dependencies = [ "once_cell", ] [[package]] name = "tray-icon" -version = "0.21.2" +version = "0.21.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3d5572781bee8e3f994d7467084e1b1fd7a93ce66bd480f8156ba89dee55a2b" +checksum = "a5e85aa143ceb072062fc4d6356c1b520a51d636e7bc8e77ec94be3608e5e80c" dependencies = [ "crossbeam-channel", "dirs 6.0.0", "libappindicator", "muda", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-app-kit 0.3.2", "objc2-core-foundation", "objc2-core-graphics", "objc2-foundation 0.3.2", "once_cell", "png 0.17.16", - "thiserror 2.0.17", + "thiserror 2.0.18", "windows-sys 0.60.2", ] @@ -8197,14 +8048,14 @@ dependencies = [ "byteorder", "bytes", "data-encoding", - "http 1.3.1", + "http", "httparse", "log", - "rand 0.8.5", - "rustls 0.23.32", + "rand 0.8.6", + "rustls", "rustls-native-certs 0.7.3", "rustls-pki-types", - "sha1", + "sha1 0.10.6", "thiserror 1.0.69", "utf-8", ] @@ -8217,14 +8068,14 @@ checksum = "eadc29d668c91fcc564941132e17b28a7ceb2f3ebf0b9dae3e03fd7a6748eb0d" dependencies = [ "bytes", "data-encoding", - "http 1.3.1", + "http", "httparse", "log", - "rand 0.9.2", - "rustls 0.23.32", + "rand 0.9.4", + "rustls", "rustls-pki-types", - "sha1", - "thiserror 2.0.17", + "sha1 0.10.6", + "thiserror 2.0.18", "utf-8", ] @@ -8238,17 +8089,23 @@ dependencies = [ "static_assertions", ] +[[package]] +name = "typed-path" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e28f89b80c87b8fb0cf04ab448d5dd0dd0ade2f8891bae878de66a75a28600e" + [[package]] name = "typenum" -version = "1.19.0" +version = "1.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb" +checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de" [[package]] name = "typewit" -version = "1.14.2" +version = "1.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8c1ae7cc0fdb8b842d65d127cb981574b0d2b249b74d1c7a2986863dc134f71" +checksum = "214ca0b2191785cbc06209b9ca1861e048e39b5ba33574b3cedd58363d5bb5f6" dependencies = [ "typewit_proc_macros", ] @@ -8261,13 +8118,13 @@ checksum = "e36a83ea2b3c704935a01b4642946aadd445cea40b10935e3f8bd8052b8193d6" [[package]] name = "uds_windows" -version = "1.1.0" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89daebc3e6fd160ac4aa9fc8b3bf71e1f74fbf92367ae71fb83a037e8bf164b9" +checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e" dependencies = [ "memoffset 0.9.1", "tempfile", - "winapi", + "windows-sys 0.61.2", ] [[package]] @@ -8287,9 +8144,9 @@ checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5" [[package]] name = "unicode-ident" -version = "1.0.19" +version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "unicode-linebreak" @@ -8305,9 +8162,9 @@ checksum = "383ad40bb927465ec0ce7720e033cb4ca06912855fc35db31b5755d0de75b1ee" [[package]] name = "unicode-segmentation" -version = "1.12.0" +version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493" +checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c" [[package]] name = "unicode-width" @@ -8327,18 +8184,18 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea" dependencies = [ - "crypto-common 0.1.6", + "crypto-common 0.1.7", "subtle", ] [[package]] name = "universal-hash" -version = "0.6.0-rc.10" +version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "058482a494bb3c9c39447d8b40a3a0f38ebb3dccaf02c5a2d681e69035f8da11" +checksum = "f4987bdc12753382e0bec4a65c50738ffaabc998b9cdd1f952fb5f39b0048a96" dependencies = [ - "crypto-common 0.2.0", - "subtle", + "crypto-common 0.2.1", + "ctutils", ] [[package]] @@ -8355,14 +8212,15 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "url" -version = "2.5.7" +version = "2.5.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" dependencies = [ "form_urlencoded", "idna", "percent-encoding", "serde", + "serde_derive", ] [[package]] @@ -8391,30 +8249,18 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" [[package]] name = "uuid" -version = "1.18.1" +version = "1.23.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" +checksum = "ddd74a9687298c6858e9b88ec8935ec45d22e8fd5e6394fa1bd4e99a87789c76" dependencies = [ - "getrandom 0.3.3", + "getrandom 0.4.2", "js-sys", "md-5", - "rand 0.9.2", - "serde", - "uuid-macro-internal", + "rand 0.10.1", + "serde_core", "wasm-bindgen", ] -[[package]] -name = "uuid-macro-internal" -version = "1.18.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9384a660318abfbd7f8932c34d67e4d1ec511095f95972ddc01e19d7ba8413f" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.106", -] - [[package]] name = "vcpkg" version = "0.2.15" @@ -8458,22 +8304,13 @@ version = "0.11.1+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" -[[package]] -name = "wasi" -version = "0.14.7+wasi-0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "883478de20367e224c0090af9cf5f9fa85bed63a95c1abf3afc5c083ebc06e8c" -dependencies = [ - "wasip2", -] - [[package]] name = "wasip2" -version = "1.0.1+wasi-0.2.4" +version = "1.0.3+wasi-0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7" +checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6" dependencies = [ - "wit-bindgen 0.46.0", + "wit-bindgen 0.57.1", ] [[package]] @@ -8487,9 +8324,9 @@ dependencies = [ [[package]] name = "wasm-bindgen" -version = "0.2.103" +version = "0.2.120" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab10a69fbd0a177f5f649ad4d8d3305499c42bab9aef2f7ff592d0ec8f833819" +checksum = "df52b6d9b87e0c74c9edfa1eb2d9bf85e5d63515474513aa50fa181b3c4f5db1" dependencies = [ "cfg-if", "once_cell", @@ -8498,38 +8335,21 @@ dependencies = [ "wasm-bindgen-shared", ] -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.103" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bb702423545a6007bbc368fde243ba47ca275e549c8a28617f56f6ba53b1d1c" -dependencies = [ - "bumpalo", - "log", - "proc-macro2", - "quote", - "syn 2.0.106", - "wasm-bindgen-shared", -] - [[package]] name = "wasm-bindgen-futures" -version = "0.4.53" +version = "0.4.70" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a0b221ff421256839509adbb55998214a70d829d3a28c69b4a6672e9d2a42f67" +checksum = "af934872acec734c2d80e6617bbb5ff4f12b052dd8e6332b0817bce889516084" dependencies = [ - "cfg-if", "js-sys", - "once_cell", "wasm-bindgen", - "web-sys", ] [[package]] name = "wasm-bindgen-macro" -version = "0.2.103" +version = "0.2.120" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc65f4f411d91494355917b605e1480033152658d71f722a90647f56a70c88a0" +checksum = "78b1041f495fb322e64aca85f5756b2172e35cd459376e67f2a6c9dffcedb103" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -8537,22 +8357,22 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.103" +version = "0.2.120" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffc003a991398a8ee604a401e194b6b3a39677b3173d6e74495eb51b82e99a32" +checksum = "9dcd0ff20416988a18ac686d4d4d0f6aae9ebf08a389ff5d29012b05af2a1b41" dependencies = [ + "bumpalo", "proc-macro2", "quote", - "syn 2.0.106", - "wasm-bindgen-backend", + "syn 2.0.117", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.103" +version = "0.2.120" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "293c37f4efa430ca14db3721dfbe48d8c33308096bd44d80ebaa775ab71ba1cf" +checksum = "49757b3c82ebf16c57d69365a142940b384176c24df52a087fb748e2085359ea" dependencies = [ "unicode-ident", ] @@ -8585,7 +8405,7 @@ version = "0.244.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "hashbrown 0.15.5", "indexmap", "semver", @@ -8607,13 +8427,13 @@ dependencies = [ [[package]] name = "wayland-backend" -version = "0.3.12" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fee64194ccd96bf648f42a65a7e589547096dfa702f7cadef84347b66ad164f9" +checksum = "2857dd20b54e916ec7253b3d6b4d5c4d7d4ca2c33c2e11c6c76a99bd8744755d" dependencies = [ "cc", "downcast-rs", - "rustix 1.1.2", + "rustix 1.1.4", "scoped-tls", "smallvec", "wayland-sys", @@ -8621,12 +8441,12 @@ dependencies = [ [[package]] name = "wayland-client" -version = "0.31.12" +version = "0.31.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8e6faa537fbb6c186cb9f1d41f2f811a4120d1b57ec61f50da451a0c5122bec" +checksum = "645c7c96bb74690c3189b5c9cb4ca1627062bb23693a4fad9d8c3de958260144" dependencies = [ - "bitflags 2.9.4", - "rustix 1.1.2", + "bitflags 2.11.1", + "rustix 1.1.4", "wayland-backend", "wayland-scanner", ] @@ -8637,29 +8457,29 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "cursor-icon", "wayland-backend", ] [[package]] name = "wayland-cursor" -version = "0.31.12" +version = "0.31.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5864c4b5b6064b06b1e8b74ead4a98a6c45a285fe7a0e784d24735f011fdb078" +checksum = "4a52d18780be9b1314328a3de5f930b73d2200112e3849ca6cb11822793fb34d" dependencies = [ - "rustix 1.1.2", + "rustix 1.1.4", "wayland-client", "xcursor", ] [[package]] name = "wayland-protocols" -version = "0.32.10" +version = "0.32.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baeda9ffbcfc8cd6ddaade385eaf2393bd2115a69523c735f12242353c3df4f3" +checksum = "563a85523cade2429938e790815fd7319062103b9f4a2dc806e9b53b95982d8f" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "wayland-backend", "wayland-client", "wayland-scanner", @@ -8671,7 +8491,7 @@ version = "20250721.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "40a1f863128dcaaec790d7b4b396cc9b9a7a079e878e18c47e6c2d2c5a8dcbb1" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "wayland-backend", "wayland-client", "wayland-protocols", @@ -8680,11 +8500,11 @@ dependencies = [ [[package]] name = "wayland-protocols-misc" -version = "0.3.10" +version = "0.3.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "791c58fdeec5406aa37169dd815327d1e47f334219b523444bc26d70ceb4c34e" +checksum = "6e9567599ef23e09b8dad6e429e5738d4509dfc46b3b21f32841a304d16b29c8" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "wayland-backend", "wayland-client", "wayland-protocols", @@ -8693,11 +8513,11 @@ dependencies = [ [[package]] name = "wayland-protocols-plasma" -version = "0.3.10" +version = "0.3.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa98634619300a535a9a97f338aed9a5ff1e01a461943e8346ff4ae26007306b" +checksum = "2b6d8cf1eb2c1c31ed1f5643c88a6e53538129d4af80030c8cabd1f9fa884d91" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "wayland-backend", "wayland-client", "wayland-protocols", @@ -8706,11 +8526,11 @@ dependencies = [ [[package]] name = "wayland-protocols-wlr" -version = "0.3.10" +version = "0.3.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e9597cdf02cf0c34cd5823786dce6b5ae8598f05c2daf5621b6e178d4f7345f3" +checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "wayland-backend", "wayland-client", "wayland-protocols", @@ -8719,20 +8539,20 @@ dependencies = [ [[package]] name = "wayland-scanner" -version = "0.31.8" +version = "0.31.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5423e94b6a63e68e439803a3e153a9252d5ead12fd853334e2ad33997e3889e3" +checksum = "9c324a910fd86ebdc364a3e61ec1f11737d3b1d6c273c0239ee8ff4bc0d24b4a" dependencies = [ "proc-macro2", - "quick-xml 0.38.3", + "quick-xml 0.39.2", "quote", ] [[package]] name = "wayland-sys" -version = "0.31.8" +version = "0.31.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e6dbfc3ac5ef974c92a2235805cc0114033018ae1290a72e474aa8b28cbbdfd" +checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be" dependencies = [ "dlib", "log", @@ -8742,9 +8562,9 @@ dependencies = [ [[package]] name = "web-sys" -version = "0.3.80" +version = "0.3.97" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbe734895e869dc429d78c4b433f8d17d95f8d05317440b4fad5ab2d33e596dc" +checksum = "2eadbac71025cd7b0834f20d1fe8472e8495821b4e9801eb0a60bd1f19827602" dependencies = [ "js-sys", "wasm-bindgen", @@ -8762,33 +8582,27 @@ dependencies = [ [[package]] name = "webpki-root-certs" -version = "1.0.6" +version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "804f18a4ac2676ffb4e8b5b5fa9ae38af06df08162314f96a68d2a363e21a8ca" +checksum = "f31141ce3fc3e300ae89b78c0dd67f9708061d1d2eda54b8209346fd6be9a92c" dependencies = [ "rustls-pki-types", ] -[[package]] -name = "webpki-roots" -version = "0.25.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1" - [[package]] name = "webpki-roots" version = "0.26.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9" dependencies = [ - "webpki-roots 1.0.3", + "webpki-roots 1.0.7", ] [[package]] name = "webpki-roots" -version = "1.0.3" +version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32b130c0d2d49f8b6889abc456e795e82525204f27c42cf767cf0d7734e089b8" +checksum = "52f5ee44c96cf55f1b349600768e3ece3a8f26010c05265ab73f945bb1a2eb9d" dependencies = [ "rustls-pki-types", ] @@ -8800,11 +8614,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bfe68bac7cde125de7a731c3400723cadaaf1703795ad3f4805f187459cd7a77" dependencies = [ "arrayvec", - "bitflags 2.9.4", + "bitflags 2.11.1", "cfg-if", "cfg_aliases", "document-features", - "hashbrown 0.16.0", + "hashbrown 0.16.1", "js-sys", "log", "naga", @@ -8831,11 +8645,11 @@ dependencies = [ "arrayvec", "bit-set", "bit-vec", - "bitflags 2.9.4", + "bitflags 2.11.1", "bytemuck", "cfg_aliases", "document-features", - "hashbrown 0.16.0", + "hashbrown 0.16.1", "indexmap", "log", "naga", @@ -8846,7 +8660,7 @@ dependencies = [ "raw-window-handle", "rustc-hash 1.1.0", "smallvec", - "thiserror 2.0.17", + "thiserror 2.0.18", "wgpu-core-deps-apple", "wgpu-core-deps-emscripten", "wgpu-core-deps-windows-linux-android", @@ -8891,7 +8705,7 @@ dependencies = [ "arrayvec", "ash", "bit-set", - "bitflags 2.9.4", + "bitflags 2.11.1", "block", "bytemuck", "cfg-if", @@ -8902,11 +8716,11 @@ dependencies = [ "gpu-alloc", "gpu-allocator", "gpu-descriptor", - "hashbrown 0.16.0", + "hashbrown 0.16.1", "js-sys", "khronos-egl", "libc", - "libloading 0.8.8", + "libloading 0.8.9", "log", "metal", "naga", @@ -8922,7 +8736,7 @@ dependencies = [ "raw-window-handle", "renderdoc-sys", "smallvec", - "thiserror 2.0.17", + "thiserror 2.0.18", "wasm-bindgen", "web-sys", "wgpu-types", @@ -8936,11 +8750,11 @@ version = "27.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "afdcf84c395990db737f2dd91628706cb31e86d72e53482320d368e52b5da5eb" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "bytemuck", "js-sys", "log", - "thiserror 2.0.17", + "thiserror 2.0.18", "web-sys", ] @@ -8998,7 +8812,7 @@ dependencies = [ "clipboard_wayland", "clipboard_x11", "raw-window-handle", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -9123,7 +8937,7 @@ checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -9134,7 +8948,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -9145,7 +8959,7 @@ checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -9156,7 +8970,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] @@ -9202,6 +9016,17 @@ dependencies = [ "windows-strings 0.4.2", ] +[[package]] +name = "windows-registry" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720" +dependencies = [ + "windows-link 0.2.1", + "windows-result 0.4.1", + "windows-strings 0.5.1", +] + [[package]] name = "windows-result" version = "0.2.0" @@ -9257,15 +9082,6 @@ dependencies = [ "windows-link 0.2.1", ] -[[package]] -name = "windows-sys" -version = "0.45.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" -dependencies = [ - "windows-targets 0.42.2", -] - [[package]] name = "windows-sys" version = "0.48.0" @@ -9299,7 +9115,7 @@ version = "0.60.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" dependencies = [ - "windows-targets 0.53.3", + "windows-targets 0.53.5", ] [[package]] @@ -9311,21 +9127,6 @@ dependencies = [ "windows-link 0.2.1", ] -[[package]] -name = "windows-targets" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" -dependencies = [ - "windows_aarch64_gnullvm 0.42.2", - "windows_aarch64_msvc 0.42.2", - "windows_i686_gnu 0.42.2", - "windows_i686_msvc 0.42.2", - "windows_x86_64_gnu 0.42.2", - "windows_x86_64_gnullvm 0.42.2", - "windows_x86_64_msvc 0.42.2", -] - [[package]] name = "windows-targets" version = "0.48.5" @@ -9359,19 +9160,19 @@ dependencies = [ [[package]] name = "windows-targets" -version = "0.53.3" +version = "0.53.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" dependencies = [ - "windows-link 0.1.3", - "windows_aarch64_gnullvm 0.53.0", - "windows_aarch64_msvc 0.53.0", - "windows_i686_gnu 0.53.0", - "windows_i686_gnullvm 0.53.0", - "windows_i686_msvc 0.53.0", - "windows_x86_64_gnu 0.53.0", - "windows_x86_64_gnullvm 0.53.0", - "windows_x86_64_msvc 0.53.0", + "windows-link 0.2.1", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", ] [[package]] @@ -9401,12 +9202,6 @@ dependencies = [ "windows-link 0.2.1", ] -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" - [[package]] name = "windows_aarch64_gnullvm" version = "0.48.5" @@ -9421,15 +9216,9 @@ checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" [[package]] name = "windows_aarch64_gnullvm" -version = "0.53.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.42.2" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" [[package]] name = "windows_aarch64_msvc" @@ -9445,15 +9234,9 @@ checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" [[package]] name = "windows_aarch64_msvc" -version = "0.53.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c" - -[[package]] -name = "windows_i686_gnu" -version = "0.42.2" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" [[package]] name = "windows_i686_gnu" @@ -9469,9 +9252,9 @@ checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" [[package]] name = "windows_i686_gnu" -version = "0.53.0" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" [[package]] name = "windows_i686_gnullvm" @@ -9481,15 +9264,9 @@ checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" [[package]] name = "windows_i686_gnullvm" -version = "0.53.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11" - -[[package]] -name = "windows_i686_msvc" -version = "0.42.2" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" [[package]] name = "windows_i686_msvc" @@ -9505,15 +9282,9 @@ checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" [[package]] name = "windows_i686_msvc" -version = "0.53.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.42.2" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" [[package]] name = "windows_x86_64_gnu" @@ -9529,15 +9300,9 @@ checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" [[package]] name = "windows_x86_64_gnu" -version = "0.53.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.42.2" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" [[package]] name = "windows_x86_64_gnullvm" @@ -9553,15 +9318,9 @@ checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" [[package]] name = "windows_x86_64_gnullvm" -version = "0.53.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.42.2" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" [[package]] name = "windows_x86_64_msvc" @@ -9577,20 +9336,20 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" [[package]] name = "windows_x86_64_msvc" -version = "0.53.0" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" [[package]] name = "winit" -version = "0.30.12" +version = "0.30.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c66d4b9ed69c4009f6321f762d6e61ad8a2389cd431b97cb1e146812e9e6c732" +checksum = "a6755fa58a9f8350bd1e472d4c3fcc25f824ec358933bba33306d0b63df5978d" dependencies = [ "ahash", "android-activity", "atomic-waker", - "bitflags 2.9.4", + "bitflags 2.11.1", "block2 0.5.1", "bytemuck", "calloop 0.13.0", @@ -9602,7 +9361,7 @@ dependencies = [ "dpi", "js-sys", "libc", - "memmap2 0.9.9", + "memmap2 0.9.10", "ndk", "objc2 0.5.2", "objc2-app-kit 0.2.2", @@ -9644,39 +9403,32 @@ dependencies = [ [[package]] name = "winnow" -version = "0.7.13" +version = "0.7.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf" +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945" dependencies = [ "memchr", ] [[package]] -name = "winreg" -version = "0.50.0" +name = "winnow" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" +checksum = "2ee1708bef14716a11bae175f579062d4554d95be2c6829f518df847b7b3fdd0" dependencies = [ - "cfg-if", - "windows-sys 0.48.0", + "memchr", ] [[package]] name = "winresource" -version = "0.1.30" +version = "0.1.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e287ced0f21cd11f4035fe946fd3af145f068d1acb708afd248100f89ec7432d" +checksum = "0986a8b1d586b7d3e4fe3d9ea39fb451ae22869dcea4aa109d287a374d866087" dependencies = [ - "toml 0.9.11+spec-1.1.0", + "toml 1.1.2+spec-1.1.0", "version_check", ] -[[package]] -name = "wit-bindgen" -version = "0.46.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" - [[package]] name = "wit-bindgen" version = "0.51.0" @@ -9686,6 +9438,12 @@ dependencies = [ "wit-bindgen-rust-macro", ] +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + [[package]] name = "wit-bindgen-core" version = "0.51.0" @@ -9707,7 +9465,7 @@ dependencies = [ "heck 0.5.0", "indexmap", "prettyplease", - "syn 2.0.106", + "syn 2.0.117", "wasm-metadata", "wit-bindgen-core", "wit-component", @@ -9723,7 +9481,7 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", "wit-bindgen-core", "wit-bindgen-rust", ] @@ -9735,7 +9493,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" dependencies = [ "anyhow", - "bitflags 2.9.4", + "bitflags 2.11.1", "indexmap", "log", "serde", @@ -9767,9 +9525,9 @@ dependencies = [ [[package]] name = "writeable" -version = "0.6.1" +version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" +checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4" [[package]] name = "wyz" @@ -9800,9 +9558,9 @@ dependencies = [ "as-raw-xcb-connection", "gethostname", "libc", - "libloading 0.8.8", + "libloading 0.8.9", "once_cell", - "rustix 1.1.2", + "rustix 1.1.4", "x11rb-protocol", ] @@ -9842,7 +9600,7 @@ checksum = "1301e935010a701ae5f8655edc0ad17c44bad3ac5ce8c39185f75453b720ae94" dependencies = [ "const-oid 0.9.6", "der", - "sha1", + "sha1 0.10.6", "signature", "spki", "tls_codec", @@ -9869,9 +9627,9 @@ dependencies = [ [[package]] name = "x509-parser" -version = "0.17.0" +version = "0.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4569f339c0c402346d4a75a9e39cf8dad310e287eef1ff56d4c68e5067f53460" +checksum = "d43b0f71ce057da06bc0851b23ee24f3f86190b07203dd8f567d0b706a185202" dependencies = [ "asn1-rs 0.7.1", "data-encoding", @@ -9880,7 +9638,7 @@ dependencies = [ "nom", "oid-registry 0.8.1", "rusticata-macros", - "thiserror 2.0.17", + "thiserror 2.0.18", "time", ] @@ -9891,7 +9649,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156" dependencies = [ "libc", - "rustix 1.1.2", + "rustix 1.1.4", ] [[package]] @@ -9906,7 +9664,7 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5" dependencies = [ - "bitflags 2.9.4", + "bitflags 2.11.1", "dlib", "log", "once_cell", @@ -9930,9 +9688,9 @@ dependencies = [ [[package]] name = "xml-rs" -version = "0.8.27" +version = "0.8.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fd8403733700263c6eb89f192880191f1b83e332f7a20371ddcf421c4a337c7" +checksum = "3ae8337f8a065cfc972643663ea4279e04e7256de865aa66fe25cec5fb912d3f" [[package]] name = "xz2" @@ -9966,11 +9724,10 @@ checksum = "e01738255b5a16e78bbb83e7fbba0a1e7dd506905cfc53f4622d89015a03fbb5" [[package]] name = "yoke" -version = "0.8.0" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" +checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca" dependencies = [ - "serde", "stable_deref_trait", "yoke-derive", "zerofrom", @@ -9978,21 +9735,21 @@ dependencies = [ [[package]] name = "yoke-derive" -version = "0.8.0" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" +checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", "synstructure", ] [[package]] name = "zbus" -version = "5.12.0" +version = "5.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b622b18155f7a93d1cd2dc8c01d2d6a44e08fb9ebb7b3f9e6ed101488bad6c91" +checksum = "c3bcbf15c8708d7fc1be0c993622e0a5cbd5e8b52bfa40afa4c3e0cd8d724ac1" dependencies = [ "async-broadcast", "async-executor", @@ -10008,15 +9765,16 @@ dependencies = [ "futures-core", "futures-lite", "hex", - "nix 0.30.1", + "libc", "ordered-stream", + "rustix 1.1.4", "serde", "serde_repr", "tracing", "uds_windows", "uuid", "windows-sys 0.61.2", - "winnow 0.7.13", + "winnow 1.0.2", "zbus_macros", "zbus_names", "zvariant", @@ -10024,14 +9782,14 @@ dependencies = [ [[package]] name = "zbus_macros" -version = "5.12.0" +version = "5.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1cdb94821ca8a87ca9c298b5d1cbd80e2a8b67115d99f6e4551ac49e42b6a314" +checksum = "51fa5406ad9175a8c825a931f8cf347116b531b3634fcb0b627c290f1f2516ff" dependencies = [ - "proc-macro-crate 3.4.0", + "proc-macro-crate 3.5.0", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", "zbus_names", "zvariant", "zvariant_utils", @@ -10039,13 +9797,12 @@ dependencies = [ [[package]] name = "zbus_names" -version = "4.2.0" +version = "4.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7be68e64bf6ce8db94f63e72f0c7eb9a60d733f7e0499e628dfab0f84d6bcb97" +checksum = "7074f3e50b894eac91750142016d30d0a89be8e67dbfd9704fb875825760e52d" dependencies = [ "serde", - "static_assertions", - "winnow 0.7.13", + "winnow 1.0.2", "zvariant", ] @@ -10063,70 +9820,70 @@ checksum = "2fe21bcc34ca7fe6dd56cc2cb1261ea59d6b93620215aefb5ea6032265527784" [[package]] name = "zerocopy" -version = "0.8.27" +version = "0.8.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c" +checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.27" +version = "0.8.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831" +checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "zerofrom" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df" dependencies = [ "zerofrom-derive", ] [[package]] name = "zerofrom-derive" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", "synstructure", ] [[package]] name = "zeroize" -version = "1.8.1" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" +checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" dependencies = [ "zeroize_derive", ] [[package]] name = "zeroize_derive" -version = "1.4.2" +version = "1.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" +checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", ] [[package]] name = "zerotrie" -version = "0.2.2" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" +checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf" dependencies = [ "displaydoc", "yoke", @@ -10135,9 +9892,9 @@ dependencies = [ [[package]] name = "zerovec" -version = "0.11.4" +version = "0.11.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" +checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239" dependencies = [ "yoke", "zerofrom", @@ -10146,33 +9903,13 @@ dependencies = [ [[package]] name = "zerovec-derive" -version = "0.11.1" +version = "0.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" +checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555" dependencies = [ "proc-macro2", "quote", - "syn 2.0.106", -] - -[[package]] -name = "zip" -version = "0.6.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261" -dependencies = [ - "aes 0.8.4", - "byteorder", - "bzip2", - "constant_time_eq", - "crc32fast", - "crossbeam-utils", - "flate2", - "hmac 0.12.1", - "pbkdf2 0.11.0", - "sha1", - "time", - "zstd 0.11.2+zstd.1.5.2", + "syn 2.0.117", ] [[package]] @@ -10188,22 +9925,35 @@ dependencies = [ "flate2", "indexmap", "memchr", - "thiserror 2.0.17", + "thiserror 2.0.18", "zopfli", ] [[package]] name = "zip" -version = "4.6.1" +version = "8.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "caa8cd6af31c3b31c6631b8f483848b91589021b28fffe50adada48d4f4d2ed1" +checksum = "2d04a6b5381502aa6087c94c669499eb1602eb9c5e8198e534de571f7154809b" dependencies = [ - "arbitrary", + "aes 0.9.0", + "bzip2 0.6.1", + "constant_time_eq", "crc32fast", + "deflate64", "flate2", + "getrandom 0.4.2", + "hmac 0.13.0", "indexmap", + "lzma-rust2", "memchr", + "pbkdf2 0.13.0", + "ppmd-rust", + "sha1 0.11.0", + "time", + "typed-path", + "zeroize", "zopfli", + "zstd", ] [[package]] @@ -10219,15 +9969,21 @@ dependencies = [ [[package]] name = "zlib-rs" -version = "0.5.2" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513" + +[[package]] +name = "zmij" +version = "1.0.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f06ae92f42f5e5c42443fd094f245eb656abf56dd7cce9b8b263236565e00f2" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" [[package]] name = "zopfli" -version = "0.8.2" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edfc5ee405f504cd4984ecc6f14d02d55cfda60fa4b689434ef4102aae150cd7" +checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249" dependencies = [ "bumpalo", "crc32fast", @@ -10237,39 +9993,19 @@ dependencies = [ [[package]] name = "zstd" -version = "0.11.2+zstd.1.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4" -dependencies = [ - "zstd-safe 5.0.2+zstd.1.5.2", -] - -[[package]] -name = "zstd" -version = "0.12.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a27595e173641171fc74a1232b7b1c7a7cb6e18222c11e9dfb9888fa424c53c" -dependencies = [ - "zstd-safe 6.0.6", -] - -[[package]] -name = "zstd-safe" -version = "5.0.2+zstd.1.5.2" +version = "0.13.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" dependencies = [ - "libc", - "zstd-sys", + "zstd-safe", ] [[package]] name = "zstd-safe" -version = "6.0.6" +version = "7.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee98ffd0b48ee95e6c5168188e44a54550b1564d9d530ee21d5f0eaed1069581" +checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d" dependencies = [ - "libc", "zstd-sys", ] @@ -10291,50 +10027,50 @@ checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9" [[package]] name = "zune-jpeg" -version = "0.5.12" +version = "0.5.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "410e9ecef634c709e3831c2cfdb8d9c32164fae1c67496d5b68fff728eec37fe" +checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296" dependencies = [ "zune-core", ] [[package]] name = "zvariant" -version = "5.8.0" +version = "5.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2be61892e4f2b1772727be11630a62664a1826b62efa43a6fe7449521cb8744c" +checksum = "1c1567a6ec68df868cbbfde844cfc6d81649fe5109a62b116b19fabd53e618ee" dependencies = [ "endi", "enumflags2", "serde", "url", - "winnow 0.7.13", + "winnow 1.0.2", "zvariant_derive", "zvariant_utils", ] [[package]] name = "zvariant_derive" -version = "5.8.0" +version = "5.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da58575a1b2b20766513b1ec59d8e2e68db2745379f961f86650655e862d2006" +checksum = "c7d5b780599bbde114e39d9a0799577fad1ced5105d38515745f7b3099d8ceda" dependencies = [ - "proc-macro-crate 3.4.0", + "proc-macro-crate 3.5.0", "proc-macro2", "quote", - "syn 2.0.106", + "syn 2.0.117", "zvariant_utils", ] [[package]] name = "zvariant_utils" -version = "3.2.1" +version = "3.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6949d142f89f6916deca2232cf26a8afacf2b9fdc35ce766105e104478be599" +checksum = "6d464f5733ffa07a3164d656f18533caace9d0638596721355d73256a410d691" dependencies = [ "proc-macro2", "quote", "serde", - "syn 2.0.106", - "winnow 0.7.13", + "syn 2.0.117", + "winnow 1.0.2", ] diff --git a/Cargo.toml b/Cargo.toml index 53c718da..14b7faaa 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,7 +2,9 @@ resolver = "3" members = [ "apps/plumeimpactor", - "apps/plumesign", + "apps/plumesign", + "3rdparty/decompress", + "3rdparty/omnisette", "crates/plume_core", "crates/plume_gestalt", "crates/plume_store", @@ -37,20 +39,36 @@ idevice = { git = "https://github.com/jkcoxson/idevice", rev = "5171e34e3a236842 "ring", ] } plist = "1.8" +goblin = "0.9" # Errors env_logger = "0.11" log = "0.4" thiserror = "2.0" # Utils -uuid = "1.18" futures = { version = "0.3", default-features = false, features = ["std"] } -chrono = { version = "0.4", default-features = false, features = ["std", "serde"] } -serde = { version = "1", features = ["derive"] } -serde_json = { version = "1" } rustls = { version = "0.23", default-features = false, features = [ "std", "tls12", "ring", ] } image = { version = "0.25", default-features = false, features = ["png", "jpeg"] } -goblin = "0.9" +# Compression +flate2 = "1.1" +zip = "8.6" +# Cryptography +hex = "0.4" +rand = "0.8" +base64 = "0.22" +sha2 = "0.11" +regex = "1.11" +uuid = { version = "1.3", features = ["v4", "fast-rng", "macro-diagnostics"] } +# Requests +reqwest = { version = "0.13", default-features = false, features = [ + "blocking", + "json", + "rustls", + "gzip", +] } +chrono = { version = "0.4", default-features = false, features = ["std", "serde"] } +serde = { version = "1", features = ["derive"] } +serde_json = { version = "1" } \ No newline at end of file diff --git a/apps/plumeimpactor/src/screen/windows/login_window.rs b/apps/plumeimpactor/src/screen/windows/login_window.rs index c81c4b80..675db83e 100644 --- a/apps/plumeimpactor/src/screen/windows/login_window.rs +++ b/apps/plumeimpactor/src/screen/windows/login_window.rs @@ -179,12 +179,12 @@ impl LoginWindow { } fn view_login(&self) -> Element<'_, Message> { - let email_input = text_input("example@riseup.net", &self.email) + let email_input = text_input("claration@riseup.net", &self.email) .on_input(Message::EmailChanged) .padding(8) .width(Fill); - let mut password_input = text_input("1234", &self.password) + let mut password_input = text_input("password", &self.password) .on_input(Message::PasswordChanged) .secure(true) .padding(8) diff --git a/crates/plume_core/Cargo.toml b/crates/plume_core/Cargo.toml index eef87eda..6baf0fa4 100644 --- a/crates/plume_core/Cargo.toml +++ b/crates/plume_core/Cargo.toml @@ -17,25 +17,18 @@ serde.workspace = true serde_json.workspace = true rustls.workspace = true goblin.workspace = true -# Core dependencies -reqwest = { version = "0.13", default-features = false, features = [ - "blocking", - "json", - "rustls", - "gzip", -] } - -regex = "1.11" -base64 = "0.22" -hex = "0.4.3" -rand = "0.8" +regex.workspace = true +reqwest.workspace = true +base64.workspace = true +hex.workspace = true +rand.workspace = true +sha2.workspace = true # Cryptography -aes = "0.9.0-rc.4" +aes = "0.9" aes-gcm = "0.11.0-rc.3" -cbc = { version = "0.2.0-rc.3", features = ["alloc"] } -pbkdf2 = "0.13.0-rc.9" -hmac = "0.13.0-rc.5" -sha2 = "0.11.0-rc.5" +cbc = { version = "0.2", features = ["alloc"] } +pbkdf2 = "0.13" +hmac = "0.13" rsa = "0.9" # Certificates x509-certificate = "0.24" @@ -46,7 +39,7 @@ sha1 = "0.10" # p12 p12-keystore = "0.2" # p12 crate only supports legacy PKCS#12 # Forks apple-codesign = { git = "https://github.com/PlumeImpactor/plume-apple-platform-rs", rev = "428b42f", package = "apple-codesign", default-features = false } -omnisette = { git = "https://github.com/PlumeImpactor/omnisette", rev = "c5c4cf2", package = "omnisette", features = [ +omnisette = { path = "../../3rdparty/omnisette", features = [ "remote-anisette-v3", ] } srp = "0.7.0-rc.1" diff --git a/crates/plume_utils/Cargo.toml b/crates/plume_utils/Cargo.toml index cdf861b7..60ab60ee 100644 --- a/crates/plume_utils/Cargo.toml +++ b/crates/plume_utils/Cargo.toml @@ -17,10 +17,8 @@ futures.workspace = true log.workspace = true image.workspace = true goblin.workspace = true +zip.workspace = true +flate2.workspace = true plume_core = { path = "../plume_core", features = ["tweaks"] } plume_store = { path = "../plume_store" } - -# TODO: replace zip with decompress -zip = { version = "4.3", default-features = false, features = ["deflate"] } -decompress = { git = "https://github.com/PlumeImpactor/decompress", rev = "75a3016" } -flate2 = "1.1" +decompress = { path = "../../3rdparty/decompress" }