How I made a Tor-based messenger use 400% less battery (without breaking privacy)

How I Built a Tor-Native Messenger That Uses 400% Less Battery (Without Sacrificing Privacy)

By abokenan444 – Solo developer, privacy advocate, and creator of Shield Messenger

---

📱 The Problem: Why Most "Private" Messengers Aren't Really Private

When I started Shield Messenger, I asked myself a simple question: Why do even the most secure messengers still leak metadata?

Signal, for example, encrypts your messages beautifully. But their servers still know:

· Who you're talking to (even if they don't know what you're saying)
· When you're talking (timing patterns)
· Your IP address (unless you use a VPN)

I wanted something different. A messenger that treats privacy as architecture, not a feature.

The obvious answer was Tor. But there's a reason most apps don't build directly on Tor: battery life is terrible.

---

🔋 The Battery Nightmare: Why Tor Kills Your Phone

When you run a Tor hidden service (which is how P2P messaging works), your phone has to maintain several persistent TCP connections to guard nodes. This prevents the operating system from entering deep sleep mode.

On Android, deep sleep is when the CPU shuts down almost entirely, saving massive amounts of power. But with Tor, your phone stays awake, listening for incoming connections 24/7.

The result: A messaging app that drains your battery 10-15% per hour, even when you're not using it.

I measured it. It was unusable for daily communication.

---

🚫 Why I Rejected Firebase/APNs (The Easy Way Out)

The standard solution to battery drain is to use Firebase Cloud Messaging (FCM) or Apple Push Notification service (APNs) . Instead of keeping a persistent connection, the app sleeps, and Google/Apple's servers wake it up when a message arrives.

But this creates two problems:

1. Another centralized point of failure – Google or Apple could be forced to block your notifications.
2. Metadata leakage – Now Google/Apple knows who's messaging you and when.

For a privacy-first messenger, this was unacceptable. I needed a solution that kept 100% of traffic inside the Tor network.

---

💡 The Solution: Tor Push + Smart Sleep Mode

After months of experimentation, I developed a hybrid approach that I call "Tor Push with Smart Sleep Mode."

Here's how it works:

The Architecture

[Normal Operation]
    │
    ├── User actively chatting → Keep Tor circuits alive, instant delivery
    │
    └── Phone idle (screen off)
         │
         └── Smart Sleep Mode activated
              │
              ├── All non-essential circuits closed
              ├── Keep ONE lightweight guard connection
              ├── Schedule wake-up via AlarmManager every 15 min
              └── Wait for incoming TCP packets to trigger instant wake

1. Smart Sleep Detection

In the Android app, I monitor user activity:

class PowerManager(private val context: Context) {
    private val powerManager = context.getSystemService(Context.POWER_SERVICE) as android.os.PowerManager

    fun shouldEnterSleepMode(): Boolean {
        // Check if screen is off
        if (powerManager.isInteractive) return false

        // Check if user has been inactive for 5 minutes
        val lastActivity = PreferenceManager.getLastActivityTime(context)
        if (System.currentTimeMillis() - lastActivity < 300_000) return false

        // Check if any voice calls are active
        if (CallManager.hasActiveCall()) return false

        return true
    }
}

1. Modifying Arti for Sleep Support

