Technical Summary: Bit of a Close Talker: A Practical Guide to Serverless Cloud Co-Location Attacks

Problem Statement

Serverless computing offers efficiency and cost-effectiveness by offloading infrastructure management to cloud providers. However, this model introduces security vulnerabilities, specifically micro-architectural side-channel attacks (e.g., Prime+Probe), which require the attacker and victim instances to be co-located on the same physical server. While dedicated hosts can prevent co-location, they are prohibitively expensive (over 10x the cost of serverless).

Existing research has explored co-location in traditional "serverful" clouds and specific platforms like Google Cloud Run, but there is a lack of a universal methodology to exploit serverless cloud schedulers. Attackers currently lack a systematic approach to reverse-engineer scheduling algorithms and construct co-location attacks using only standard user interfaces (invoking functions) without privileged access.

Methodology

The paper proposes a three-stage framework to achieve co-location in serverless environments:

1. Scheduler Fingerprinting (Step 0)

The authors introduce a method to reveal exploitable features of serverless scheduling algorithms by observing placement sequences. The process involves three phases of function invocation:

• Phase 1: Repeatedly invoke a single function to detect Invocation Locality (F1) (reusing hosts to avoid cold starts) and Auto-Scaling (F2) (spreading hosts under load).
• Phase 2: Invoke the original function alongside a functionally identical but distinct function to detect Cold-Start Locations (F3) (whether re-launched instances return to the same servers) and Account Locality (F4) (whether a user's functions are confined to a specific set of servers).
• Phase 3: Invoke functions with varying configuration parameters (e.g., different package dependencies) to detect Configuration-Based Locality (F5), such as package-aware scheduling.

2. Attack Construction (Step 1)

Based on the identified features, the authors propose specific attack strategies:

• For Invocation Locality (F1): Construct multiple distinct attack functions to increase the probability of hitting the same limited set of warm hosts.
• For Auto-Scaling (F2): Create bursts of invocations to force the scheduler to scale out, spreading the attacker's instances across the cluster.
• For Configuration-Based Locality (F5):
  • Precise Targeting: If the victim's dependencies are known, construct an attack function with identical dependencies to force co-location.
  • Scatter-Based: If dependencies are unknown, construct multiple functions with varying dependencies to cover the cluster's scheduling logic.

3. Evaluation

The methodology was evaluated using:

• Simulator: A C++ simulator modeling ~2000 lines of code with 4 scheduling algorithms (Random, Helper, OpenWhisk, Package-Aware Scheduler).
• Cluster Experiments: A 50-node CloudLab cluster running a Dask-based serverless platform.
• Real-World Case Study: Microsoft Azure Functions (Consumption Plan).

Key Contributions

1. Scheduler Fingerprinting Method: A systematic approach to reverse-engineer serverless scheduling policies (F1–F5) using only normal user interfaces.
2. Universal Attack Strategy: A guide for constructing co-location attacks tailored to specific scheduler features, including "scatter-based" and "precise targeting" approaches.
3. Empirical Validation: Successful demonstration of co-location attacks on:
   • Open-source platforms (OpenWhisk, Dask-based systems).
   • Commercial infrastructure (Microsoft Azure Functions).
   • Different scheduling algorithms (Random, Helper, PASch).
4. Mitigation Proposal (Double-Dip): A new scheduling algorithm designed to provide "soft" user isolation. It prioritizes placing a user's new function on a host where they are already active; if none exists, it selects the host with the least variety of active users to minimize cross-user overlap.

Results

Fingerprinting and Attack Success

• Feature Identification: The fingerprinting method successfully identified distinct behaviors in different schedulers. For example, the Helper scheduler (mimicking Google Cloud Run) exhibited auto-scaling and cold-start locality, while PASch exhibited package locality.
• Attack Efficiency:
  • Configuration-Based Locality (F5): Exploiting this feature yielded the highest success rates. In the PASch scheduler, attackers achieved nearly 100% co-location success by matching package dependencies.
  • Auto-Scaling (F2): Exploiting auto-scaling was less efficient. While it increased coverage, the success rate plateaued because not all invocations triggered new host creation.
  • Random Scheduling: Contrary to intuition, pure random scheduling was found to be vulnerable; attackers could achieve high coverage simply by deploying a large number of functions.
• Azure Functions Case Study:
  • Fingerprinting revealed that Azure Functions considers invocation locality and auto-scales but does not confine a single user's functions to a small set of servers (no Account Locality). However, it does place functions from the same application on the same physical machine.
  • Attack Outcome: Using 64 attack functions across different applications, the attacker achieved co-location with at least one victim host in every experiment (5 trials). The attack covered an average of 230 machines and cost less than $25 USD.

Mitigation Evaluation (Double-Dip)

• Co-Location Resistance: In simulations with up to 50 attackers, the Double-Dip scheduler maintained a significantly lower co-location success rate compared to the Helper scheduler. For 50 attackers, Helper reached 100% success, while Double-Dip remained at 30.6%.
• Performance Overhead: Double-Dip preserved most of the "warm-start" benefits of the Helper scheduler (high warm-start ratios) while introducing only modest performance overhead, scaling well as user count and request volume increased.

Significance and Claims

The paper claims to bridge a critical gap in serverless security by providing a practical guide for attackers to construct co-location attacks without privileged access. The authors emphasize that:

• Scheduler Design is Critical: Current serverless schedulers often prioritize performance (cold-start reduction, load balancing) over security, inadvertently creating deterministic placement patterns that attackers can exploit.
• Randomness is Not a Panacea: Pure random scheduling does not guarantee security; it can actually be exploited by attackers to scatter instances and increase coverage.
• Soft Isolation is Viable: The proposed Double-Dip algorithm demonstrates that it is possible to mitigate co-location risks through scheduling logic ("soft" isolation) without resorting to expensive dedicated hardware, though it does not offer a 100% guarantee.

The authors conclude that understanding and exploiting scheduler features is essential for both attackers and defenders, and that future serverless scheduling systems must balance performance optimization with security unpredictability.