鱼皮AI导航
鱼皮AI导航
  • 主页
  • 社区
  • AI工具
  • AI知识库
  • AI提示词
  • MCP
  • Skills
  • AI学习资源
  • AI资讯
  • GitHub开源
登录/注册

wycheproof

提供密码学实现的标准化测试能力,覆盖对称加密、数字签名、密钥交换等主流算法,通过预置的边界条件与攻击向量验证代码在异常输入下的鲁棒性,帮助发现签名可塑性、无效曲线、填充预言等典型漏洞。

测试与安全
访问 GitHub
文档Skills.MD
name
wycheproof
type
domain
description
Wycheproof provides test vectors for validating cryptographic implementations. Use when testing crypto code for known attacks and edge cases.

Wycheproof

Wycheproof is an extensive collection of test vectors designed to verify the correctness of cryptographic implementations and test against known attacks. Originally developed by Google, it is now a community-managed project where contributors can add test vectors for specific cryptographic constructions.

Background

Key Concepts

ConceptDescription
Test vectorInput/output pair for validating crypto implementation correctness
Test groupCollection of test vectors sharing attributes (key size, IV size, curve)
Result flagIndicates if test should pass (valid), fail (invalid), or is acceptable
Edge case testingTesting for known vulnerabilities and attack patterns

Why This Matters

Cryptographic implementations are notoriously difficult to get right. Even small bugs can:

  • Expose private keys
  • Allow signature forgery
  • Enable message decryption
  • Create consensus problems when different implementations accept/reject the same inputs

Wycheproof has found vulnerabilities in major libraries including OpenJDK's SHA1withDSA, Bouncy Castle's ECDHC, and the elliptic npm package.

When to Use

Apply Wycheproof when:

  • Testing cryptographic implementations (AES-GCM, ECDSA, ECDH, RSA, etc.)
  • Validating that crypto code handles edge cases correctly
  • Verifying implementations against known attack vectors
  • Setting up CI/CD for cryptographic libraries
  • Auditing third-party crypto code for correctness

Consider alternatives when:

  • Testing for timing side-channels (use constant-time testing tools instead)
  • Finding new unknown bugs (use fuzzing instead)
  • Testing custom/experimental cryptographic algorithms (Wycheproof only covers established algorithms)

Quick Reference

ScenarioRecommended ApproachNotes
AES-GCM implementationUse aes_gcm_test.json316 test vectors across 44 test groups
ECDSA verificationUse ecdsa_*_test.json for specific curvesTests signature malleability, DER encoding
ECDH key exchangeUse ecdh_*_test.jsonTests invalid curve attacks
RSA signaturesUse rsa_*_test.jsonTests padding oracle attacks
ChaCha20-Poly1305Use chacha20_poly1305_test.jsonTests AEAD implementation

Testing Workflow

▼
text
复制代码
Phase 1: Setup Phase 2: Parse Test Vectors ┌─────────────────┐ ┌─────────────────┐ │ Add Wycheproof │ → │ Load JSON file │ │ as submodule │ │ Filter by params│ └─────────────────┘ └─────────────────┘ ↓ ↓ Phase 4: CI Integration Phase 3: Write Harness ┌─────────────────┐ ┌─────────────────┐ │ Auto-update │ ← │ Test valid & │ │ test vectors │ │ invalid cases │ └─────────────────┘ └─────────────────┘

Repository Structure

The Wycheproof repository is organized as follows:

▼
text
复制代码
┣ 📜 README.md : Project overview ┣ 📂 doc : Documentation ┣ 📂 java : Java JCE interface testing harness ┣ 📂 javascript : JavaScript testing harness ┣ 📂 schemas : Test vector schemas ┣ 📂 testvectors : Test vectors ┗ 📂 testvectors_v1 : Updated test vectors (more detailed)

The essential folders are testvectors and testvectors_v1. While both contain similar files, testvectors_v1 includes more detailed information and is recommended for new integrations.

Supported Algorithms

Wycheproof provides test vectors for a wide range of cryptographic algorithms:

