dataset1

Dataset Description

This is a synthetic side-channel analysis (SCA) dataset containing power consumption traces captured during AES-128 encryption operations. The dataset is structured similar to the ASCAD format and designed for deep learning-based side-channel attacks.

Dataset Details

• Number of Traces: 10,000
• Trace Length: 5,000 samples per trace
• Encryption Algorithm: AES-128
• Block Size: 16 bytes
• Data Type: Synthetic/Simulated Data
• Storage Format: Parquet (columnar, compressed with Snappy)
• Trace Chunk Size: 1000 traces per file
• Number of Trace Chunks: 10
• Total Dataset Size: ~191.0 MB (uncompressed)

What This Dataset Contains

This dataset captures the power consumption during 10,000 AES-128 encryption operations:

1. Power Traces (Large, Chunked Files):

   • Files: data-traces-00000-of-00010.parquet through data-traces-00009-of-00010.parquet
   • Each trace represents the power consumption measured during one AES encryption
   • 5,000 samples per trace (time-series data)
   • Stored as int32 arrays (will be converted to float during analysis)
   • Chunked for resilience: If download/upload fails, only failed chunks need to be retried

2. Plaintext Metadata (Single Small File):

   • File: data-plaintexts.parquet (~156.2 KB)
   • Contains the 16-byte input data for each AES encryption
   • Each plaintext is an array of 16 integers (0-255)
   • Linked to traces via trace_idx column

3. Ciphertext Metadata (Single Small File):

   • File: data-ciphertexts.parquet (~156.2 KB)
   • Contains the 16-byte encrypted output for each AES encryption
   • Each ciphertext is an array of 16 integers (0-255)
   • Linked to traces via trace_idx column

Data Schema

Trace Files (data-traces-*-of-*.parquet):

Column	Type	Description
trace_idx	int	Unique index (0 to 9999) linking to metadata
trace	list[int32]	Power consumption samples (5,000 values)

Plaintexts File (data-plaintexts.parquet):

Column	Type	Description
trace_idx	int	Index linking to corresponding trace
plaintext	list[uint8]	16-byte AES plaintext input

Ciphertexts File (data-ciphertexts.parquet):

Column	Type	Description
trace_idx	int	Index linking to corresponding trace
ciphertext	list[uint8]	16-byte AES ciphertext output

Usage Examples

Basic Loading with HuggingFace Datasets

from datasets import load_dataset
import pyarrow.parquet as pq
import pyarrow.compute as pc

# Download dataset (automatically handles all chunks)
dataset = load_dataset("DLSCA/dataset1")

# Load and combine all data
trace_tables = [pq.read_table(f) for f in dataset.data_files['traces']]
traces_table = pa.concat_tables(trace_tables)
plaintexts_table = pq.read_table(dataset.data_files['plaintexts'])
ciphertexts_table = pq.read_table(dataset.data_files['ciphertexts'])

# Merge on trace_idx to get complete dataset using pyarrow
import pyarrow as pa
full_table = traces_table.join(plaintexts_table, 'trace_idx').join(ciphertexts_table, 'trace_idx')

print(f"Loaded {len(full_table):,} complete traces")
print(full_table.slice(0, 5))  # Show first 5 rows

Efficient Batch Processing

import pyarrow.parquet as pq
from pathlib import Path
import numpy as np

# Download dataset locally first
dataset = load_dataset("DLSCA/dataset1", cache_dir="./cache")

# Process traces in batches (memory-efficient)
trace_files = sorted(Path("./cache").glob("data-traces-*.parquet"))
plaintexts_table = pq.read_table("./cache/data-plaintexts.parquet")
ciphertexts_table = pq.read_table("./cache/data-ciphertexts.parquet")

for trace_file in trace_files:
    # Load one chunk at a time
    chunk_table = pq.read_table(trace_file)
    
    # Join with metadata
    chunk_full = chunk_table.join(plaintexts_table, 'trace_idx').join(ciphertexts_table, 'trace_idx')
    
    # Process this batch
    for i in range(len(chunk_full)):
        trace = np.array(chunk_full['trace'][i].as_py(), dtype=np.float32)
        plaintext = np.array(chunk_full['plaintext'][i].as_py(), dtype=np.uint8)
        ciphertext = np.array(chunk_full['ciphertext'][i].as_py(), dtype=np.uint8)
        
        # Your side-channel analysis here
        # Example: Extract intermediate value for byte 0
        # sbox_output = AES_SBOX[plaintext[0] ^ key_guess]

PyTorch DataLoader Integration

import torch
from torch.utils.data import Dataset, DataLoader
import pyarrow.parquet as pq
import pyarrow as pa
import numpy as np

class SCADataset(Dataset):
    def __init__(self, traces_table, plaintexts_table, ciphertexts_table):
        # Join all tables on trace_idx
        self.data = traces_table.join(plaintexts_table, 'trace_idx').join(ciphertexts_table, 'trace_idx')
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        trace = torch.tensor(self.data['trace'][idx].as_py(), dtype=torch.float32)
        plaintext = torch.tensor(self.data['plaintext'][idx].as_py(), dtype=torch.uint8)
        ciphertext = torch.tensor(self.data['ciphertext'][idx].as_py(), dtype=torch.uint8)
        return trace, plaintext, ciphertext

# Load dataset
dataset = load_dataset("DLSCA/dataset1")
trace_tables = [pq.read_table(f) for f in dataset['traces']]
traces_table = pa.concat_tables(trace_tables)
plaintexts_table = pq.read_table(dataset['plaintexts'])
ciphertexts_table = pq.read_table(dataset['ciphertexts'])

# Create PyTorch dataset and loader
sca_dataset = SCADataset(traces_table, plaintexts_table, ciphertexts_table)
dataloader = DataLoader(sca_dataset, batch_size=32, shuffle=True)

# Training loop
for traces, plaintexts, ciphertexts in dataloader:
    # Your neural network training here
    pass

Why Chunked Storage?

Problem: Power traces are large (e.g., 5,000 samples × 10,000 traces ≈ 191 MB uncompressed). If upload/download fails at 90%, you'd have to restart from 0%.

Solution:

• Traces are chunked into 10 files of ~1000 traces each
• Metadata stays together in single files (only ~312 KB combined)
• Resume capability: Failed uploads/downloads can continue from the last successful chunk
• Parallel processing: Can process chunks independently for distributed computing

All files are linked via trace_idx, so merging is straightforward with pyarrow.

Use Cases

This dataset is suitable for:

• Deep Learning-based Side-Channel Analysis (DLSCA)
• Profiling attacks on AES implementations
• Machine learning model training for power analysis
• Research on neural network architectures for SCA
• Educational purposes in cryptographic engineering

Dataset Creation

This dataset was automatically generated using the DLSCA platform for side-channel analysis research and development.

Generation Parameters:

• Chunk Size: 1000 traces per file
• Synthetic traces with simulated noise and periodic patterns
• Random plaintexts and ciphertexts (not real AES encryptions)

Citation

If you use this dataset in your research, please cite:

@dataset{dataset1,
  title={dataset1: Synthetic Side-Channel Analysis Dataset},
  author={DLSCA Platform},
  year={2026},
  publisher={HuggingFace},
  url={https://huggingface.co/datasets/DLSCA/dataset1}
}