🔭 astrophysics

A High-Throughput AES-GCM Implementation on GPUs for Secure, Policy-Based Access to Massive Astronomical Catalogs

This paper presents a novel, GPU-accelerated framework that integrates fine-grained policy-based access control with a highly parallelized AES-GCM implementation to enable secure, high-throughput encryption of massive astronomical image catalogs without compromising research workflows.

Original authors: Samuel Lemes-Perera, Miguel R. Alarcon, Pino Caballero-Gil, Miquel Serra-Ricart

Published 2026-06-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Samuel Lemes-Perera, Miguel R. Alarcon, Pino Caballero-Gil, Miquel Serra-Ricart

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a massive library of the universe, filled with billions of high-resolution photos of stars, galaxies, and nebulae. These aren't just JPEGs; they are petabyte-scale scientific datasets that take up entire server rooms. Before these photos can be shown to the public, they go through a "proprietary period" where only a specific team of scientists is allowed to see them.

The problem is that keeping these photos secret usually means locking them in a heavy, slow vault. If you try to unlock them quickly enough for scientists to do their work, the security often breaks, or the process becomes so slow that research grinds to a halt.

This paper introduces a new system called GpuFitsCrypt that solves this by building a "super-fast, smart vault" that runs on powerful graphics cards (GPUs). Here is how it works, broken down into simple concepts:

1. The "Two-Key" Envelope

Think of a standard astronomical photo file (called a FITS file) as a sealed envelope. Inside, there are two distinct things:

The Label (Metadata): This tells you what the photo is (e.g., "Taken on Tuesday," "Looking at Mars," "Exposure time: 10 seconds").
The Picture (Pixel Data): The actual image of the stars.

Usually, if you lock the whole envelope, you can't read the label without unlocking the picture. But this new system splits the envelope. It uses two different keys:

Key A unlocks the Label.
Key B unlocks the Picture.

This allows for clever rules. For example, a student might get Key A so they can see what data exists (to plan their research) but not Key B, so they can't see the actual picture yet. Or, a public user might get both keys only after a specific date (like a movie release date).

2. The "Super-Speed" Lock (GPU Acceleration)

The biggest problem with high-security locks (encryption) is that they are usually slow. They work like a chain: to lock the second link, you must finish the first one. This "chain reaction" is terrible for computers that are designed to do millions of things at once (like GPUs).

The authors realized that the "chain" part of the lock (called the GHASH function) was the bottleneck. To fix this, they invented a parallel tree-reduction strategy.

The Analogy:
Imagine you have a line of 1,000 people passing a heavy bucket down the line.

The Old Way (Sequential): Person 1 fills the bucket, passes it to Person 2, who passes it to Person 3. It takes a long time because everyone has to wait for the person before them.
The New Way (Parallel Tree): Imagine the line splits in half. Person 1 and 2 pass buckets to a middle person at the same time. Person 3 and 4 do the same. Then those middle people pass to a top person. Everyone works at the same time, and the bucket gets to the end in a fraction of the time.

By using this "tree" method on powerful graphics cards (the kind used for video games and AI), the system can lock and unlock these massive files almost as fast as the hard drive can read them.

3. The "Tamper-Proof" Seal

Security isn't just about hiding the data; it's also about making sure no one changed it while it was locked.

The Checksum (The Receipt): Standard files have a "receipt" that checks if the file got corrupted by accident (like a power outage).
The Cryptographic Tag (The Wax Seal): This system adds a special digital wax seal. If someone tries to swap the "Label" with a different photo's label (a trick called a "context swap"), the seal breaks, and the computer refuses to open the file.

The system checks this seal before it even shows you the picture. If the seal is broken, it gives you a blank, zero-filled file instead of a corrupted one, ensuring scientists never accidentally analyze fake data.

4. The Result: Invisible Security

The most impressive part is that for the scientist, this security is invisible.

They use the same tools they always use (Python software called Astropy).
They type the same commands to open a file.
If they have the right keys, the file opens instantly, and the picture looks exactly the same as the original.
If they don't have the keys, the system either hides the picture (showing a blank screen) or hides the label, depending on the rules set by the library.

Summary

The paper claims to have built a system that allows astronomers to keep their massive image catalogs secure and private during sensitive periods without slowing down their research. By using a "two-key" system for flexible access and a "parallel tree" method to make the encryption super-fast on graphics cards, they ensure that data remains safe from hackers and accidental corruption, while still being ready for immediate scientific discovery the moment it is allowed to be shared.

Technical Summary: A High-Throughput AES-GCM Implementation on GPUs for Secure, Policy-Based Access to Massive Astronomical Catalogs

Problem Statement
Modern astronomical surveys, such as the Legacy Survey of Space and Time (LSST), generate petabyte-scale image catalogs that require robust security during proprietary periods before public release. While Findable, Accessible, Interoperable, and Reusable (FAIR) principles guide eventual public dissemination, securing data during embargo phases presents a dual challenge: enforcing fine-grained access control without incurring prohibitive performance penalties. Traditional security methods often lack granularity or introduce significant latency, creating bottlenecks for data-intensive workflows. Furthermore, standard encryption modes like Counter (CTR) provide confidentiality but lack intrinsic integrity verification, leaving data vulnerable to manipulation. The primary technical hurdle in implementing authenticated encryption (AES-GCM) on GPUs is the inherently sequential nature of the Galois/Counter Mode (GCM) authentication hash (GHASH), which prevents the massive parallelism required for high-throughput processing.

