constant-time-analysis

Detect timing-side-channel vulnerabilities in cryptographic code across multiple languages.

9|2|Updated Mar 12, 2026
One-click install
npx skills add https://github.com/hongmaple0820/agent-academy --skill constant-time-analysis-hongmaple0820
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: constant-time-analysis
Source: https://github.com/hongmaple0820/agent-academy/tree/main/skills/security-testing/constant-time-analysis/skills/constant-time-analysis
Command: npx skills add https://github.com/hongmaple0820/agent-academy --skill constant-time-analysis-hongmaple0820

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Timing side-channel vulnerabilities in cryptographic code can lead to key leakage and insecure implementations. This skill helps identify risky patterns such as division on secret values, secret-dependent branches, and non-constant-time comparisons across languages, enabling safer crypto coding practices.

Core Features & Use Cases

  • Detects variable-time operations (division/modulus) on secrets and timing-sensitive branches.
  • Provides guidance for constant-time patterns and safe comparisons across C/C++, Go, Rust, Swift, Java, Kotlin, C#, PHP, JavaScript/TypeScript, Python, and Ruby.
  • Produces machine-readable reports for CI pipelines and code reviews to streamline secure development.

Quick Start

Analyze your crypto code by providing source files to receive timing-attack indicators and guidance.

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 attacks by analyzing assembly or bytecode outputs to find secret-dependent branches, division on secrets, and insecure comparisons. It identifies variable-time operations in cryptographic implementations to prevent key leakage.

What types of timing leaks can constant-time crypto analysis identify?▼

Constant-time crypto analysis identifies timing leaks such as division or modulus operations on secret values, secret-dependent branches, and non-constant-time comparisons. These timing-side-channel vulnerabilities can lead to key leakage in cryptographic implementations.

Can I analyze timing attacks across different programming languages?▼

Analyze timing attacks across C, C++, Go, Rust, Swift, Java, Kotlin, C#, PHP, JavaScript, TypeScript, Python, and Ruby. It reviews assembly or bytecode outputs to find timing-side-channel vulnerabilities in various cryptographic implementations.

Does timing-side-channel analysis support CI pipelines and code review workflows?▼

Timing-side-channel analysis supports CI pipelines and code reviews by generating machine-readable JSON reports. These structured outputs flag timing vulnerabilities and provide guidance for constant-time patterns to streamline secure development.

What is the best way to find non-constant-time comparisons in cryptographic implementations?▼

Find non-constant-time comparisons by analyzing assembly or bytecode outputs for insecure comparison patterns. This flags variable-time operations on secrets and provides guidance for safe constant-time coding practices across multiple languages.

Why do I need assembly or bytecode analysis for constant-time verification?▼

Assembly or bytecode analysis is needed for constant-time verification because source code alone can hide timing leaks introduced by compiler optimizations. Analyzing the compiled output detects secret-dependent branches and division on secrets accurately.