[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M75CG4AXJKD8K32ANZ9TQW80":3,"skill-same:01M75CG4AXJKD8K32ANZ9TQW80":47},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":18,"linkOnly":19,"markdownContent":20,"markdownBody":21,"frontMatter":22,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":29,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":6,"updatedAt":32,"install":33,"resources":46},"01M75CG4AXJKD8K32ANZ9TQW80","constant-time-testing",null,"Constant-time testing detects timing side channels in cryptographic code. Use when auditing crypto implementations for timing vulnerabilities.","agisota\u002Fold-one","agisota","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F121413592?v=4","01M75B4BRNT67EC1NDRT8QZEP2","01M75B4BS7QR9VP580MSCPTS3X",3,"MIT","https:\u002F\u002Fgithub.com\u002Fagisota\u002Fold-one\u002Fblob\u002Fmain\u002Fskills\u002Fconstant-time-testing\u002FSKILL.md",[],[],"2026-11-12 13:55:43",false,"---\nname: constant-time-testing\ntype: domain\ndescription: >\n  Constant-time testing detects timing side channels in cryptographic code.\n  Use when auditing crypto implementations for timing vulnerabilities.\n---\n\n# Constant-Time Testing\n\nTiming attacks exploit variations in execution time to extract secret information from cryptographic implementations. Unlike cryptanalysis that targets theoretical weaknesses, timing attacks leverage implementation flaws - and they can affect any cryptographic code.\n\n## Background\n\nTiming attacks were introduced by [Kocher](https:\u002F\u002Fpaulkocher.com\u002Fdoc\u002FTimingAttacks.pdf) in 1996. Since then, researchers have demonstrated practical attacks on RSA ([Schindler](https:\u002F\u002Flink.springer.com\u002Fcontent\u002Fpdf\u002F10.1007\u002F3-540-44499-8_8.pdf)), OpenSSL ([Brumley and Boneh](https:\u002F\u002Fcrypto.stanford.edu\u002F~dabo\u002Fpapers\u002Fssl-timing.pdf)), AES implementations, and even post-quantum algorithms like [Kyber](https:\u002F\u002Feprint.iacr.org\u002F2024\u002F1049.pdf).\n\n### Key Concepts\n\n| Concept | Description |\n|---------|-------------|\n| Constant-time | Code path and memory accesses independent of secret data |\n| Timing leakage | Observable execution time differences correlated with secrets |\n| Side channel | Information extracted from implementation rather than algorithm |\n| Microarchitecture | CPU-level timing differences (cache, division, shifts) |\n\n### Why This Matters\n\nTiming vulnerabilities can:\n- **Expose private keys** - Extract secret exponents in RSA\u002FECDH\n- **Enable remote attacks** - Network-observable timing differences\n- **Bypass cryptographic security** - Undermine theoretical guarantees\n- **Persist silently** - Often undetected without specialized analysis\n\nTwo prerequisites enable exploitation:\n1. **Access to oracle** - Sufficient queries to the vulnerable implementation\n2. **Timing dependency** - Correlation between execution time and secret data\n\n### Common Constant-Time Violation Patterns\n\nFour patterns account for most timing vulnerabilities:\n\n```c\n\u002F\u002F 1. Conditional jumps - most severe timing differences\nif(secret == 1) { ... }\nwhile(secret > 0) { ... }\n\n\u002F\u002F 2. Array access - cache-timing attacks\nlookup_table[secret];\n\n\u002F\u002F 3. Integer division (processor dependent)\ndata = secret \u002F m;\n\n\u002F\u002F 4. Shift operation (processor dependent)\ndata = a \u003C\u003C secret;\n```\n\n**Conditional jumps** cause different code paths, leading to vast timing differences.\n\n**Array access** dependent on secrets enables cache-timing attacks, as shown in [AES cache-timing research](https:\u002F\u002Fcr.yp.to\u002Fantiforgery\u002Fcachetiming-20050414.pdf).\n\n**Integer division and shift operations** leak secrets on certain CPU architectures and compiler configurations.\n\nWhen patterns cannot be avoided, employ [masking techniques](https:\u002F\u002Flink.springer.com\u002Fchapter\u002F10.1007\u002F978-3-642-38348-9_9) to remove correlation between timing and secrets.\n\n### Example: Modular Exponentiation Timing Attacks\n\nModular exponentiation (used in RSA and Diffie-Hellman) is susceptible to timing attacks. RSA decryption computes:\n\n$$ct^{d} \\mod{N}$$\n\nwhere $d$ is the secret exponent. The *exponentiation by squaring* optimization reduces multiplications to $\\log{d}$:\n\n$$\n\\begin{align*}\n& \\textbf{Input: } \\text{base }y,\\text{exponent } d=\\{d_n,\\cdots,d_0\\}_2,\\text{modulus } N \\\\\n& r = 1 \\\\\n& \\textbf{for } i=|n| \\text{ downto } 0: \\\\\n& \\quad\\textbf{if } d_i == 1: \\\\\n& \\quad\\quad r = r * y \\mod{N} \\\\\n& \\quad y = y * y \\mod{N} \\\\\n& \\textbf{return }r\n\\end{align*}\n$$\n\nThe code branches on exponent bit $d_i$, violating constant-time principles. When $d_i = 1$, an additional multiplication occurs, increasing execution time and leaking bit information.\n\nMontgomery multiplication (commonly used for modular arithmetic) also leaks timing: when intermediate values exceed modulus $N$, an additional reduction step is required. An attacker constructs inputs $y$ and $y'$ such that:\n\n$$\n\\begin{align*}\ny^2 \u003C y^3 \u003C N \\\\\ny'^2 \u003C N \\leq y'^3\n\\end{align*}\n$$\n\nFor $y$, both multiplications take time $t_1+t_1$. For $y'$, the second multiplication requires reduction, taking time $t_1+t_2$. This timing difference reveals whether $d_i$ is 0 or 1.\n\n## When to Use\n\n**Apply constant-time analysis when:**\n- Auditing cryptographic implementations (primitives, protocols)\n- Code handles secret keys, passwords, or sensitive cryptographic material\n- Implementing crypto algorithms from scratch\n- Reviewing PRs that touch crypto code\n- Investigating potential timing vulnerabilities\n\n**Consider alternatives when:**\n- Code does not process secret data\n- Public algorithms with no secret inputs\n- Non-cryptographic timing requirements (performance optimization)\n\n## Quick Reference\n\n| Scenario | Recommended Approach | Skill |\n|----------|---------------------|-------|\n| Prove absence of leaks | Formal verification | SideTrail, ct-verif, FaCT |\n| Detect statistical timing differences | Statistical testing | **dudect** |\n| Track secret data flow at runtime | Dynamic analysis | **timecop** |\n| Find cache-timing vulnerabilities | Symbolic execution | Binsec, pitchfork |\n\n## Constant-Time Tooling Categories\n\nThe cryptographic community has developed four categories of timing analysis tools:\n\n| Category | Approach | Pros | Cons |\n|----------|----------|------|------|\n| **Formal** | Mathematical proof on model | Guarantees absence of leaks | Complexity, modeling assumptions |\n| **Symbolic** | Symbolic execution paths | Concrete counterexamples | Time-intensive path exploration |\n| **Dynamic** | Runtime tracing with marked secrets | Granular, flexible | Limited coverage to executed paths |\n| **Statistical** | Measure real execution timing | Practical, simple setup | No root cause, noise sensitivity |\n\n### 1. Formal Tools\n\nFormal verification mathematically proves timing properties on an abstraction (model) of code. Tools create a model from source\u002Fbinary and verify it satisfies specified properties (e.g., variables annotated as secret).\n\n**Popular tools:**\n- [SideTrail](https:\u002F\u002Fgithub.com\u002Faws\u002Fs2n-tls\u002Ftree\u002Fmain\u002Ftests\u002Fsidetrail)\n- [ct-verif](https:\u002F\u002Fgithub.com\u002Fimdea-software\u002Fverifying-constant-time)\n- [FaCT](https:\u002F\u002Fgithub.com\u002Fplsyssec\u002Ffact)\n\n**Strengths:** Proof of absence, language-agnostic (LLVM bytecode)\n**Weaknesses:** Requires expertise, modeling assumptions may miss real-world issues\n\n### 2. Symbolic Tools\n\nSymbolic execution analyzes how paths and memory accesses depend on symbolic variables (secrets). Provides concrete counterexamples. Focus on cache-timing attacks.\n\n**Popular tools:**\n- [Binsec](https:\u002F\u002Fgithub.com\u002Fbinsec\u002Fbinsec)\n- [pitchfork](https:\u002F\u002Fgithub.com\u002FPLSysSec\u002Fhaybale-pitchfork)\n\n**Strengths:** Concrete counterexamples aid debugging\n**Weaknesses:** Path explosion leads to long execution times\n\n### 3. Dynamic Tools\n\nDynamic analysis marks sensitive memory regions and traces execution to detect timing-dependent operations.\n\n**Popular tools:**\n- [Memsan](https:\u002F\u002Fclang.llvm.org\u002Fdocs\u002FMemorySanitizer.html): [Tutorial](https:\u002F\u002Fcrocs-muni.github.io\u002Fct-tools\u002Ftutorials\u002Fmemsan)\n- **Timecop** (see below)\n\n**Strengths:** Granular control, targeted analysis\n**Weaknesses:** Coverage limited to executed paths\n\n> **Detailed Guidance:** See the **timecop** skill for setup and usage.\n\n### 4. Statistical Tools\n\nExecute code with various inputs, measure elapsed time, and detect inconsistencies. Tests actual implementation including compiler optimizations and architecture.\n\n**Popular tools:**\n- **dudect** (see below)\n- [tlsfuzzer](https:\u002F\u002Fgithub.com\u002Ftlsfuzzer\u002Ftlsfuzzer)\n\n**Strengths:** Simple setup, practical real-world results\n**Weaknesses:** No root cause info, noise obscures weak signals\n\n> **Detailed Guidance:** See the **dudect** skill for setup and usage.\n\n## Testing Workflow\n\n```\nPhase 1: Static Analysis        Phase 2: Statistical Testing\n┌─────────────────┐            ┌─────────────────┐\n│ Identify secret │      →     │ Detect timing   │\n│ data flow       │            │ differences     │\n│ Tool: ct-verif  │            │ Tool: dudect    │\n└─────────────────┘            └─────────────────┘\n         ↓                              ↓\nPhase 4: Root Cause             Phase 3: Dynamic Tracing\n┌─────────────────┐            ┌─────────────────┐\n│ Pinpoint leak   │      ←     │ Track secret    │\n│ location        │            │ propagation     │\n│ Tool: Timecop   │            │ Tool: Timecop   │\n└─────────────────┘            └─────────────────┘\n```\n\n**Recommended approach:**\n1. **Start with dudect** - Quick statistical check for timing differences\n2. **If leaks found** - Use Timecop to pinpoint root cause\n3. **For high-assurance** - Apply formal verification (ct-verif, SideTrail)\n4. **Continuous monitoring** - Integrate dudect into CI pipeline\n\n## Tools and Approaches\n\n### Dudect - Statistical Analysis\n\n[Dudect](https:\u002F\u002Fgithub.com\u002Foreparaz\u002Fdudect\u002F) measures execution time for two input classes (fixed vs random) and uses Welch's t-test to detect statistically significant differences.\n\n> **Detailed Guidance:** See the **dudect** skill for complete setup, usage patterns, and CI integration.\n\n#### Quick Start for Constant-Time Analysis\n\n```c\n#define DUDECT_IMPLEMENTATION\n#include \"dudect.h\"\n\nuint8_t do_one_computation(uint8_t *data) {\n    \u002F\u002F Code to measure goes here\n}\n\nvoid prepare_inputs(dudect_config_t *c, uint8_t *input_data, uint8_t *classes) {\n    for (size_t i = 0; i \u003C c->number_measurements; i++) {\n        classes[i] = randombit();\n        uint8_t *input = input_data + (size_t)i * c->chunk_size;\n        if (classes[i] == 0) {\n            \u002F\u002F Fixed input class\n        } else {\n            \u002F\u002F Random input class\n        }\n    }\n}\n```\n\n**Key advantages:**\n- Simple C header-only integration\n- Statistical rigor via Welch's t-test\n- Works with compiled binaries (real-world conditions)\n\n**Key limitations:**\n- No root cause information when leak detected\n- Sensitive to measurement noise\n- Cannot guarantee absence of leaks (statistical confidence only)\n\n### Timecop - Dynamic Tracing\n\n[Timecop](https:\u002F\u002Fpost-apocalyptic-crypto.org\u002Ftimecop\u002F) wraps Valgrind to detect runtime operations dependent on secret memory regions.\n\n> **Detailed Guidance:** See the **timecop** skill for installation, examples, and debugging.\n\n#### Quick Start for Constant-Time Analysis\n\n```c\n#include \"valgrind\u002Fmemcheck.h\"\n\n#define poison(addr, len) VALGRIND_MAKE_MEM_UNDEFINED(addr, len)\n#define unpoison(addr, len) VALGRIND_MAKE_MEM_DEFINED(addr, len)\n\nint main() {\n    unsigned long long secret_key = 0x12345678;\n\n    \u002F\u002F Mark secret as poisoned\n    poison(&secret_key, sizeof(secret_key));\n\n    \u002F\u002F Any branching or memory access dependent on secret_key\n    \u002F\u002F will be reported by Valgrind\n    crypto_operation(secret_key);\n\n    unpoison(&secret_key, sizeof(secret_key));\n}\n```\n\nRun with Valgrind:\n```bash\nvalgrind --leak-check=full --track-origins=yes .\u002Fbinary\n```\n\n**Key advantages:**\n- Pinpoints exact line of timing leak\n- No code instrumentation required\n- Tracks secret propagation through execution\n\n**Key limitations:**\n- Cannot detect microarchitecture timing differences\n- Coverage limited to executed paths\n- Performance overhead (runs on synthetic CPU)\n\n## Implementation Guide\n\n### Phase 1: Initial Assessment\n\n**Identify cryptographic code handling secrets:**\n- Private keys, exponents, nonces\n- Password hashes, authentication tokens\n- Encryption\u002Fdecryption operations\n\n**Quick statistical check:**\n1. Write dudect harness for the crypto function\n2. Run for 5-10 minutes with `timeout 600 .\u002Fct_test`\n3. Monitor t-value: high absolute values indicate leakage\n\n**Tools:** dudect\n**Expected time:** 1-2 hours (harness writing + initial run)\n\n### Phase 2: Detailed Analysis\n\nIf dudect detects leakage:\n\n**Root cause investigation:**\n1. Mark secret variables with Timecop `poison()`\n2. Run under Valgrind to identify exact line\n3. Review the four common violation patterns\n4. Check assembly output for conditional branches\n\n**Tools:** Timecop, compiler output (`objdump -d`)\n\n### Phase 3: Remediation\n\n**Fix the timing leak:**\n- Replace conditional branches with constant-time selection (bitwise operations)\n- Use constant-time comparison functions\n- Replace array lookups with constant-time alternatives or masking\n- Verify compiler doesn't optimize away constant-time code\n\n**Re-verify:**\n1. Run dudect again for extended period (30+ minutes)\n2. Test across different compilers and optimization levels\n3. Test on different CPU architectures\n\n### Phase 4: Continuous Monitoring\n\n**Integrate into CI:**\n- Add dudect tests to test suite\n- Run for fixed duration (5-10 minutes in CI)\n- Fail build if leakage detected\n\nSee the **dudect** skill for CI integration examples.\n\n## Common Vulnerabilities\n\n| Vulnerability | Description | Detection | Severity |\n|---------------|-------------|-----------|----------|\n| Secret-dependent branch | `if (secret_bit) { ... }` | dudect, Timecop | CRITICAL |\n| Secret-dependent array access | `table[secret_index]` | Timecop, Binsec | HIGH |\n| Variable-time division | `result = x \u002F secret` | Timecop | MEDIUM |\n| Variable-time shift | `result = x \u003C\u003C secret` | Timecop | MEDIUM |\n| Montgomery reduction leak | Extra reduction when intermediate > N | dudect | HIGH |\n\n### Secret-Dependent Branch: Deep Dive\n\n**The vulnerability:**\nExecution time differs based on whether branch is taken. Common in optimized modular exponentiation (square-and-multiply).\n\n**How to detect with dudect:**\n```c\nuint8_t do_one_computation(uint8_t *data) {\n    uint64_t base = ((uint64_t*)data)[0];\n    uint64_t exponent = ((uint64_t*)data)[1]; \u002F\u002F Secret!\n    return mod_exp(base, exponent, MODULUS);\n}\n\nvoid prepare_inputs(dudect_config_t *c, uint8_t *input_data, uint8_t *classes) {\n    for (size_t i = 0; i \u003C c->number_measurements; i++) {\n        classes[i] = randombit();\n        uint64_t *input = (uint64_t*)(input_data + i * c->chunk_size);\n        input[0] = rand(); \u002F\u002F Random base\n        input[1] = (classes[i] == 0) ? FIXED_EXPONENT : rand(); \u002F\u002F Fixed vs random\n    }\n}\n```\n\n**How to detect with Timecop:**\n```c\npoison(&exponent, sizeof(exponent));\nresult = mod_exp(base, exponent, modulus);\nunpoison(&exponent, sizeof(exponent));\n```\n\nValgrind will report:\n```\nConditional jump or move depends on uninitialised value(s)\n  at 0x40115D: mod_exp (example.c:14)\n```\n\n**Related skill:** **dudect**, **timecop**\n\n## Case Studies\n\n### Case Study: OpenSSL RSA Timing Attack\n\nBrumley and Boneh (2005) extracted RSA private keys from OpenSSL over a network. The vulnerability exploited Montgomery multiplication's variable-time reduction step.\n\n**Attack vector:** Timing differences in modular exponentiation\n**Detection approach:** Statistical analysis (precursor to dudect)\n**Impact:** Remote key extraction\n\n**Tools used:** Custom timing measurement\n**Techniques applied:** Statistical analysis, chosen-ciphertext queries\n\n### Case Study: KyberSlash\n\nPost-quantum algorithm Kyber's reference implementation contained timing vulnerabilities in polynomial operations. Division operations leaked secret coefficients.\n\n**Attack vector:** Secret-dependent division timing\n**Detection approach:** Dynamic analysis and statistical testing\n**Impact:** Secret key recovery in post-quantum cryptography\n\n**Tools used:** Timing measurement tools\n**Techniques applied:** Differential timing analysis\n\n## Advanced Usage\n\n### Tips and Tricks\n\n| Tip | Why It Helps |\n|-----|--------------|\n| Pin dudect to isolated CPU core (`taskset -c 2`) | Reduces OS noise, improves signal detection |\n| Test multiple compilers (gcc, clang, MSVC) | Optimizations may introduce or remove leaks |\n| Run dudect for extended periods (hours) | Increases statistical confidence |\n| Minimize non-crypto code in harness | Reduces noise that masks weak signals |\n| Check assembly output (`objdump -d`) | Verify compiler didn't introduce branches |\n| Use `-O3 -march=native` in testing | Matches production optimization levels |\n\n### Common Mistakes\n\n| Mistake | Why It's Wrong | Correct Approach |\n|---------|----------------|------------------|\n| Only testing one input distribution | May miss leaks visible with other patterns | Test fixed-vs-random, fixed-vs-fixed-different, etc. |\n| Short dudect runs (\u003C 1 minute) | Insufficient measurements for weak signals | Run 5-10+ minutes, longer for high assurance |\n| Ignoring compiler optimization levels | `-O0` may hide leaks present in `-O3` | Test at production optimization level |\n| Not testing on target architecture | x86 vs ARM have different timing characteristics | Test on deployment platform |\n| Marking too much as secret in Timecop | False positives, unclear results | Mark only true secrets (keys, not public data) |\n\n## Related Skills\n\n### Tool Skills\n\n| Skill | Primary Use in Constant-Time Analysis |\n|-------|---------------------------------------|\n| **dudect** | Statistical detection of timing differences via Welch's t-test |\n| **timecop** | Dynamic tracing to pinpoint exact location of timing leaks |\n\n### Technique Skills\n\n| Skill | When to Apply |\n|-------|---------------|\n| **coverage-analysis** | Ensure test inputs exercise all code paths in crypto function |\n| **ci-integration** | Automate constant-time testing in continuous integration pipeline |\n\n### Related Domain Skills\n\n| Skill | Relationship |\n|-------|--------------|\n| **crypto-testing** | Constant-time analysis is essential component of cryptographic testing |\n| **fuzzing** | Fuzzing crypto code may trigger timing-dependent paths |\n\n## Skill Dependency Map\n\n```\n                    ┌─────────────────────────┐\n                    │  constant-time-analysis │\n                    │     (this skill)        │\n                    └───────────┬─────────────┘\n                                │\n                ┌───────────────┴───────────────┐\n                │                               │\n                ▼                               ▼\n    ┌───────────────────┐           ┌───────────────────┐\n    │      dudect       │           │     timecop       │\n    │  (statistical)    │           │    (dynamic)      │\n    └────────┬──────────┘           └────────┬──────────┘\n             │                               │\n             └───────────────┬───────────────┘\n                             │\n                             ▼\n              ┌──────────────────────────────┐\n              │   Supporting Techniques      │\n              │ coverage, CI integration     │\n              └──────────────────────────────┘\n```\n\n## Resources\n\n### Key External Resources\n\n**[These results must be false: A usability evaluation of constant-time analysis tools](https:\u002F\u002Fwww.usenix.org\u002Fsystem\u002Ffiles\u002Fsec24fall-prepub-760-fourne.pdf)**\nComprehensive usability study of constant-time analysis tools. Key findings: developers struggle with false positives, need better error messages, and benefit from tool integration. Evaluates FaCT, ct-verif, dudect, and Memsan across multiple cryptographic implementations. Recommends improved tooling UX and better documentation.\n\n**[List of constant-time tools - CROCS](https:\u002F\u002Fcrocs-muni.github.io\u002Fct-tools\u002F)**\nCurated catalog of constant-time analysis tools with tutorials. Covers formal tools (ct-verif, FaCT), dynamic tools (Memsan, Timecop), symbolic tools (Binsec), and statistical tools (dudect). Includes practical tutorials for setup and usage.\n\n**[Paul Kocher: Timing Attacks on Implementations of Diffie-Hellman, RSA, DSS, and Other Systems](https:\u002F\u002Fpaulkocher.com\u002Fdoc\u002FTimingAttacks.pdf)**\nOriginal 1996 paper introducing timing attacks. Demonstrates attacks on modular exponentiation in RSA and Diffie-Hellman. Essential historical context for understanding timing vulnerabilities.\n\n**[Remote Timing Attacks are Practical (Brumley & Boneh)](https:\u002F\u002Fcrypto.stanford.edu\u002F~dabo\u002Fpapers\u002Fssl-timing.pdf)**\nDemonstrates practical remote timing attacks against OpenSSL. Shows network-level timing differences are sufficient to extract RSA keys. Proves timing attacks work in realistic network conditions.\n\n**[Cache-timing attacks on AES](https:\u002F\u002Fcr.yp.to\u002Fantiforgery\u002Fcachetiming-20050414.pdf)**\nShows AES implementations using lookup tables are vulnerable to cache-timing attacks. Demonstrates practical attacks extracting AES keys via cache timing side channels.\n\n**[KyberSlash: Division Timings Leak Secrets](https:\u002F\u002Feprint.iacr.org\u002F2024\u002F1049.pdf)**\nRecent discovery of timing vulnerabilities in Kyber (NIST post-quantum standard). Shows division operations leak secret coefficients. Highlights that constant-time issues persist even in modern post-quantum cryptography.\n\n### Video Resources\n\n- [Trail of Bits: Constant-Time Programming](https:\u002F\u002Fwww.youtube.com\u002Fwatch?v=vW6wqTzfz5g) - Overview of constant-time programming principles and tools\n","# Constant-Time Testing\n\nTiming attacks exploit variations in execution time to extract secret information from cryptographic implementations. Unlike cryptanalysis that targets theoretical weaknesses, timing attacks leverage implementation flaws - and they can affect any cryptographic code.\n\n## Background\n\nTiming attacks were introduced by [Kocher](https:\u002F\u002Fpaulkocher.com\u002Fdoc\u002FTimingAttacks.pdf) in 1996. Since then, researchers have demonstrated practical attacks on RSA ([Schindler](https:\u002F\u002Flink.springer.com\u002Fcontent\u002Fpdf\u002F10.1007\u002F3-540-44499-8_8.pdf)), OpenSSL ([Brumley and Boneh](https:\u002F\u002Fcrypto.stanford.edu\u002F~dabo\u002Fpapers\u002Fssl-timing.pdf)), AES implementations, and even post-quantum algorithms like [Kyber](https:\u002F\u002Feprint.iacr.org\u002F2024\u002F1049.pdf).\n\n### Key Concepts\n\n| Concept | Description |\n|---------|-------------|\n| Constant-time | Code path and memory accesses independent of secret data |\n| Timing leakage | Observable execution time differences correlated with secrets |\n| Side channel | Information extracted from implementation rather than algorithm |\n| Microarchitecture | CPU-level timing differences (cache, division, shifts) |\n\n### Why This Matters\n\nTiming vulnerabilities can:\n- **Expose private keys** - Extract secret exponents in RSA\u002FECDH\n- **Enable remote attacks** - Network-observable timing differences\n- **Bypass cryptographic security** - Undermine theoretical guarantees\n- **Persist silently** - Often undetected without specialized analysis\n\nTwo prerequisites enable exploitation:\n1. **Access to oracle** - Sufficient queries to the vulnerable implementation\n2. **Timing dependency** - Correlation between execution time and secret data\n\n### Common Constant-Time Violation Patterns\n\nFour patterns account for most timing vulnerabilities:\n\n```c\n\u002F\u002F 1. Conditional jumps - most severe timing differences\nif(secret == 1) { ... }\nwhile(secret > 0) { ... }\n\n\u002F\u002F 2. Array access - cache-timing attacks\nlookup_table[secret];\n\n\u002F\u002F 3. Integer division (processor dependent)\ndata = secret \u002F m;\n\n\u002F\u002F 4. Shift operation (processor dependent)\ndata = a \u003C\u003C secret;\n```\n\n**Conditional jumps** cause different code paths, leading to vast timing differences.\n\n**Array access** dependent on secrets enables cache-timing attacks, as shown in [AES cache-timing research](https:\u002F\u002Fcr.yp.to\u002Fantiforgery\u002Fcachetiming-20050414.pdf).\n\n**Integer division and shift operations** leak secrets on certain CPU architectures and compiler configurations.\n\nWhen patterns cannot be avoided, employ [masking techniques](https:\u002F\u002Flink.springer.com\u002Fchapter\u002F10.1007\u002F978-3-642-38348-9_9) to remove correlation between timing and secrets.\n\n### Example: Modular Exponentiation Timing Attacks\n\nModular exponentiation (used in RSA and Diffie-Hellman) is susceptible to timing attacks. RSA decryption computes:\n\n$$ct^{d} \\mod{N}$$\n\nwhere $d$ is the secret exponent. The *exponentiation by squaring* optimization reduces multiplications to $\\log{d}$:\n\n$$\n\\begin{align*}\n& \\textbf{Input: } \\text{base }y,\\text{exponent } d=\\{d_n,\\cdots,d_0\\}_2,\\text{modulus } N \\\\\n& r = 1 \\\\\n& \\textbf{for } i=|n| \\text{ downto } 0: \\\\\n& \\quad\\textbf{if } d_i == 1: \\\\\n& \\quad\\quad r = r * y \\mod{N} \\\\\n& \\quad y = y * y \\mod{N} \\\\\n& \\textbf{return }r\n\\end{align*}\n$$\n\nThe code branches on exponent bit $d_i$, violating constant-time principles. When $d_i = 1$, an additional multiplication occurs, increasing execution time and leaking bit information.\n\nMontgomery multiplication (commonly used for modular arithmetic) also leaks timing: when intermediate values exceed modulus $N$, an additional reduction step is required. An attacker constructs inputs $y$ and $y'$ such that:\n\n$$\n\\begin{align*}\ny^2 \u003C y^3 \u003C N \\\\\ny'^2 \u003C N \\leq y'^3\n\\end{align*}\n$$\n\nFor $y$, both multiplications take time $t_1+t_1$. For $y'$, the second multiplication requires reduction, taking time $t_1+t_2$. This timing difference reveals whether $d_i$ is 0 or 1.\n\n## When to Use\n\n**Apply constant-time analysis when:**\n- Auditing cryptographic implementations (primitives, protocols)\n- Code handles secret keys, passwords, or sensitive cryptographic material\n- Implementing crypto algorithms from scratch\n- Reviewing PRs that touch crypto code\n- Investigating potential timing vulnerabilities\n\n**Consider alternatives when:**\n- Code does not process secret data\n- Public algorithms with no secret inputs\n- Non-cryptographic timing requirements (performance optimization)\n\n## Quick Reference\n\n| Scenario | Recommended Approach | Skill |\n|----------|---------------------|-------|\n| Prove absence of leaks | Formal verification | SideTrail, ct-verif, FaCT |\n| Detect statistical timing differences | Statistical testing | **dudect** |\n| Track secret data flow at runtime | Dynamic analysis | **timecop** |\n| Find cache-timing vulnerabilities | Symbolic execution | Binsec, pitchfork |\n\n## Constant-Time Tooling Categories\n\nThe cryptographic community has developed four categories of timing analysis tools:\n\n| Category | Approach | Pros | Cons |\n|----------|----------|------|------|\n| **Formal** | Mathematical proof on model | Guarantees absence of leaks | Complexity, modeling assumptions |\n| **Symbolic** | Symbolic execution paths | Concrete counterexamples | Time-intensive path exploration |\n| **Dynamic** | Runtime tracing with marked secrets | Granular, flexible | Limited coverage to executed paths |\n| **Statistical** | Measure real execution timing | Practical, simple setup | No root cause, noise sensitivity |\n\n### 1. Formal Tools\n\nFormal verification mathematically proves timing properties on an abstraction (model) of code. Tools create a model from source\u002Fbinary and verify it satisfies specified properties (e.g., variables annotated as secret).\n\n**Popular tools:**\n- [SideTrail](https:\u002F\u002Fgithub.com\u002Faws\u002Fs2n-tls\u002Ftree\u002Fmain\u002Ftests\u002Fsidetrail)\n- [ct-verif](https:\u002F\u002Fgithub.com\u002Fimdea-software\u002Fverifying-constant-time)\n- [FaCT](https:\u002F\u002Fgithub.com\u002Fplsyssec\u002Ffact)\n\n**Strengths:** Proof of absence, language-agnostic (LLVM bytecode)\n**Weaknesses:** Requires expertise, modeling assumptions may miss real-world issues\n\n### 2. Symbolic Tools\n\nSymbolic execution analyzes how paths and memory accesses depend on symbolic variables (secrets). Provides concrete counterexamples. Focus on cache-timing attacks.\n\n**Popular tools:**\n- [Binsec](https:\u002F\u002Fgithub.com\u002Fbinsec\u002Fbinsec)\n- [pitchfork](https:\u002F\u002Fgithub.com\u002FPLSysSec\u002Fhaybale-pitchfork)\n\n**Strengths:** Concrete counterexamples aid debugging\n**Weaknesses:** Path explosion leads to long execution times\n\n### 3. Dynamic Tools\n\nDynamic analysis marks sensitive memory regions and traces execution to detect timing-dependent operations.\n\n**Popular tools:**\n- [Memsan](https:\u002F\u002Fclang.llvm.org\u002Fdocs\u002FMemorySanitizer.html): [Tutorial](https:\u002F\u002Fcrocs-muni.github.io\u002Fct-tools\u002Ftutorials\u002Fmemsan)\n- **Timecop** (see below)\n\n**Strengths:** Granular control, targeted analysis\n**Weaknesses:** Coverage limited to executed paths\n\n> **Detailed Guidance:** See the **timecop** skill for setup and usage.\n\n### 4. Statistical Tools\n\nExecute code with various inputs, measure elapsed time, and detect inconsistencies. Tests actual implementation including compiler optimizations and architecture.\n\n**Popular tools:**\n- **dudect** (see below)\n- [tlsfuzzer](https:\u002F\u002Fgithub.com\u002Ftlsfuzzer\u002Ftlsfuzzer)\n\n**Strengths:** Simple setup, practical real-world results\n**Weaknesses:** No root cause info, noise obscures weak signals\n\n> **Detailed Guidance:** See the **dudect** skill for setup and usage.\n\n## Testing Workflow\n\n```\nPhase 1: Static Analysis        Phase 2: Statistical Testing\n┌─────────────────┐            ┌─────────────────┐\n│ Identify secret │      →     │ Detect timing   │\n│ data flow       │            │ differences     │\n│ Tool: ct-verif  │            │ Tool: dudect    │\n└─────────────────┘            └─────────────────┘\n         ↓                              ↓\nPhase 4: Root Cause             Phase 3: Dynamic Tracing\n┌─────────────────┐            ┌─────────────────┐\n│ Pinpoint leak   │      ←     │ Track secret    │\n│ location        │            │ propagation     │\n│ Tool: Timecop   │            │ Tool: Timecop   │\n└─────────────────┘            └─────────────────┘\n```\n\n**Recommended approach:**\n1. **Start with dudect** - Quick statistical check for timing differences\n2. **If leaks found** - Use Timecop to pinpoint root cause\n3. **For high-assurance** - Apply formal verification (ct-verif, SideTrail)\n4. **Continuous monitoring** - Integrate dudect into CI pipeline\n\n## Tools and Approaches\n\n### Dudect - Statistical Analysis\n\n[Dudect](https:\u002F\u002Fgithub.com\u002Foreparaz\u002Fdudect\u002F) measures execution time for two input classes (fixed vs random) and uses Welch's t-test to detect statistically significant differences.\n\n> **Detailed Guidance:** See the **dudect** skill for complete setup, usage patterns, and CI integration.\n\n#### Quick Start for Constant-Time Analysis\n\n```c\n#define DUDECT_IMPLEMENTATION\n#include \"dudect.h\"\n\nuint8_t do_one_computation(uint8_t *data) {\n    \u002F\u002F Code to measure goes here\n}\n\nvoid prepare_inputs(dudect_config_t *c, uint8_t *input_data, uint8_t *classes) {\n    for (size_t i = 0; i \u003C c->number_measurements; i++) {\n        classes[i] = randombit();\n        uint8_t *input = input_data + (size_t)i * c->chunk_size;\n        if (classes[i] == 0) {\n            \u002F\u002F Fixed input class\n        } else {\n            \u002F\u002F Random input class\n        }\n    }\n}\n```\n\n**Key advantages:**\n- Simple C header-only integration\n- Statistical rigor via Welch's t-test\n- Works with compiled binaries (real-world conditions)\n\n**Key limitations:**\n- No root cause information when leak detected\n- Sensitive to measurement noise\n- Cannot guarantee absence of leaks (statistical confidence only)\n\n### Timecop - Dynamic Tracing\n\n[Timecop](https:\u002F\u002Fpost-apocalyptic-crypto.org\u002Ftimecop\u002F) wraps Valgrind to detect runtime operations dependent on secret memory regions.\n\n> **Detailed Guidance:** See the **timecop** skill for installation, examples, and debugging.\n\n#### Quick Start for Constant-Time Analysis\n\n```c\n#include \"valgrind\u002Fmemcheck.h\"\n\n#define poison(addr, len) VALGRIND_MAKE_MEM_UNDEFINED(addr, len)\n#define unpoison(addr, len) VALGRIND_MAKE_MEM_DEFINED(addr, len)\n\nint main() {\n    unsigned long long secret_key = 0x12345678;\n\n    \u002F\u002F Mark secret as poisoned\n    poison(&secret_key, sizeof(secret_key));\n\n    \u002F\u002F Any branching or memory access dependent on secret_key\n    \u002F\u002F will be reported by Valgrind\n    crypto_operation(secret_key);\n\n    unpoison(&secret_key, sizeof(secret_key));\n}\n```\n\nRun with Valgrind:\n```bash\nvalgrind --leak-check=full --track-origins=yes .\u002Fbinary\n```\n\n**Key advantages:**\n- Pinpoints exact line of timing leak\n- No code instrumentation required\n- Tracks secret propagation through execution\n\n**Key limitations:**\n- Cannot detect microarchitecture timing differences\n- Coverage limited to executed paths\n- Performance overhead (runs on synthetic CPU)\n\n## Implementation Guide\n\n### Phase 1: Initial Assessment\n\n**Identify cryptographic code handling secrets:**\n- Private keys, exponents, nonces\n- Password hashes, authentication tokens\n- Encryption\u002Fdecryption operations\n\n**Quick statistical check:**\n1. Write dudect harness for the crypto function\n2. Run for 5-10 minutes with `timeout 600 .\u002Fct_test`\n3. Monitor t-value: high absolute values indicate leakage\n\n**Tools:** dudect\n**Expected time:** 1-2 hours (harness writing + initial run)\n\n### Phase 2: Detailed Analysis\n\nIf dudect detects leakage:\n\n**Root cause investigation:**\n1. Mark secret variables with Timecop `poison()`\n2. Run under Valgrind to identify exact line\n3. Review the four common violation patterns\n4. Check assembly output for conditional branches\n\n**Tools:** Timecop, compiler output (`objdump -d`)\n\n### Phase 3: Remediation\n\n**Fix the timing leak:**\n- Replace conditional branches with constant-time selection (bitwise operations)\n- Use constant-time comparison functions\n- Replace array lookups with constant-time alternatives or masking\n- Verify compiler doesn't optimize away constant-time code\n\n**Re-verify:**\n1. Run dudect again for extended period (30+ minutes)\n2. Test across different compilers and optimization levels\n3. Test on different CPU architectures\n\n### Phase 4: Continuous Monitoring\n\n**Integrate into CI:**\n- Add dudect tests to test suite\n- Run for fixed duration (5-10 minutes in CI)\n- Fail build if leakage detected\n\nSee the **dudect** skill for CI integration examples.\n\n## Common Vulnerabilities\n\n| Vulnerability | Description | Detection | Severity |\n|---------------|-------------|-----------|----------|\n| Secret-dependent branch | `if (secret_bit) { ... }` | dudect, Timecop | CRITICAL |\n| Secret-dependent array access | `table[secret_index]` | Timecop, Binsec | HIGH |\n| Variable-time division | `result = x \u002F secret` | Timecop | MEDIUM |\n| Variable-time shift | `result = x \u003C\u003C secret` | Timecop | MEDIUM |\n| Montgomery reduction leak | Extra reduction when intermediate > N | dudect | HIGH |\n\n### Secret-Dependent Branch: Deep Dive\n\n**The vulnerability:**\nExecution time differs based on whether branch is taken. Common in optimized modular exponentiation (square-and-multiply).\n\n**How to detect with dudect:**\n```c\nuint8_t do_one_computation(uint8_t *data) {\n    uint64_t base = ((uint64_t*)data)[0];\n    uint64_t exponent = ((uint64_t*)data)[1]; \u002F\u002F Secret!\n    return mod_exp(base, exponent, MODULUS);\n}\n\nvoid prepare_inputs(dudect_config_t *c, uint8_t *input_data, uint8_t *classes) {\n    for (size_t i = 0; i \u003C c->number_measurements; i++) {\n        classes[i] = randombit();\n        uint64_t *input = (uint64_t*)(input_data + i * c->chunk_size);\n        input[0] = rand(); \u002F\u002F Random base\n        input[1] = (classes[i] == 0) ? FIXED_EXPONENT : rand(); \u002F\u002F Fixed vs random\n    }\n}\n```\n\n**How to detect with Timecop:**\n```c\npoison(&exponent, sizeof(exponent));\nresult = mod_exp(base, exponent, modulus);\nunpoison(&exponent, sizeof(exponent));\n```\n\nValgrind will report:\n```\nConditional jump or move depends on uninitialised value(s)\n  at 0x40115D: mod_exp (example.c:14)\n```\n\n**Related skill:** **dudect**, **timecop**\n\n## Case Studies\n\n### Case Study: OpenSSL RSA Timing Attack\n\nBrumley and Boneh (2005) extracted RSA private keys from OpenSSL over a network. The vulnerability exploited Montgomery multiplication's variable-time reduction step.\n\n**Attack vector:** Timing differences in modular exponentiation\n**Detection approach:** Statistical analysis (precursor to dudect)\n**Impact:** Remote key extraction\n\n**Tools used:** Custom timing measurement\n**Techniques applied:** Statistical analysis, chosen-ciphertext queries\n\n### Case Study: KyberSlash\n\nPost-quantum algorithm Kyber's reference implementation contained timing vulnerabilities in polynomial operations. Division operations leaked secret coefficients.\n\n**Attack vector:** Secret-dependent division timing\n**Detection approach:** Dynamic analysis and statistical testing\n**Impact:** Secret key recovery in post-quantum cryptography\n\n**Tools used:** Timing measurement tools\n**Techniques applied:** Differential timing analysis\n\n## Advanced Usage\n\n### Tips and Tricks\n\n| Tip | Why It Helps |\n|-----|--------------|\n| Pin dudect to isolated CPU core (`taskset -c 2`) | Reduces OS noise, improves signal detection |\n| Test multiple compilers (gcc, clang, MSVC) | Optimizations may introduce or remove leaks |\n| Run dudect for extended periods (hours) | Increases statistical confidence |\n| Minimize non-crypto code in harness | Reduces noise that masks weak signals |\n| Check assembly output (`objdump -d`) | Verify compiler didn't introduce branches |\n| Use `-O3 -march=native` in testing | Matches production optimization levels |\n\n### Common Mistakes\n\n| Mistake | Why It's Wrong | Correct Approach |\n|---------|----------------|------------------|\n| Only testing one input distribution | May miss leaks visible with other patterns | Test fixed-vs-random, fixed-vs-fixed-different, etc. |\n| Short dudect runs (\u003C 1 minute) | Insufficient measurements for weak signals | Run 5-10+ minutes, longer for high assurance |\n| Ignoring compiler optimization levels | `-O0` may hide leaks present in `-O3` | Test at production optimization level |\n| Not testing on target architecture | x86 vs ARM have different timing characteristics | Test on deployment platform |\n| Marking too much as secret in Timecop | False positives, unclear results | Mark only true secrets (keys, not public data) |\n\n## Related Skills\n\n### Tool Skills\n\n| Skill | Primary Use in Constant-Time Analysis |\n|-------|---------------------------------------|\n| **dudect** | Statistical detection of timing differences via Welch's t-test |\n| **timecop** | Dynamic tracing to pinpoint exact location of timing leaks |\n\n### Technique Skills\n\n| Skill | When to Apply |\n|-------|---------------|\n| **coverage-analysis** | Ensure test inputs exercise all code paths in crypto function |\n| **ci-integration** | Automate constant-time testing in continuous integration pipeline |\n\n### Related Domain Skills\n\n| Skill | Relationship |\n|-------|--------------|\n| **crypto-testing** | Constant-time analysis is essential component of cryptographic testing |\n| **fuzzing** | Fuzzing crypto code may trigger timing-dependent paths |\n\n## Skill Dependency Map\n\n```\n                    ┌─────────────────────────┐\n                    │  constant-time-analysis │\n                    │     (this skill)        │\n                    └───────────┬─────────────┘\n                                │\n                ┌───────────────┴───────────────┐\n                │                               │\n                ▼                               ▼\n    ┌───────────────────┐           ┌───────────────────┐\n    │      dudect       │           │     timecop       │\n    │  (statistical)    │           │    (dynamic)      │\n    └────────┬──────────┘           └────────┬──────────┘\n             │                               │\n             └───────────────┬───────────────┘\n                             │\n                             ▼\n              ┌──────────────────────────────┐\n              │   Supporting Techniques      │\n              │ coverage, CI integration     │\n              └──────────────────────────────┘\n```\n\n## Resources\n\n### Key External Resources\n\n**[These results must be false: A usability evaluation of constant-time analysis tools](https:\u002F\u002Fwww.usenix.org\u002Fsystem\u002Ffiles\u002Fsec24fall-prepub-760-fourne.pdf)**\nComprehensive usability study of constant-time analysis tools. Key findings: developers struggle with false positives, need better error messages, and benefit from tool integration. Evaluates FaCT, ct-verif, dudect, and Memsan across multiple cryptographic implementations. Recommends improved tooling UX and better documentation.\n\n**[List of constant-time tools - CROCS](https:\u002F\u002Fcrocs-muni.github.io\u002Fct-tools\u002F)**\nCurated catalog of constant-time analysis tools with tutorials. Covers formal tools (ct-verif, FaCT), dynamic tools (Memsan, Timecop), symbolic tools (Binsec), and statistical tools (dudect). Includes practical tutorials for setup and usage.\n\n**[Paul Kocher: Timing Attacks on Implementations of Diffie-Hellman, RSA, DSS, and Other Systems](https:\u002F\u002Fpaulkocher.com\u002Fdoc\u002FTimingAttacks.pdf)**\nOriginal 1996 paper introducing timing attacks. Demonstrates attacks on modular exponentiation in RSA and Diffie-Hellman. Essential historical context for understanding timing vulnerabilities.\n\n**[Remote Timing Attacks are Practical (Brumley & Boneh)](https:\u002F\u002Fcrypto.stanford.edu\u002F~dabo\u002Fpapers\u002Fssl-timing.pdf)**\nDemonstrates practical remote timing attacks against OpenSSL. Shows network-level timing differences are sufficient to extract RSA keys. Proves timing attacks work in realistic network conditions.\n\n**[Cache-timing attacks on AES](https:\u002F\u002Fcr.yp.to\u002Fantiforgery\u002Fcachetiming-20050414.pdf)**\nShows AES implementations using lookup tables are vulnerable to cache-timing attacks. Demonstrates practical attacks extracting AES keys via cache timing side channels.\n\n**[KyberSlash: Division Timings Leak Secrets](https:\u002F\u002Feprint.iacr.org\u002F2024\u002F1049.pdf)**\nRecent discovery of timing vulnerabilities in Kyber (NIST post-quantum standard). Shows division operations leak secret coefficients. Highlights that constant-time issues persist even in modern post-quantum cryptography.\n\n### Video Resources\n\n- [Trail of Bits: Constant-Time Programming](https:\u002F\u002Fwww.youtube.com\u002Fwatch?v=vW6wqTzfz5g) - Overview of constant-time programming principles and tools\n",{"name":5,"type":23,"description":7},"domain","main","f37de8f681f0c0ca0e0ebab6e5fddf764ca7553d","skills\u002Fconstant-time-testing",1,"https:\u002F\u002Fgithub.com\u002Fagisota\u002Fold-one","https:\u002F\u002Fagisota.github.io\u002Fold-one\u002F","https:\u002F\u002Fgithub.com\u002Fagisota","pzd.world","2026-07-04 22:32:06",{"source":8,"skillName":5,"commands":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add agisota\u002Fold-one --skill constant-time-testing",{"tool":39,"command":40},"bunx","bunx skills add agisota\u002Fold-one --skill constant-time-testing",{"tool":42,"command":43},"pnpm","pnpm dlx skills add agisota\u002Fold-one --skill constant-time-testing","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fagisota\u002Fold-one\u002Fblob\u002Fmain\u002Fskills\u002Fconstant-time-testing\u002FSKILL.md",true,[],[48,55,62,71,78,85],{"skillNo":49,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":52,"categories":53,"keywords":54,"publishedAt":18},"01M75KRGZWQWE9JDBS6RX42NWV","zoom-out","Tell the agent to zoom out and give broader context or a higher-level perspective. Use when you're unfamiliar with a section of code or need to understand how it fits into the bigger picture.","https:\u002F\u002Fgithub.com\u002Fagisota\u002Fold-one\u002Fblob\u002Fmain\u002Fskills\u002Fzoom-out\u002FSKILL.md",[],[],{"skillNo":56,"name":57,"nameZh":6,"description":58,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":59,"categories":60,"keywords":61,"publishedAt":18},"01M75KRCZHKE0ZYAQFFYHS0YNP","zeroize-audit","Detects missing zeroization of sensitive data in source code and identifies zeroization removed by compiler optimizations, with assembly-level analysis, and control-flow verification. Use for auditing C\u002FC++\u002FRust code handling secrets, keys, passwords, or other sensitive data.","https:\u002F\u002Fgithub.com\u002Fagisota\u002Fold-one\u002Fblob\u002Fmain\u002Fskills\u002Fzeroize-audit\u002FSKILL.md",[],[],{"skillNo":63,"name":64,"nameZh":6,"description":65,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":66,"licenseFileUrl":67,"sourceHtmlUrl":68,"categories":69,"keywords":70,"publishedAt":18},"01M75KR94KYQ30DTE1P9WNDAE0","yeet","Use only when the user explicitly asks to stage, commit, push, and open a GitHub pull request in one flow using the GitHub CLI (`gh`).","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fagisota\u002Fold-one\u002Fblob\u002Fmain\u002Fskills\u002Fyeet\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fagisota\u002Fold-one\u002Fblob\u002Fmain\u002Fskills\u002Fyeet\u002FSKILL.md",[],[],{"skillNo":72,"name":73,"nameZh":6,"description":74,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":75,"categories":76,"keywords":77,"publishedAt":18},"01M75KR3H13YJ9QHMD49818FA1","yara-rule-authoring","Guides authoring of high-quality YARA-X detection rules for malware identification. Use when writing, reviewing, or optimizing YARA rules. Covers naming conventions, string selection, performance optimization, migration from legacy YARA, and false positive reduction. Triggers on: YARA, YARA-X, malware detection, threat hunting, IOC, signature, crx module, dex module.","https:\u002F\u002Fgithub.com\u002Fagisota\u002Fold-one\u002Fblob\u002Fmain\u002Fskills\u002Fyara-rule-authoring\u002FSKILL.md",[],[],{"skillNo":79,"name":80,"nameZh":6,"description":81,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":82,"categories":83,"keywords":84,"publishedAt":18},"01M75KQMPY8A4Y8XTDD2DT0M9T","x-twitter-growth","X\u002FTwitter growth engine for building audience, crafting viral content, and analyzing engagement. Use when the user wants to grow on X\u002FTwitter, write tweets or threads, analyze their X profile, research competitors on X, plan a posting strategy, or optimize engagement. Complements social-content (generic multi-platform) with X-specific depth: algorithm mechanics, thread engineering, reply strategy, profile optimization, and competitive intelligence via web search.","https:\u002F\u002Fgithub.com\u002Fagisota\u002Fold-one\u002Fblob\u002Fmain\u002Fskills\u002Fx-twitter-growth\u002FSKILL.md",[],[],{"skillNo":86,"name":87,"nameZh":6,"description":88,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":89,"categories":90,"keywords":91,"publishedAt":18},"01M75KQHNZ0ANZNJGZY6M8MDAK","x-api","X\u002FTwitter API integration for posting tweets, threads, reading timelines, search, and analytics. Covers OAuth auth patterns, rate limits, and platform-native content posting. Use when the user wants to interact with X programmatically.","https:\u002F\u002Fgithub.com\u002Fagisota\u002Fold-one\u002Fblob\u002Fmain\u002Fskills\u002Fx-api\u002FSKILL.md",[],[]]