constant-time-analysis

Detect variable-time instructions in assembly or bytecode for cryptographic implementations.

Updated Nov 23, 2025
One-click install
npx skills add https://github.com/manuelbrandner85/Weltenbibliothekapp --skill constant-time-analysis-manuelbrandner85
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: constant-time-analysis
Source: https://github.com/manuelbrandner85/Weltenbibliothekapp/tree/main/.agents/skills/constant-time-analysis
Command: npx skills add https://github.com/manuelbrandner85/Weltenbibliothekapp --skill constant-time-analysis-manuelbrandner85

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This skill identifies timing side-channel vulnerabilities in cryptographic code, which can leak secret keys or sensitive data through execution time variations.

Core Features & Use Cases

  • Vulnerability Detection: Scans for variable-time instructions like division, modulo, and secret-dependent branches.
  • Multi-Language Support: Analyzes C, C++, Go, Rust, Java, Kotlin, C#, PHP, JavaScript, TypeScript, Python, and Ruby.
  • Use Case: When implementing a new signature verification function, use this skill to ensure that division operations or early-exit comparisons do not leak bits of the private key.

Quick Start

Invoke the constant-time analysis skill to scan the file crypto_implementation.c for potential timing leaks and branch vulnerabilities.

Frequently Asked Questions about constant-time-analysis

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I detect timing side-channel vulnerabilities in cryptographic code?

Detect timing side-channel vulnerabilities by analyzing compiled assembly or bytecode for variable-time instructions, such as division and modulo, that leak secret keys through execution time variations in cryptographic implementations.

What causes a timing side-channel leak in cryptographic implementations?

Timing side-channel leaks are caused by variable-time instructions and secret-dependent branches, such as early-exit comparisons, which allow attackers to observe execution time differences and extract bits of a private key.

Can I scan Rust and Go code for constant-time programming issues?

Yes, you can scan Rust and Go code, along with C, C++, Java, Kotlin, C#, PHP, JavaScript, TypeScript, Python, and Ruby, by analyzing the compiled output for dangerous instructions that violate constant-time programming requirements.

How do I check signature verification functions for private key leaks?

Check signature verification functions by scanning the implementation for division operations and secret-dependent branches that do not execute in constant time, ensuring no bits of the private key are leaked through timing variations.

What is the best way to find secret-dependent branches in cryptography libraries?

The best way to find secret-dependent branches is using static analysis to flag dangerous variable-time instructions in the compiled assembly, providing specific remediation patterns to satisfy constant-time security requirements.

Does constant-time analysis work on both compiled and interpreted languages?

Yes, constant-time analysis supports a wide range of both compiled languages like C, C++, and Rust, and interpreted languages like Python and Ruby, by examining the underlying assembly or bytecode for secret-dependent operations.