Secure Computing Lab

About the lab

The Secure Computing Lab (SCL) is a research laboratory in the Department of Computer Science at the University of Arizona that examines cutting-edge problems in cybersecurity. It is led by Prof. Quinn Burke. Our focus is on building robust systems infrastructure for emerging cloud and edge applications that is secure, reliable, and scalable. We leverage emerging hardware security features and advanced cryptography, integrating techniques in systems building, cryptographic protocol design, and large-scale performance evaluation. We apply these ideas across storage and networking, software supply chains, AI/agentic systems, and other critical infrastructure where trustworthy computation is essential.

Students and researchers who join early will help shape a new research group, working closely with Prof. Burke on ambitious systems security projects and publishing in top security and systems conferences and journals. Curious and self-motivated students and researchers with different backgrounds and levels of experience are all welcome to apply. Strong applicants will usually have experience in one or more of the following areas: computer security, systems programming, distributed systems, cloud computing, applied cryptography, trusted execution environments, cloud storage systems, computer networking, or large-scale performance evaluation. Applicants with strong engineering portfolios, open-source contributions, research experience, or other substantial independent projects are especially encouraged to reach out.

Recent news

• August 2026: The Secure Computing Lab has launched!

Research areas

Rollback attacks vs. rollback-as-a-feature

Confidential computing keeps an application's state protected inside a trusted execution environment, but that state has to be persisted somewhere the platform does not trust, and persisted state can always be swapped for an older copy. The security community has studied this almost entirely through an adversarial lens: rollback is an attack, freshness is the goal, and a correct system is one that refuses to ever run on stale state. That framing is incomplete. Rolling a service back to a known‑good state is a routine and often essential DevOps operation: it is how operators recover from a bad deploy, a corrupted update, or a failed migration. A design that makes rollback impossible does not only frustrate attackers; it takes away a recovery path that operators genuinely depend on.

Our work resolves that tension by treating rollback as a feature to be secured rather than a failure to be prevented. We designed cryptographic protocols that separate an authorized rollback from an adversarial one: state advances through commitments anchored in the hardware's trust, and rewinding requires explicit authorization that leaves durable evidence behind. Operators keep the recovery path they need, while a client can still establish which state it is talking to and whether that state was ever rolled back, and by whom.

Key result

• Rollback protection and rollback support are not actually in conflict. The right abstraction is not "prevent every rewind" but "make every rewind authorized and auditable," which gives confidential deployments a trustworthy recovery path they previously had to do without.

Selected publications

• Quinn Burke, Anjo Vahldiek-Oberwagner, Michael Swift, and Patrick McDaniel. "It's a Feature, Not a Bug: Secure and Auditable State Rollback for Confidential Cloud Applications." IEEE Symposium on Security and Privacy (S&P), 2026. [PDF] [arXiv] [Code]

Robust, low‑cost security on untrusted storage infrastructure

Ensuring the integrity of data stored in the cloud is an important element of cloud security, but it requires executing complex cryptographic checks on data whenever it is read from or written to storage. These checks can degrade storage performance by up to 90%, rendering the performance capabilities of modern storage devices (e.g., NVMe SSDs) useless and creating a strong economic incentive for storage administrators to disable protections in practice. Our work was the first to quantitatively explain why these overheads occur in modern settings: CPU hashing speeds are the bottleneck (previously hidden by slower disk speeds), overheads increase non‑linearly, and the underlying integrity data structures are static.

Building on this analysis, we designed an optimal data structure that establishes a lower bound on integrity cost for a given workload profile, then built a new adaptive structure that learns on the fly (without a priori knowledge) and performs near‑optimally across small‑ and large‑scale storage. In complementary work, we formalized secure deferral of verification by coupling asynchronous execution to simple commit and admission rules tied to durability, which moves integrity work off the critical path while remaining hardware anchored and crash consistent, delivering robust integrity protections at near‑zero cost.

Key result

• This work provided both theoretical and empirical evidence contradicting conventional wisdom about what data structures are necessary and sufficient to protect storage integrity at low cost. It also established a new principled design recipe for systems security researchers demonstrating how to push system optimizations to their limits while remaining within strict security requirements.

Selected publications

• Quinn Burke, Ryan Sheatsley, Yohan Beugin, Eric Pauley, Owen Hines, Michael Swift, and Patrick McDaniel. "Efficient Storage Integrity in Adversarial Settings." IEEE Symposium on Security and Privacy (S&P), 2025. [PDF]
• Quinn Burke, Ryan Sheatsley, Rachel King, Owen Hines, Michael Swift, and Patrick McDaniel. "On Scalable Integrity Checking For Secure Cloud Disks." USENIX Conference on File and Storage Technologies (FAST), 2025. [PDF]
• Quinn Burke, Yohan Beugin, Blaine Hoak, Rachel King, Eric Pauley, Ryan Sheatsley, Mingli Yu, Ting He, Thomas La Porta, and Patrick McDaniel. "Securing Cloud File Systems with Trusted Execution." IEEE Transactions on Dependable and Secure Computing (TDSC), 2024. [PDF]

Network security in the modern cloud

Modern cloud networks increasingly rely on software‑defined networking (SDN), whose programmability enables flexible control but also creates new security challenges. We have leveraged SDN programmability to enforce secure information‑flow policies directly in the routing fabric (at every hop), mitigating configuration errors and limiting attacker lateral movement when endpoint rules are misconfigured or bypassed.

We have also examined vulnerabilities arising from SDN's control–data plane separation, showing how strategic manipulations of inputs to SDN controllers (e.g., traffic load reports from switches) can mislead load balancers and degrade availability while evading state of the art detection mechanisms. Moreover, we have contributed to analyzing side channels in SDN data planes. These works have produced insights that have informed the design of new defenses for SDN control and data planes.

Key result

• Our work embedding secure information flow policies in the routing fabric shifted policy enforcement from endpoints into the routing fabric, providing verifiable, hop‑by‑hop information‑flow guarantees that provably prevent lateral movement and data exfiltration attacks.

Selected publications

• Quinn Burke, Fidan Mehmeti, Rahul George, Trent Jaeger, Thomas La Porta, and Patrick McDaniel. "Enforcing Multilevel Security Policies in Unstable Networks." IEEE Transactions on Network and Service Management (TNSM), 2022. [PDF]
• Mingli Yu, Tian Xie, Ting He, Patrick McDaniel, and Quinn Burke. "Flow Table Security in SDN: Adversarial Reconnaissance and Intelligent Attacks." IEEE/ACM Transactions on Networking (TON), 2021. [PDF]
• Quinn Burke, Patrick McDaniel, Thomas La Porta, Mingli Yu, and Ting He. "Misreporting Attacks in Software‑Defined Networking." International Conference on Security and Privacy in Communication Networks (SecureComm), 2020. [PDF]