Side-channel analysis, from power traces to the key

The public ASCAD traces as chunked datasets, a leakage analysis run over them as jobs, and a viewer that shows the samples that leak: the ground a deep-learning key recovery is built on.

Sign in Docs
How DLSCA worksThe public ASCAD power traces are written as chunked Zarr datasets by jobs. A leakage analysis, split over several jobs, computes a target per key byte chunk by chunk into a results dataset, which the node's leakage viewer plots to show the samples that leak. The next step the platform is built towards is a model per key byte that recovers the key.ASCAD tracespower traces,cryptodataDataset jobsHDF5 to Zarr, chunkedascad-v1-fkascad-v1-vkascad-v2, 8 partsDatasetschunked, read by slicetracesplaintext, key, sboxLeakageanalysisN workers, chunk bychunkper target, per byteLeakage vieweron the nodebyte 0 leaksRecover thekeydeep learning, nexta model per bytekey rankleakage_results<dataset>/<byte>/<target>one .npy per chunk

  • Leakage viewer

    Pick a dataset and its targets, and see where the traces leak.

  • Jobs

    The dataset scripts and the leakage analysis, queued as jobs from one dashboard.

  • Blog

    Notes on the platform as it grows.

  • Docs

    How the datasets, the analysis and the viewer fit together.

  • Portfolio

    Write-ups of the analyses run on the platform.

  • Resume

    Who is behind the project.

What DLSCA does

DLSCA is a platform for deep learning based side-channel analysis and cryptographic key recovery. It takes the public ASCAD power traces, writes them as chunked datasets in the project's data store, runs a leakage analysis over them as jobs, and shows the result on a node, so the samples that leak are known before any model is trained.

From traces to a plot

  1. Traces. ASCAD: power traces of AES-128 running on ATmega and STM32 boards, with the plaintext, the key and the masked S-box output of every trace alongside.
  2. Chunked datasets. One job per dataset downloads the HDF5 files, writes them as Zarr in chunks and uploads them as DLSCA/<dataset>: ascad-v1-fk, ascad-v1-vk, and ascad-v2 in eight parts. Any slice can then be read without the rest.
  3. Leakage analysis. Launched as several jobs, each worker takes its share of the trace columns and computes a target, per key byte, chunk by chunk. Each chunk is written as one .npy file into the leakage_results dataset, under <dataset>/<byte>/<target>/.
  4. See where it leaks. The node's leakage viewer pulls the results and plots any targets of a dataset over the samples, downsampled to what a screen can show. A peak is a sample that leaks.

What comes next

The leaky samples are where a model looks. The next step the platform is built towards is a model per key byte, trained on those samples, that ranks the key candidates until the key is recovered.

Where things run

  • This site is the front door: sign in, your profile, the project's page, the blog and the docs, and the node's and the jobs dashboard's pages shown inside it.
  • The node is a FastAPI runtime with its own frontend: it reads what the jobs wrote and launches nothing itself.
  • Jobs run on the jobs infra: each script declares what it needs, its hardware and its timeout, and is launched from the jobs dashboard, its API or an MCP client.
  • The project's data store holds the datasets: the traces and their cryptodata, and the results.

Built on Spiking Neurons Stacks

DLSCA is a project built on Spiking Neurons Stacks: its site, node and jobs are made from the platform's blueprints, and everyone signs in once with One Account. The assistant on this page reads everything published here, so it can answer questions about any of it.