CategoryAlgorithms
Symmetric EncryptionAES-GCM, AES-EAX, ChaCha20-Poly1305
SignaturesECDSA, EdDSA, RSA-PSS, RSA-PKCS1
Key ExchangeECDH, X25519, X448
HashingHMAC, HKDF
Curvessecp256k1, secp256r1, secp384r1, secp521r1, ed25519, ed448

Test File Structure

Each JSON test file tests a specific cryptographic construction. All test files share common attributes:

▼
json
复制代码
"algorithm" : The name of the algorithm tested "schema" : The JSON schema (found in schemas folder) "generatorVersion" : The version number "numberOfTests" : The total number of test vectors in this file "header" : Detailed description of test vectors "notes" : In-depth explanation of flags in test vectors "testGroups" : Array of one or multiple test groups

Test Groups

Test groups group sets of tests based on shared attributes such as:

  • Key sizes
  • IV sizes
  • Public keys
  • Curves

This classification allows extracting tests that meet specific criteria relevant to the construction being tested.

Test Vector Attributes

Shared Attributes

All test vectors contain four common fields:

  • tcId: Unique identifier for the test vector within a file
  • comment: Additional information about the test case
  • flags: Descriptions of specific test case types and potential dangers (referenced in notes field)
  • result: Expected outcome of the test

The result field can take three values:

ResultMeaning
validTest case should succeed
acceptableTest case is allowed to succeed but contains non-ideal attributes
invalidTest case should fail

Unique Attributes

Unique attributes are specific to the algorithm being tested:

AlgorithmUnique Attributes
AES-GCMkey, iv, aad, msg, ct, tag
ECDH secp256k1public, private, shared
ECDSAmsg, sig, result
EdDSAmsg, sig, pk

Implementation Guide

Phase 1: Add Wycheproof to Your Project

Option 1: Git Submodule (Recommended)

Adding Wycheproof as a git submodule ensures automatic updates:

▼
bash
复制代码
git submodule add https://github.com/C2SP/wycheproof.git

Option 2: Fetch Specific Test Vectors

If submodules aren't possible, fetch specific JSON files:

▼
bash
复制代码
#!/bin/bash TMP_WYCHEPROOF_FOLDER=".wycheproof/" TEST_VECTORS=('aes_gcm_test.json' 'aes_eax_test.json') BASE_URL="https://raw.githubusercontent.com/C2SP/wycheproof/master/testvectors_v1/" # Create wycheproof folder mkdir -p $TMP_WYCHEPROOF_FOLDER # Request all test vector files if they don't exist for i in "${TEST_VECTORS[@]}"; do if [ ! -f "${TMP_WYCHEPROOF_FOLDER}${i}" ]; then curl -o "${TMP_WYCHEPROOF_FOLDER}${i}" "${BASE_URL}${i}" if [ $? -ne 0 ]; then echo "Failed to download ${i}" exit 1 fi fi done

Phase 2: Parse Test Vectors

Identify the test file for your algorithm and parse the JSON:

Python Example:

▼
python
复制代码
import json def load_wycheproof_test_vectors(path: str): testVectors = [] try: with open(path, "r") as f: wycheproof_json = json.loads(f.read()) except FileNotFoundError: print(f"No Wycheproof file found at: {path}") return testVectors # Attributes that need hex-to-bytes conversion convert_attr = {"key", "aad", "iv", "msg", "ct", "tag"} for testGroup in wycheproof_json["testGroups"]: # Filter test groups based on implementation constraints if testGroup["ivSize"] < 64 or testGroup["ivSize"] > 1024: continue for tv in testGroup["tests"]: # Convert hex strings to bytes for attr in convert_attr: if attr in tv: tv[attr] = bytes.fromhex(tv[attr]) testVectors.append(tv) return testVectors

JavaScript Example:

