Update Rust & Java dependencies (#4540)

* Update Java dependencies

* Baselint lint fixes

* Update Rust version

* Update actix-files 0.6.6 -> 0.6.8

* Update actix-http 3.11.0 -> 3.11.2

* Update actix-rt 2.10.0 -> 2.11.0

* Update async_zip 0.0.17 -> 0.0.18

* Update async-compression 0.4.27 -> 0.4.32

* Update async-trait 0.1.88 -> 0.1.89

* Update async-tungstenite 0.30.0 -> 0.31.0

* Update const_format 0.2.34 -> 0.2.35

* Update bitflags 2.9.1 -> 2.9.4

* Update bytemuck 1.23.1 -> 1.24.0

* Update typed-path 0.11.0 -> 0.12.0

* Update chrono 0.4.41 -> 0.4.42

* Update cidre 0.11.2 -> 0.11.3

* Update clap 4.5.43 -> 4.5.48

* Update data-url 0.3.1 -> 0.3.2

* Update discord-rich-presence 0.2.5 -> 1.0.0

* Update enumset 1.1.7 -> 1.1.10

* Update flate2 1.1.2 -> 1.1.4

* Update hyper 1.6.0 -> 1.7.0

* Update hyper-util 0.1.16 -> 0.1.17

* Update iana-time-zone 0.1.63 -> 0.1.64

* Update image 0.25.6 -> 0.25.8

* Update indexmap 2.10.0 -> 2.11.4

* Update json-patch 4.0.0 -> 4.1.0

* Update meilisearch-sdk 0.29.1 -> 0.30.0

* Update clickhouse 0.13.3 -> 0.14.0

* Fix some prettier things

* Update lettre 0.11.18 -> 0.11.19

* Update phf 0.12.1 -> 0.13.1

* Update png 0.17.16 -> 0.18.0

* Update quick-xml 0.38.1 -> 0.38.3

* Update redis 0.32.4 -> 0.32.7

* Update regex 1.11.1 -> 1.11.3

* Update reqwest 0.12.22 -> 0.12.23

* Update rust_decimal 1.37.2 -> 1.38.0

* Update rust-s3 0.35.1 -> 0.37.0

* Update serde 1.0.219 -> 1.0.228

* Update serde_bytes 0.11.17 -> 0.11.19

* Update serde_json 1.0.142 -> 1.0.145

* Update serde_with 3.14.0 -> 3.15.0

* Update sentry 0.42.0 -> 0.45.0 and sentry-actix 0.42.0 -> 0.45.0

* Update spdx 0.10.9 -> 0.12.0

* Update sysinfo 0.36.1 -> 0.37.2

* Update tauri 2.7.0 -> 2.8.5

* Update tauri-build 2.3.1 -> 2.4.1

* Update tauri-plugin-deep-link 2.4.1 -> 2.4.3

* Update tauri-plugin-dialog 2.3.2 -> 2.4.0

* Update tauri-plugin-http 2.5.1 -> 2.5.2

* Update tauri-plugin-opener 2.4.0 -> 2.5.0

* Update tauri-plugin-os 2.3.0 -> 2.3.1

* Update tauri-plugin-single-instance 2.3.2 -> 2.3.4

* Update tempfile 3.20.0 -> 3.23.0

* Update thiserror 2.0.12 -> 2.0.17

* Update tracing-subscriber 0.3.19 -> 0.3.20

* Update url 2.5.4 -> 2.5.7

* Update uuid 1.17.0 -> 1.18.1

* Update webp 0.3.0 -> 0.3.1

* Update whoami 1.6.0 -> 1.6.1

* Note that windows and windows-core can't be updated yet

* Update zbus 5.9.0 -> 5.11.0

* Update zip 4.3.0 -> 6.0.0

* Fix build

* Enforce rustls crypto provider

* Refresh Cargo.lock

* Update transitive dependencies

* Bump Gradle usage to Java 17

* Use ubuntu-latest consistently across workflows

* Fix lint

* Fix lint in Rust

* Update native-dialog 0.9.0 -> 0.9.2

* Update regex 1.11.3 -> 1.12.2

* Update reqwest 0.12.23 -> 0.12.24

* Update rust_decimal 1.38.0 -> 1.39.0

* Remaining lock-only updates

* chore: move TLS impl of some other dependencies to aws-lc-rs

The AWS bloatware "virus" expands by sheer force of widespread adoption
by the ecosystem... 🫣

* chore(fmt): run Tombi

---------

Co-authored-by: Alejandro González <me@alegon.dev>

packages/app-lib/src/api/minecraft_skins/png_util.rs

@@ -1,6 +1,6 @@
 //! Miscellaneous PNG utilities for Minecraft skins.
 
-use std::io::Read;
+use std::io::{BufRead, Cursor, Seek};
 use std::sync::Arc;
 
 use base64::Engine;
@@ -9,7 +9,8 @@ use data_url::DataUrl;
 use futures::{Stream, TryStreamExt, future::Either, stream};
 use itertools::Itertools;
 use rgb::Rgba;
-use tokio_util::{compat::FuturesAsyncReadCompatExt, io::SyncIoBridge};
+use tokio::io::AsyncReadExt;
+use tokio_util::compat::FuturesAsyncReadCompatExt;
 use url::Url;
 
 use crate::{
@@ -95,7 +96,8 @@ pub fn dimensions(png_data: &[u8]) -> crate::Result<(u32, u32)> {
 pub async fn normalize_skin_texture(
     texture: &UrlOrBlob,
 ) -> crate::Result<Bytes> {
-    let texture_stream = SyncIoBridge::new(Box::pin(
+    let mut texture_data = Vec::with_capacity(8192);
+    Box::pin(
         match texture {
             UrlOrBlob::Url(url) => Either::Left(
                 url_to_data_stream(url)
@@ -112,84 +114,84 @@ pub async fn normalize_skin_texture(
             ),
         }
         .compat(),
-    ));
+    )
+    .read_to_end(&mut texture_data)
+    .await?;
 
-    tokio::task::spawn_blocking(|| {
-        let mut png_reader = {
-            let mut decoder = png::Decoder::new(texture_stream);
-            decoder.set_transformations(
-                png::Transformations::normalize_to_color8(),
-            );
-            decoder.read_info()
-        }?;
+    let mut png_reader = {
+        let mut decoder = png::Decoder::new(Cursor::new(texture_data));
+        decoder
+            .set_transformations(png::Transformations::normalize_to_color8());
+        decoder.read_info()
+    }?;
 
-        // The code below assumes that the skin texture has valid dimensions.
-        // This also serves as a way to bail out early for obviously invalid or
-        // adversarial textures
-        if png_reader.info().width != 64
-            || ![64, 32].contains(&png_reader.info().height)
-        {
-            Err(ErrorKind::InvalidSkinTexture)?;
-        }
+    // The code below assumes that the skin texture has valid dimensions.
+    // This also serves as a way to bail out early for obviously invalid or
+    // adversarial textures
+    if png_reader.info().width != 64
+        || ![64, 32].contains(&png_reader.info().height)
+    {
+        Err(ErrorKind::InvalidSkinTexture)?;
+    }
 
-        let is_legacy_skin = png_reader.info().height == 32;
-        let mut texture_buf =
-            get_skin_texture_buffer(&mut png_reader, is_legacy_skin)?;
-        if is_legacy_skin {
-            convert_legacy_skin_texture(&mut texture_buf, png_reader.info());
-            do_notch_transparency_hack(&mut texture_buf, png_reader.info());
-        }
-        make_inner_parts_opaque(&mut texture_buf, png_reader.info());
+    let is_legacy_skin = png_reader.info().height == 32;
+    let mut texture_buf =
+        get_skin_texture_buffer(&mut png_reader, is_legacy_skin)?;
+    if is_legacy_skin {
+        convert_legacy_skin_texture(&mut texture_buf, png_reader.info());
+        do_notch_transparency_hack(&mut texture_buf, png_reader.info());
+    }
+    make_inner_parts_opaque(&mut texture_buf, png_reader.info());
 
-        let mut encoded_png = vec![];
+    let mut encoded_png = vec![];
 
-        let mut png_encoder = png::Encoder::new(&mut encoded_png, 64, 64);
-        png_encoder.set_color(png::ColorType::Rgba);
-        png_encoder.set_depth(png::BitDepth::Eight);
-        png_encoder.set_filter(png::FilterType::NoFilter);
-        png_encoder.set_compression(png::Compression::Fast);
+    let mut png_encoder = png::Encoder::new(&mut encoded_png, 64, 64);
+    png_encoder.set_color(png::ColorType::Rgba);
+    png_encoder.set_depth(png::BitDepth::Eight);
+    png_encoder.set_filter(png::Filter::NoFilter);
+    png_encoder.set_compression(png::Compression::Fast);
 
-        // Keeping color space information properly set, to handle the occasional
-        // strange PNG with non-sRGB chromaticities and/or different grayscale spaces
-        // that keeps most people wondering, is what sets a carefully crafted image
-        // manipulation routine apart :)
-        if let Some(source_chromaticities) =
-            png_reader.info().source_chromaticities.as_ref().copied()
-        {
-            png_encoder.set_source_chromaticities(source_chromaticities);
-        }
-        if let Some(source_gamma) =
-            png_reader.info().source_gamma.as_ref().copied()
-        {
-            png_encoder.set_source_gamma(source_gamma);
-        }
-        if let Some(source_srgb) = png_reader.info().srgb.as_ref().copied() {
-            png_encoder.set_source_srgb(source_srgb);
-        }
+    // Keeping color space information properly set, to handle the occasional
+    // strange PNG with non-sRGB chromaticities and/or different grayscale spaces
+    // that keeps most people wondering, is what sets a carefully crafted image
+    // manipulation routine apart :)
+    if let Some(source_chromaticities) =
+        png_reader.info().source_chromaticities.as_ref().copied()
+    {
+        png_encoder.set_source_chromaticities(source_chromaticities);
+    }
+    if let Some(source_gamma) = png_reader.info().source_gamma.as_ref().copied()
+    {
+        png_encoder.set_source_gamma(source_gamma);
+    }
+    if let Some(source_srgb) = png_reader.info().srgb.as_ref().copied() {
+        png_encoder.set_source_srgb(source_srgb);
+    }
 
-        let png_buf = bytemuck::try_cast_slice(&texture_buf)
-            .map_err(|_| ErrorKind::InvalidPng)?;
-        let mut png_writer = png_encoder.write_header()?;
-        png_writer.write_image_data(png_buf)?;
-        png_writer.finish()?;
+    let png_buf = bytemuck::try_cast_slice(&texture_buf)
+        .map_err(|_| ErrorKind::InvalidPng)?;
+    let mut png_writer = png_encoder.write_header()?;
+    png_writer.write_image_data(png_buf)?;
+    png_writer.finish()?;
 
-        Ok(encoded_png.into())
-    })
-    .await?
+    Ok(encoded_png.into())
 }
 
 /// Reads a skin texture and returns a 64x64 buffer in RGBA format.
-fn get_skin_texture_buffer<R: Read>(
+fn get_skin_texture_buffer<R: BufRead + Seek>(
     png_reader: &mut png::Reader<R>,
     is_legacy_skin: bool,
 ) -> crate::Result<Vec<Rgba<u8>>> {
+    let output_buffer_size = png_reader
+        .output_buffer_size()
+        .expect("Reasonable skin texture size verified already");
     let mut png_buf = if is_legacy_skin {
         // Legacy skins have half the height, so duplicate the rows to
         // turn them into a 64x64 texture
-        vec![0; png_reader.output_buffer_size() * 2]
+        vec![0; output_buffer_size * 2]
     } else {
         // Modern skins are left as-is
-        vec![0; png_reader.output_buffer_size()]
+        vec![0; output_buffer_size]
     };
     png_reader.next_frame(&mut png_buf)?;
 
@@ -373,9 +375,10 @@ fn set_alpha(
 #[tokio::test]
 async fn normalize_skin_texture_works() {
     let decode_to_pixels = |png_data: &[u8]| {
-        let decoder = png::Decoder::new(png_data);
+        let decoder = png::Decoder::new(Cursor::new(png_data));
         let mut reader = decoder.read_info().expect("Failed to read PNG info");
-        let mut buffer = vec![0; reader.output_buffer_size()];
+        let mut buffer =
+            vec![0; reader.output_buffer_size().expect("Skin size too large")];
         reader
             .next_frame(&mut buffer)
             .expect("Failed to decode PNG");