Android utilizes Ahead-of-Time (AOT) compilation technology to precompile applications and stores the compiled code in OAT files, thereby improving app performance. When the Android system is updated, the old OAT files become invalidated. Applications will fall back to interpreted execution, resulting in degraded performance. To accommodate the frequent updates to the Android system that commonly occur on a monthly basis for most smartphone manufacturers, apps must be frequently recompiled into OAT files to promptly restore optimal app performance. However, recompiling applications is a resource-consuming process that cannot be completed quickly. Users have to endure issues such as device overheating and lag, which are caused by performance degradation after system updates.This paper evaluated popular Android apps across different system updates and made an important observation: up to 99% of the compiled code can be reused across different system updates, rendering most existing recompilation efforts unnecessary. Based on this observation, this paper proposes a method to accelerate app recompilation across Android system updates by reusing the old OAT files. We evaluated the proposed method with eight popular apps, on ten open-source Android system pairs and one closed-source Android system pair provided by a smartphone manufacturer. These Android system pairs have the same Android Runtime (ART) version and execute AOT compilation in both speed and speed-profile modes. Experimental results show that the proposed method reuses approximately 95% of compiled methods, achieving average speedups of 2.12× in CPU time and 1.39× in wall-clock time in speed-profile mode. In speed mode, the proposed method reuses about 99% of compiled methods, achieving average speedups of 5.15× in CPU time and 2.80× in wall-clock time, respectively. The proposed method not only accelerates app recompilation but also generates OAT files identical to those generated by native AOT compilation, without introducing security issues. Therefore, it holds significant promise for real-world deployment and has the potential to enhance user experience by speeding up the generation of new OAT files for applications.

Abstract Current deep learning models for side-channel analysis are often parameter-inefficient and lack robustness in feature extraction under noisy conditions, thereby requiring a substantial number of power traces to recover the key. We propose Stal-net, a lightweight task-oriented architecture for profiling side-channel analysis. It integrates lightweight local feature extraction, temporal dependency modeling, dynamic-threshold-based feature refinement, and correlation-aware multi-scale fusion in a coordinated pipeline, improving feature discriminability while controlling model complexity. Experiments were conducted on the ASCAD and DPA contest v4 datasets. Key recovery performance is evaluated using classification accuracy and average key rank, and attack efficiency is measured by the average number of power traces required to achieve average key rank of 0. On ASCAD, Stal-net achieves 94.23% accuracy and reaches average key rank = 0 with only 22 power traces, improving accuracy by 1.33% and attack efficiency by 26.7% over the baseline. On DPA contest v4, Stal-net achieves 93.4% accuracy and reaches average key rank = 0 with only 2 power traces, improving accuracy by 5.18% and attack efficiency by 33.3%. Ablation studies further demonstrate the complementary roles of the four core modules in noise suppression, temporal modeling, and feature fusion. This collaborative mechanism is the key enabler for Stal-net to maintain high performance while adhering to a lightweight design.

Abstract To address the current issue that existing steganographic techniques are highly dependent on the quality of carrier images and have insufficient adaptability to damaged images, we propose an MAE-based inpainting-steganography framework, which realizes steganography and inpainting for 2D color damaged images through multi-module collaboration. The encoder divides the original 244 × 244 images into non-overlapping patches and performs random masking to generate their feature sequences. The steganographic point prediction module locates suitable steganographic points by analyzing feature fluctuations during the inpainting process. The steganography module embeds information by introducing feature offsets at specific positions in the feature sequences according to the suitable steganographic points. The decoder completes the inpainting of masked regions to obtain stego-inpainted images. And the extraction module recovers the secret information through feature alignment. Experimental results show that with a feature fluctuation amplitude threshold of 0%, an offset of 3%, and an embedding capacity of 30 bits, the verification success rate reaches 96.67%, and remains at 95.27% even when the capacity is increased to 1000 bits. In terms of anti-steganography detection capability, evaluation results based on mainstream steganalysis models show that the detection accuracy of the proposed method is 49.79%. This accuracy is close to the level of random guessing, which indicates the excellent anti-detection performance of the method. Moreover, under the combined perturbations of JPEG compression, Gaussian blur, and noise interference, the information extraction accuracy still reaches 94.68%, demonstrating that the feature-domain embedding mechanism has good robustness. In addition, adding steganography under different masking ratios has no significant impact on image inpainting performance, and some metrics even outperform pure inpainting algorithms. While maintaining the quality of image inpainting, this framework achieves highly reliable information embedding and extraction, and maintains a high verification success rate in the complex scenario of damaged carrier images, providing a new idea for steganographic techniques in practical applications.

With the proliferation of mobile devices in daily life, ensuring the security and performance of these devices has become crucial. On Android, the Java Native Interface (JNI) acts as a bridge, allowing native libraries to directly access Java heap memory via raw pointers, bypassing Java's built-in safety checks. While this offers powerful functionality and performance, it also threatens the memory safety of the Java heap. Recently, Memory Tagging Extension (MTE) is introduced into the ARM architectures to enhance memory safety, reducing software vulnerabilities caused by illegal memory operations. This paper proposes MTE4JNI, an MTE-based JNI checking method, to protect Java heap memory from illicit native code access. Experimental results on real Android devices demonstrate that, compared to the currently employed guarded copy method, the proposed MTE4JNI method provides superior memory safety protection, while significantly reducing the runtime overhead on average by 11x and 27x for single-threaded and multi-threaded environments, respectively.

Recent Android systems have employed pre-compilation technology to boost app launch speed and runtime performance. However, this generates large OAT files that over-consume scarce memory and storage resources in mobile devices. This paper conducts an evaluation of code redundancy in popular production android applications and observes that the code redundancy is up to 25%. To reduce the code size via redundancy elimination, this paper proposes Calibro, a compilation-assisted linking-time binary code outlining method. Calibro consists of two parts, the Compilation-Time code Outlining (CTO) and the Linking-Time Binary code Outlining (LTBO) with information collected at compilation- time. Additionally, a paralleled suffix tree method is proposed to reduce the building time overhead, and a hot function filtering method is proposed to effectively mitigate run-time performance degradation caused by code outlining. Experimental results show that compared to the baseline (the original AOSP version with all available code size optimization enabled), the proposed approach reduces code size in Android applications by more than 15.19% on average, with negligible runtime performance degradation and tolerable building time overhead. Hence the proposed code outlining approach is promising for production deployment.