Methodology
The authors propose GpuFitsCrypt, a framework integrating a flexible policy engine with a novel, GPU-accelerated implementation of the AES-128-GCM protocol. The system is designed to operate within the existing astronomical Python ecosystem (Astropy, cfitsio) while maintaining strict data integrity.

Architecture: The framework separates the Control Plane (Policy Engine, Access Control Module, Key Management Service) from the Data Plane (Cryptographic Module). It employs a "verify-then-decrypt" workflow where an Access Control Module validates user identity and policy rules before retrieving keys from an external KMS.
Data Format: The system utilizes a FITS-compatible authenticated container. The original FITS file is transformed into a two-HDU structure:
1. Primary HDU (Metadata Container): Contains encrypted headers (ENCHDR), initialization vectors (NONCE_H, NONCE_D), and authentication tags. Critical structural keywords (ORIG_*) remain in plaintext to allow file parsing but are cryptographically bound to the ciphertext via Associated Authenticated Data (AAD).
2. BINTABLE Extension (Data Container): The pixel payload is encrypted and stored as a single-row binary blob, concealing image geometry from unauthorized users while preserving scientific invariance.
Dual-Key Mechanism: The framework supports independent Header Keys and Data Keys. This enables granular access scenarios, such as allowing metadata queries without pixel access, or providing a "fallback" minimal header if the header key is denied, ensuring the file remains parsable by standard tools even under restricted access.
GPU Acceleration Strategy: To overcome the sequential bottleneck of GHASH, the authors adapt a parallel tree-reduction strategy.
- Parallel GHASH: Instead of a linear $O(N)$ dependency chain, the algorithm precomputes powers of the hash key ( $H^{2^0}, H^{2^1}, \dots$ ) and employs a binary reduction tree. This allows independent data blocks to be processed concurrently, reducing complexity to $O(\log N)$ .
- Pipeline: The implementation uses asynchronous CUDA streams to overlap host-device memory transfers (using pinned memory) with cryptographic computation. A MapReduce architecture handles massive files (>600 MB) by performing partial reductions on the GPU and combining them without CPU intervention.

Key Contributions

Algorithmic Adaptation: The paper presents the first adaptation of a parallel tree-reduction strategy for the GHASH function on GPUs, transforming a sequential process into a highly parallelizable, logarithmic-time operation suitable for petabyte-scale data.
FITS-Aware Integration: Unlike generic encryption libraries, GpuFitsCrypt produces syntactically valid FITS files that open cleanly in Astropy and cfitsio without modification. It integrates cryptographic authentication tags with the FITS-standard CHECKSUM/DATASUM mechanisms to detect both intentional tampering and accidental corruption.
Policy-Driven Granularity: The framework decouples metadata visibility from data confidentiality through a dual-key architecture, supporting complex access policies (e.g., time-based embargoes, role-based access) without requiring re-encryption of data.
High-Throughput Implementation: The library achieves authenticated encryption throughputs that match the I/O capabilities of modern storage systems, effectively removing the cryptographic bottleneck for large-scale astronomical analysis.

Results
Performance benchmarks were conducted on a range of hardware, from edge devices (Jetson Orin) to consumer workstations (RTX 3060, 3090) and datacenter accelerators (H100, A100, L40S).

Throughput: On the RTX 3090, the GHASH-only kernel achieved 472 Gbps, approximately 1.91x faster than prior state-of-the-art GPU implementations (Lee et al., 2025) using 16 KB blocks. On the L40S, throughput reached 664 Gbps.
Scalability: For "Large" files (600 MB), performance was found to be latency-bound, with system overheads (PCIe, kernel launch) dominating execution time, resulting in comparable performance between consumer and datacenter GPUs. However, for "Extra-Large" files (3.4 GB), the system entered a throughput-bound regime, where datacenter GPUs (H100) demonstrated superior scaling, with Net GCM costs clustering between 6.2 and 6.5 seconds.
Overhead: The cost of adding authentication (GCM) compared to unauthenticated encryption (CTR) ranged from a 1.72x to 4.89x slowdown, depending on the hardware and file size. This reflects the arithmetic cost of finite field multiplications but remains within acceptable limits for high-throughput pipelines.
Scientific Validity: Photometric analysis using the GPUPHOT package on decrypted data confirmed that the framework introduces no numerical artifacts. The decrypted images were bit-exact to the originals, preserving source catalogs and radiometric properties (FWHM, flux) with zero residuals.

Significance
The paper claims that this work resolves the historical trade-off between rigorous security and high-performance data access in astronomy. By leveraging GPU parallelism to overcome the GHASH bottleneck, the framework enables the secure, policy-based management of massive astronomical datasets without hindering research workflows. It provides a robust mechanism for data providers to enforce access policies during proprietary periods, ensuring confidentiality and integrity while facilitating a smooth transition to public, FAIR archives. The authors emphasize that this approach allows for the immediate revocation of access via policy updates without the need to re-encrypt petabytes of data, addressing a critical operational need for modern observatories.