▼
javascript
复制代码
const fs = require('fs').promises; async function loadWycheproofTestVectors(path) { const tests = []; try { const fileContent = await fs.readFile(path); const data = JSON.parse(fileContent.toString()); data.testGroups.forEach(testGroup => { testGroup.tests.forEach(test => { // Add shared test group properties to each test test['pk'] = testGroup.publicKey.pk; tests.push(test); }); }); } catch (err) { console.error('Error reading or parsing file:', err); throw err; } return tests; }

Phase 3: Write Testing Harness

Create test functions that handle both valid and invalid test cases.

Python/pytest Example:

▼
python
复制代码
import pytest from cryptography.hazmat.primitives.ciphers.aead import AESGCM tvs = load_wycheproof_test_vectors("wycheproof/testvectors_v1/aes_gcm_test.json") @pytest.mark.parametrize("tv", tvs, ids=[str(tv['tcId']) for tv in tvs]) def test_encryption(tv): try: aesgcm = AESGCM(tv['key']) ct = aesgcm.encrypt(tv['iv'], tv['msg'], tv['aad']) except ValueError as e: # Implementation raised error - verify test was expected to fail assert tv['result'] != 'valid', tv['comment'] return if tv['result'] == 'valid': assert ct[:-16] == tv['ct'], f"Ciphertext mismatch: {tv['comment']}" assert ct[-16:] == tv['tag'], f"Tag mismatch: {tv['comment']}" elif tv['result'] == 'invalid' or tv['result'] == 'acceptable': assert ct[:-16] != tv['ct'] or ct[-16:] != tv['tag'] @pytest.mark.parametrize("tv", tvs, ids=[str(tv['tcId']) for tv in tvs]) def test_decryption(tv): try: aesgcm = AESGCM(tv['key']) decrypted_msg = aesgcm.decrypt(tv['iv'], tv['ct'] + tv['tag'], tv['aad']) except ValueError: assert tv['result'] != 'valid', tv['comment'] return except InvalidTag: assert tv['result'] != 'valid', tv['comment'] assert 'ModifiedTag' in tv['flags'], f"Expected 'ModifiedTag' flag: {tv['comment']}" return assert tv['result'] == 'valid', f"No invalid test case should pass: {tv['comment']}" assert decrypted_msg == tv['msg'], f"Decryption mismatch: {tv['comment']}"

JavaScript/Mocha Example:

▼
javascript
复制代码
const assert = require('assert'); function testFactory(tcId, tests) { it(`[${tcId + 1}] ${tests[tcId].comment}`, function () { const test = tests[tcId]; const ed25519 = new eddsa('ed25519'); const key = ed25519.keyFromPublic(toArray(test.pk, 'hex')); let sig; if (test.result === 'valid') { sig = key.verify(test.msg, test.sig); assert.equal(sig, true, `[${test.tcId}] ${test.comment}`); } else if (test.result === 'invalid') { try { sig = key.verify(test.msg, test.sig); } catch (err) { // Point could not be decoded sig = false; } assert.equal(sig, false, `[${test.tcId}] ${test.comment}`); } }); } // Generate tests for all test vectors for (var tcId = 0; tcId < tests.length; tcId++) { testFactory(tcId, tests); }

Phase 4: CI Integration

Ensure test vectors stay up to date by:

  1. Using git submodules: Update submodule in CI before running tests
  2. Fetching latest vectors: Run fetch script before test execution
  3. Scheduled updates: Set up weekly/monthly updates to catch new test vectors

Common Vulnerabilities Detected

Wycheproof test vectors are designed to catch specific vulnerability patterns:

VulnerabilityDescriptionAffected AlgorithmsExample CVE
Signature malleabilityMultiple valid signatures for same messageECDSA, EdDSACVE-2024-42459
Invalid DER encodingAccepting non-canonical DER signaturesECDSACVE-2024-42460, CVE-2024-42461
Invalid curve attacksECDH with invalid curve pointsECDHCommon in many libraries
Padding oracleTiming leaks in padding validationRSA-PKCS1Historical OpenSSL issues
Tag forgeryAccepting modified authentication tagsAES-GCM, ChaCha20-Poly1305Various implementations

Signature Malleability: Deep Dive

Problem: Implementations that don't validate signature encoding can accept multiple valid signatures for the same message.

Example (EdDSA): Appending or removing zeros from signature:

▼
text
复制代码
Valid signature: ...6a5c51eb6f946b30d Invalid signature: ...6a5c51eb6f946b30d0000 (should be rejected)

How to detect:

▼
python
复制代码
# Add signature length check if len(sig) != 128: # EdDSA signatures must be exactly 64 bytes (128 hex chars) return False

Impact: Can lead to consensus problems when different implementations accept/reject the same signatures.

Related Wycheproof tests:

  • EdDSA: tcId 37 - "removing 0 byte from signature"
  • ECDSA: tcId 06 - "Legacy: ASN encoding of r misses leading 0"

Case Study: Elliptic npm Package

This case study demonstrates how Wycheproof found three CVEs in the popular elliptic npm package (3000+ dependents, millions of weekly downloads).

Overview

The elliptic library is an elliptic-curve cryptography library written in JavaScript, supporting ECDH, ECDSA, and EdDSA. Using Wycheproof test vectors on version 6.5.6 revealed multiple vulnerabilities:

  • CVE-2024-42459: EdDSA signature malleability (appending/removing zeros)
  • CVE-2024-42460: ECDSA DER encoding - invalid bit placement
  • CVE-2024-42461: ECDSA DER encoding - leading zero in length field

Methodology

  1. Identify supported curves: ed25519 for EdDSA
  2. Find test vectors: testvectors_v1/ed25519_test.json
  3. Parse test vectors: Load JSON and extract tests
  4. Write test harness: Create parameterized tests
  5. Run tests: Identify failures
  6. Analyze root causes: Examine implementation code
  7. Propose fixes: Add validation checks

Key Findings

EdDSA Issue (CVE-2024-42459):

  • Missing signature length validation
  • Allowed trailing zeros in signatures
  • Fix: Add if(sig.length !== 128) return false;

ECDSA Issue 1 (CVE-2024-42460):

  • Missing check for first bit being zero in DER-encoded r and s values
  • Fix: Add if ((data[p.place] & 128) !== 0) return false;

ECDSA Issue 2 (CVE-2024-42461):

  • DER length field accepted leading zeros
  • Fix: Add if(buf[p.place] === 0x00) return false;

Impact

All three vulnerabilities allowed multiple valid signatures for a single message, leading to consensus problems across implementations.

Lessons learned:

  • Wycheproof catches subtle encoding bugs
  • Reusable test harnesses pay dividends
  • Test vector comments and flags help diagnose issues
  • Even popular libraries benefit from systematic test vector validation

Advanced Usage

Tips and Tricks

TipWhy It Helps
Filter test groups by parametersFocus on test vectors relevant to your implementation constraints
Use test vector flagsUnderstand specific vulnerability patterns being tested
Check the notes fieldGet detailed explanations of flag meanings
Test both encrypt/decrypt and sign/verifyEnsure bidirectional correctness
Run tests in CICatch regressions and benefit from new test vectors
Use parameterized testsGet clear failure messages with tcId and comment

Common Mistakes

MistakeWhy It's WrongCorrect Approach
Only testing valid casesMisses vulnerabilities where invalid inputs are acceptedTest all result types: valid, invalid, acceptable
Ignoring "acceptable" resultImplementation might have subtle bugsTreat acceptable as warnings worth investigating
Not filtering test groupsWastes time on unsupported parametersFilter by keySize, ivSize, etc. based on your implementation
Not updating test vectorsMiss new vulnerability patternsUse submodules or scheduled fetches
Testing only one directionEncrypt/sign might work but decrypt/verify failsTest both operations

Related Skills

Tool Skills

SkillPrimary Use in Wycheproof Testing
pytestPython testing framework for parameterized tests
mochaJavaScript testing framework for test generation
constant-time-testingComplement Wycheproof with timing side-channel testing
cryptofuzzFuzz-based crypto testing to find additional bugs

Technique Skills

SkillWhen to Apply
coverage-analysisEnsure test vectors cover all code paths in crypto implementation
property-based-testingTest mathematical properties (e.g., encrypt/decrypt round-trip)
fuzz-harness-writingCreate harnesses for crypto parsers (complements Wycheproof)

Related Domain Skills

SkillRelationship
crypto-testingWycheproof is a key tool in comprehensive crypto testing methodology
fuzzingUse fuzzing to find bugs Wycheproof doesn't cover (new edge cases)

Skill Dependency Map

▼
text
复制代码
┌─────────────────────┐ │ wycheproof │ │ (this skill) │ └──────────┬──────────┘ │ ┌───────────────────┼───────────────────┐ │ │ │ ▼ ▼ ▼ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ pytest/mocha │ │ constant-time │ │ cryptofuzz │ │ (test framework)│ │ testing │ │ (fuzzing) │ └────────┬────────┘ └────────┬────────┘ └────────┬────────┘ │ │ │ └───────────────────┼───────────────────┘ │ ▼ ┌──────────────────────────┐ │ Technique Skills │ │ coverage, harness, PBT │ └──────────────────────────┘

Resources

Official Repository

Wycheproof GitHub Repository

The official repository contains:

  • All test vectors in testvectors/ and testvectors_v1/
  • JSON schemas in schemas/
  • Reference implementations in Java and JavaScript
  • Documentation in doc/

Real-World Examples

pycryptodome

The pycryptodome library integrates Wycheproof test vectors in their test suite, demonstrating best practices for Python crypto implementations.

Community Resources

  • C2SP Community - Cryptographic specifications and standards community maintaining Wycheproof
  • Wycheproof issues tracker - Report bugs in test vectors or suggest new constructions

Summary

Wycheproof is an essential tool for validating cryptographic implementations against known attack vectors and edge cases. By integrating Wycheproof test vectors into your testing workflow:

  1. Catch subtle encoding and validation bugs
  2. Prevent signature malleability issues
  3. Ensure consistent behavior across implementations
  4. Benefit from community-contributed test vectors
  5. Protect against known cryptographic vulnerabilities

The investment in writing a reusable testing harness pays dividends through continuous validation as new test vectors are added to the Wycheproof repository.

测试与安全

快捷安装

复制到终端去安装 Skill

npxskillsaddtrailofbits/skills--skill"wycheproof"
站长:程序员鱼皮 老鱼简历 商务合作 增值电信业务经营许可证
2026 鱼皮AI导航 | 沪ICP备19026706号-6
站长:程序员鱼皮 老鱼简历 商务合作 增值电信业务经营许可证
2026 鱼皮AI导航 | 沪ICP备19026706号-6
🔥热门工具
朱雀AI检测朱雀AI检测
朱雀AI检测助手朱雀AI检测助手
LovartLovart
老鱼简历老鱼简历
WritePass官网WritePass官网
面多多面多多
CursorCursor
星月写作星月写作
朱雀AI检测助手朱雀AI检测助手
零感AI零感AI
Skills 推荐
debug
debug 是一个系统化定位软件缺陷根因的技能,适用于用户报告 'fix'、'broken'、'error' 等问题或测试意外失败时。它通过可验证的假设、最小复现、因果链分析和回归测试,确保在修复前准确定位根本原因。
webapp-testing
提供本地 Web 应用的端到端测试能力,支持页面导航、元素交互、表单填写、动态等待、断言验证、截图捕获、浏览器日志收集及网络请求拦截,适用于前端功能验证与 UI 行为调试。
tdd-process
严格遵循测试驱动开发的红绿重构循环,强制执行先写测试、失败要有意义、实现最小化、验证全覆盖的全流程,确保每次代码变更都由可执行的测试用例驱动并经编译、检查与全量验证确认。
smoke-test
自动化创建 Mastra 项目并完成 Studio 全流程冒烟测试,涵盖项目初始化、环境配置、本地服务启动及 Chrome 浏览器中对 Agents、Tools、Workflows、Scorers 等核心模块的功能验证与截图记录。
property-based-testing
通过生成随机输入验证代码在各类边界条件下的行为一致性,适用于序列化、解析、归一化及纯函数等场景,能有效发现隐含缺陷并提升测试覆盖率,尤其适合需要高可靠性的算法与智能合约验证。