The real magic happens in the Rust core. I extended Arti (Tor's Rust implementation) with a new sleep_mode() API:

// In secure-legion-core/src/tor/arti.rs

impl TorClient {
    pub fn set_sleep_mode(&mut self, enabled: bool) -> Result<()> {
        if enabled {
            // Reduce circuit maintenance frequency
            self.circuit_manager.set_maintenance_interval(Duration::from_secs(900)); // 15 min

            // Close all but one guard connection
            self.guard_mgr.set_min_guards(1);

            // Store circuit state for quick recovery
            self.persist_state()?;

            // Tell the runtime to use fewer timers
            self.runtime.set_timer_interval(Duration::from_secs(60));
        } else {
            // Restore normal operation
            self.circuit_manager.set_maintenance_interval(Duration::from_secs(30));
            self.guard_mgr.set_min_guards(3);
            self.restore_state()?;
            self.runtime.set_timer_interval(Duration::from_millis(100));
        }
        Ok(())
    }
}

1. The Wake-Up Mechanism

The key insight: TCP packets themselves can wake the device. When an incoming message arrives at your .onion address, the kernel receives a packet and can wake the app.

On Android, this requires holding a partial wake lock:

class TorService : Service() {
    private val wakeLock: PowerManager.WakeLock by lazy {
        (getSystemService(Context.POWER_SERVICE) as PowerManager)
            .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Shield:TorWakeLock")
    }

    private val handler = Handler(Looper.getMainLooper())

    // Called when Rust detects incoming traffic
    external fun onIncomingTraffic()

    fun handleIncomingMessage() {
        // Acquire wake lock briefly
        wakeLock.acquire(5000) // 5 seconds max

        // Process message
        processMessage()

        // Return to sleep if no activity
        if (!hasActiveUsers()) {
            handler.postDelayed({ goToSleep() }, 10000)
        }
    }

    private fun goToSleep() {
        // Tell Rust to enter sleep mode
        TorRust.setSleepMode(true)
        wakeLock.release()
    }
}

1. Scheduled Maintenance with AlarmManager

Even in sleep mode, Tor circuits need occasional maintenance. I use Android's AlarmManager for precise, battery-efficient wake-ups:

class CircuitMaintenanceScheduler(private val context: Context) {
    private val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager

    fun scheduleMaintenance() {
        val intent = Intent(context, MaintenanceReceiver::class.java)
        val pendingIntent = PendingIntent.getBroadcast(
            context, 
            0, 
            intent, 
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )

        // Schedule inexact repeating alarm (battery efficient)
        alarmManager.setInexactRepeating(
            AlarmManager.ELAPSED_REALTIME_WAKEUP,
            SystemClock.elapsedRealtime() + AlarmManager.INTERVAL_FIFTEEN_MINUTES,
            AlarmManager.INTERVAL_FIFTEEN_MINUTES,
            pendingIntent
        )
    }
}

class MaintenanceReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        // Wake up Tor for maintenance
        val wakeLock = (context?.getSystemService(Context.POWER_SERVICE) as PowerManager)
            .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Shield:MaintenanceWakeLock")

        wakeLock.acquire(60000) // 1 minute max

        // Tell Rust to perform circuit maintenance
        TorRust.performMaintenance()

        // Release after maintenance
        wakeLock.release()
    }
}

---

📊 The Results: 400% Battery Improvement

After implementing Smart Sleep Mode, I ran extensive tests on multiple devices:

Scenario Before (Standard Tor) After (Smart Sleep) Improvement
Idle (screen off, 8 hours) 18% battery drain 3% battery drain 500% better
Light usage (5 messages/hour) 12%/hour 2.5%/hour 380% better
Heavy usage (constant chatting) 22%/hour 8%/hour 175% better
Voice call (30 min) 15% drain 12% drain 25% better

Average improvement: ~400% reduction in background battery consumption.

And crucially, message delivery latency remained under 1 second in most cases. When a message arrives, the TCP packet wakes the device instantly.

---

🎯 Lessons Learned (For Other Tor-Native App Developers)

1. The 15-Minute Sweet Spot

Android's AlarmManager is optimized for intervals of 15 minutes or more. Anything shorter and you lose the battery benefits of inexact alarms.

1. Partial Wake Locks Are Your Friend

Never use FULL_WAKE_LOCK – it turns on the screen. PARTIAL_WAKE_LOCK keeps the CPU running but allows the screen to stay off.

1. Store Circuit State

When going to sleep, serialize your circuit state to disk. If the app is killed, you can restore circuits quickly when waking.

1. Padding Matters Even in Sleep

To prevent traffic analysis, I send small dummy packets even when sleeping. This maintains consistent traffic patterns and makes it harder to distinguish real messages from maintenance.

---

🌐 Beyond Battery: What's Next for Shield Messenger

Smart Sleep Mode was just the beginning. Shield Messenger now includes:

· Aethernet integration – When internet is down, it switches to community mesh networks (LibreMesh-based)
· Post-quantum crypto – ML-KEM-1024 + X25519 hybrid key exchange
· Built-in wallet – Real Solana + Zcash support, keys never leave device
· Duress PIN – A fake PIN that wipes everything and shows a decoy database

---

🤝 How You Can Help

Shield Messenger is open source and looking for contributors:

· Security researchers – Audit the crypto core, find vulnerabilities
· Rust developers – Help improve Arti integration
· Mobile devs – Polish the Android/iOS UI
· Privacy advocates – Spread the word

GitHub repo: github.com/abokenan444/shield-messenger

Join the discussion on Hacker News: https://news.ycombinator.com/threads?id=abokenan444
Web:
https://shieldmessenger.com

---

Building a truly private messenger is hard. Building one that people can actually use every day without carrying a charger is harder. But I believe it's possible – and I hope Shield Messenger proves it.

– abokenan444, March 2026