Skip to main content
Glama
Crypto Tools MCP Server

Crypto Tools MCP Server

by marc-shade

crypto_tools_mcp

Crypto Tools MCP Server

MCP Python-3.10+ License Tests Coverage FIPS 140-3 CNSA 2.0 Post-Quantum Part of Agentic System

Defense-grade cryptographic compliance and analysis tools for MCP.

Part of the Agentic System - a 24/7 autonomous AI framework with persistent memory.

Features

Defense Compliance Modules

  • FIPS 140-3 Validator - Validate algorithms against Federal Information Processing Standards

  • CNSA 2.0 Analyzer - NSA Commercial National Security Algorithm Suite readiness

  • Post-Quantum Readiness - NIST FIPS 203/204/205 quantum vulnerability assessment

  • Key Lifecycle Manager - Key state management per NIST SP 800-57 Part 1 Rev 5

  • Crypto Audit Engine - Code/config scanning with CWE mapping and SARIF output

Classical Cryptography

  • Caesar Cipher - Encrypt, decrypt, and crack with frequency analysis

  • Vigenere Cipher - Polyalphabetic substitution cipher

  • XOR Analysis - XOR encryption/decryption and brute-force key recovery

  • ROT13 - Self-inverse Caesar variant

  • Frequency Analysis - Letter frequency and Index of Coincidence

  • Cipher Detection - Automatic cipher type identification


Related MCP server: quantakrypto pqc-tools

Tools

Compliance Tools

Tool

Description

check_fips_compliance

Validate algorithms against FIPS 140-3 approved list

analyze_cnsa_compliance

Check CNSA 2.0 readiness with gap analysis

assess_pqc_readiness

Post-quantum cryptography readiness assessment

manage_key_lifecycle

Key lifecycle management per SP 800-57

audit_crypto_usage

Scan code for cryptographic issues (CWE mapped)

generate_compliance_report

Unified report across all standards

Classical Crypto Tools

Tool

Description

caesar_encrypt

Encrypt plaintext with Caesar cipher

caesar_decrypt

Decrypt ciphertext with known shift

caesar_crack

Crack Caesar cipher using frequency analysis

frequency_analysis

Analyze letter frequencies in text

rot13

ROT13 encode/decode (self-inverse)

vigenere_encrypt

Encrypt with Vigenere cipher

vigenere_decrypt

Decrypt with known Vigenere key

xor_cipher

XOR encrypt/decrypt with key

brute_force_xor

Brute-force XOR with single-byte keys

detect_cipher_type

Identify cipher type used

generate_key

Generate cryptographically secure random key

validate_key

Validate key strength for an algorithm


FIPS 140-3 Compliance

Validates algorithms against the FIPS 140-3 approved list per NIST SP 800-131A Rev 2.

Approved Algorithms

Category

Algorithms

Standard

Symmetric

AES-128, AES-192, AES-256, AES-GCM, AES-CCM

FIPS 197, SP 800-38D

Hash

SHA-224, SHA-256, SHA-384, SHA-512, SHA-3 family

FIPS 180-4, FIPS 202

MAC

HMAC-SHA-2, CMAC-AES, GMAC-AES

FIPS 198-1, SP 800-38B

Signature

RSA (2048+), ECDSA (P-256/384/521), EdDSA

FIPS 186-5

Post-Quantum

ML-KEM, ML-DSA, SLH-DSA

FIPS 203, 204, 205

DRBG

CTR_DRBG, Hash_DRBG, HMAC_DRBG

SP 800-90A Rev 1

KDF

SP 800-108, SP 800-56C, HKDF, PBKDF2

SP 800-108, SP 800-56C

Key Wrap

AES-KW, AES-KWP

SP 800-38F

Disallowed Algorithms

Algorithm

Reason

MD5

Collision attacks trivial

SHA-1

Practical collision attacks (SHAttered, 2017)

DES

56-bit key, brute-forceable since 1998

3DES/TDEA

64-bit block size (Sweet32), deprecated 2023

RC4

Statistical biases, banned in TLS

Blowfish

64-bit block size, not FIPS approved

Dual_EC_DRBG

NSA backdoor, withdrawn

Usage Example

check_fips_compliance(algorithms="AES-256,SHA-384,RSA-2048,MD5,3DES")

CNSA 2.0 (National Security Systems)

Analyzes cryptographic posture against NSA's Commercial National Security Algorithm Suite 2.0.

CNSA 2.0 Required Algorithms

Use Case

Algorithm

Parameter

Symmetric Encryption

AES-256

256-bit key (not 128/192)

Hashing

SHA-384

Minimum (not SHA-256)

Key Encapsulation

ML-KEM-1024

NIST Level 5 (not 512/768)

Digital Signatures

ML-DSA-87

NIST Level 5 (not 44/65)

Hash-Based Signatures

SLH-DSA-256

NIST Level 5 (alternative)

CNSA 2.0 Transition Timeline

Category

Deadline

Requirement

Software/firmware signing

2025

ML-DSA-87 or SLH-DSA-256

Web servers/browsers (TLS)

2025

ML-KEM-1024 + ML-DSA-87

Cloud services

2025

Full CNSA 2.0 suite

Networking equipment

2026

ML-KEM-1024 + ML-DSA-87

Operating systems

2027

Native PQC support

Custom/niche applications

2030

Complete PQC migration

All NSS (full compliance)

2033

Classical algorithms retired

CNSA 1.0 vs 2.0

Use Case

CNSA 1.0

CNSA 2.0

Change

Symmetric

AES-256

AES-256

No change

Hash

SHA-384

SHA-384

No change

Signatures

ECDSA-P384, RSA-3072+

ML-DSA-87, SLH-DSA-256

Classical -> PQC

Key Exchange

ECDH-P384, DH-3072+

ML-KEM-1024

ECDH -> Lattice KEM

Usage Example

analyze_cnsa_compliance(algorithms="AES-256,ECDSA-P384,SHA-256,RSA-2048")

Post-Quantum Cryptography (FIPS 203/204/205)

Assesses readiness for the quantum computing threat per NIST post-quantum standards.

NIST PQC Standards

Standard

Algorithm

Type

NIST Level

Key Size

Sig/CT Size

FIPS 203

ML-KEM-512

KEM

1

800 B

768 B

FIPS 203

ML-KEM-768

KEM

3

1,184 B

1,088 B

FIPS 203

ML-KEM-1024

KEM

5

1,568 B

1,568 B

FIPS 204

ML-DSA-44

Signature

2

1,312 B

2,420 B

FIPS 204

ML-DSA-65

Signature

3

1,952 B

3,309 B

FIPS 204

ML-DSA-87

Signature

5

2,592 B

4,627 B

FIPS 205

SLH-DSA-128s

Signature

1

32 B

7,856 B

FIPS 205

SLH-DSA-256s

Signature

5

64 B

29,792 B

Quantum Vulnerability

Algorithm

Attack

Quantum Security

RSA (all sizes)

Shor's algorithm

0 bits (broken)

ECDSA/ECDH (all curves)

Shor's algorithm

0 bits (broken)

DH (all sizes)

Shor's algorithm

0 bits (broken)

AES-128

Grover's algorithm

64 bits (reduced)

AES-256

Grover's algorithm

128 bits (adequate)

SHA-256

Grover's algorithm

128 bits (adequate)

HNDL Threat Assessment

Harvest-Now-Decrypt-Later (HNDL): adversaries intercept encrypted data today to decrypt once quantum computers are available. The tool calculates HNDL risk based on data sensitivity, shelf life, and algorithm vulnerability.

Usage Example

assess_pqc_readiness(
    algorithms="RSA-2048,ECDSA-P256,AES-256,SHA-256",
    data_sensitivity="critical",
    data_shelf_life_years=15,
    system_type="nss"
)

Key Lifecycle Management (SP 800-57)

Manages cryptographic key states and cryptoperiods per NIST SP 800-57 Part 1 Rev 5.

Key States

Pre-activation -> Active -> Deactivated -> Destroyed
                    |            |
                    v            v
                Suspended   Compromised -> Destroyed-Compromised

Cryptoperiod Limits

Key Type

Max Active Period

Session key (TLS)

24 hours

API key

90 days

Master key

1 year

SSH key

1 year

TLS certificate key

398 days

Symmetric encryption

2 years

Signing private key

3 years

Intermediate CA

3-5 years

Root CA

10-20 years

Usage Examples

# Create and track a key
manage_key_lifecycle(action="create", key_id="prod-aes-1", name="Production AES Key",
                     key_type="symmetric_encryption", algorithm="AES-256",
                     owner="security-team", location="AWS KMS")

# Activate the key
manage_key_lifecycle(action="transition", key_id="prod-aes-1", new_state="active")

# Check compliance
manage_key_lifecycle(action="check", key_id="prod-aes-1")

# Get full inventory
manage_key_lifecycle(action="inventory")

# Check rotation schedule
manage_key_lifecycle(action="rotation")

# Validate key management practices
manage_key_lifecycle(action="validate_practice",
                     practice_description="Keys stored in HSM with RBAC, rotated annually...")

Crypto Audit Engine

Scans code and configuration for cryptographic security issues with CWE mapping.

Detection Categories

Category

Rules

CWE IDs

Hardcoded Secrets

Keys, AWS creds, hex material

CWE-798

Weak Random

Non-CSPRNG usage

CWE-330, CWE-338

Broken Algorithms

MD5, SHA-1, DES, RC4

CWE-327, CWE-328

Insecure Modes

ECB, CBC without HMAC

CWE-327

Missing KDF

Raw password as key

CWE-327

Weak Key Length

RSA <2048, short symmetric

CWE-326

Certificate Issues

verify=False, CERT_NONE

CWE-295

Insecure TLS

SSLv3, TLS 1.0, TLS 1.1

CWE-757

Timing Attacks

Non-constant-time comparison

CWE-208

SARIF Output

The audit engine outputs SARIF (Static Analysis Results Interchange Format) for CI/CD integration with GitHub Code Scanning, Azure DevOps, and other platforms.

Usage Example

# Audit source code
audit_crypto_usage(text="import hashlib\nh = hashlib.md5(data)\nkey = 'hardcoded_secret_key'")

# Get SARIF output for CI/CD
audit_crypto_usage(text=source_code, output_format="sarif")

Comprehensive Compliance Report

Generate a unified report covering all standards.

generate_compliance_report(
    algorithms="AES-256,RSA-2048,SHA-256,ECDSA-P256",
    scan_text=source_code,
    system_type="federal",
    data_sensitivity="high",
    data_shelf_life_years=10
)

Compliance Coverage Matrix

Standard

Control

Coverage

FIPS 140-3

Algorithm validation

Full

SP 800-131A Rev 2

Algorithm transitions

Full

SP 800-57 Part 1

Key management

Full

SP 800-53 SC-12

Key establishment

Full

SP 800-53 SC-13

Cryptographic protection

Full

SP 800-53 SC-17

PKI certificates

Partial

SP 800-53 SC-28

Information at rest

Partial

CNSA 2.0

NSS algorithm suite

Full

CNSSP 15

AES policy

Full

FIPS 203

ML-KEM

Full

FIPS 204

ML-DSA

Full

FIPS 205

SLH-DSA

Full

OMB M-23-02

PQC migration

Full

SP 800-88

Media sanitization

Guidance


Testing

# Run all tests with coverage
python -m pytest tests/ -v --cov=crypto_tools_mcp --cov-report=term-missing

# Run compliance tests only
python -m pytest tests/test_compliance.py -v

# Run classical cipher tests only
python -m pytest tests/test_encryption.py tests/test_hashing.py -v

Test coverage: 412 tests across 6 test modules covering classical ciphers, key management, MCP tool registration, and all five compliance modules (FIPS, CNSA, PQC, Key Lifecycle, Crypto Audit).


Installation

# Clone and install
git clone https://github.com/marc-shade/crypto-tools-mcp.git
cd crypto-tools-mcp
pip install -e .

# Or install with uv
uv pip install -e .

MCP Configuration

Add to your Claude Desktop or MCP client configuration:

{
  "mcpServers": {
    "crypto-tools": {
      "command": "crypto-tools-mcp"
    }
  }
}

Part of the MCP Ecosystem

This server integrates with other MCP servers for comprehensive AGI capabilities:

Server

Purpose

enhanced-memory-mcp

4-tier persistent memory with semantic search

agent-runtime-mcp

Persistent task queues and goal decomposition

agi-mcp

Full AGI orchestration with 21 tools

cluster-execution-mcp

Distributed task routing across nodes

node-chat-mcp

Inter-node AI communication

ember-mcp

Production-only policy enforcement

See agentic-system-oss for the complete framework.

Available Tools

18 tools
analyze_cnsa_complianceA

Check NSA CNSA 2.0 readiness for National Security Systems.

Analyzes algorithms against CNSA 2.0 requirements (AES-256, SHA-384, ML-KEM-1024, ML-DSA-87), tracks transition timeline, and assesses crypto agility.

Args: algorithms: Comma-separated algorithm names (e.g. "AES-256,ECDSA-P384,SHA-256") include_gap_analysis: Include full gap analysis with migration roadmap (default True) scan_text: Optional source code or config text to scan

Returns: JSON CNSA 2.0 compliance analysis with gap assessment

Inputs: algorithms (required), include_gap_analysis, scan_text. Returns: result

assess_pqc_readinessB

Assess post-quantum cryptography readiness per FIPS 203/204/205.

Evaluates quantum vulnerability of current algorithms, calculates quantum risk scores, assesses Harvest-Now-Decrypt-Later threats, and generates PQC migration roadmaps.

Args: algorithms: Comma-separated algorithm names (e.g. "RSA-2048,ECDSA-P256,AES-256") data_sensitivity: Data sensitivity level - "low", "medium", "high", or "critical" data_shelf_life_years: How many years data must remain confidential system_type: System type - "nss" (National Security), "federal", or "general" include_hndl: Include Harvest-Now-Decrypt-Later assessment (default True) include_roadmap: Include migration roadmap (default True)

Returns: JSON post-quantum readiness assessment with risk scores and migration plan

Inputs: algorithms (required), data_sensitivity, data_shelf_life_years, system_type, +2 more. Returns: result

audit_crypto_usageA

Scan text or code for cryptographic security issues.

Detects hardcoded keys, weak algorithms, insecure modes (ECB), missing key derivation, disabled certificate validation, insecure TLS versions, and more. Maps findings to CWE IDs.

Args: text: Source code, configuration, or documentation text to audit output_format: Output format - "json" (default) or "sarif" for CI/CD integration

Returns: JSON audit report with findings, CWE mappings, and remediation

Inputs: text (required), output_format. Returns: result

brute_force_xorA

Brute force XOR cipher with single-byte or short keys.

Args: ciphertext_hex: Hex-encoded ciphertext max_key_length: Maximum key length to try (1-4)

Returns: JSON with potential plaintexts

Inputs: ciphertext_hex (required), max_key_length. Returns: result

caesar_crackA

Crack Caesar cipher using frequency analysis.

Args: ciphertext: Encrypted text to crack show_all: Show all 26 possible decryptions

Returns: JSON with most likely plaintext and shift value

Inputs: ciphertext (required), show_all. Returns: result

caesar_decryptB

Decrypt ciphertext using Caesar cipher with known shift.

Args: ciphertext: Text to decrypt shift: Number of positions that were shifted

Returns: JSON with decrypted plaintext

Inputs: ciphertext (required), shift. Returns: result

caesar_encryptB

Encrypt plaintext using Caesar cipher.

Args: plaintext: Text to encrypt shift: Number of positions to shift (default: 3)

Returns: JSON with encrypted ciphertext

Inputs: plaintext (required), shift. Returns: result

check_fips_complianceA

Validate cryptographic algorithms against FIPS 140-3 approved list.

Checks algorithm compliance, key lengths, security strength per SP 800-57, and maps findings to NIST 800-53 controls (SC-12, SC-13).

Args: algorithms: Comma-separated list of algorithm names (e.g. "AES-256,SHA-384,RSA-2048,MD5") scan_text: Optional source code or config text to scan for algorithm usage

Returns: JSON FIPS 140-3 compliance report with pass/fail per algorithm

Inputs: algorithms (required), scan_text. Returns: result

detect_cipher_typeB

Attempt to identify the type of cipher used.

Args: ciphertext: Encrypted text to analyze

Returns: JSON with cipher type analysis

Inputs: ciphertext (required). Returns: result

frequency_analysisA

Perform letter frequency analysis on text.

Args: text: Text to analyze

Returns: JSON with letter frequencies and comparison to English

Inputs: text (required). Returns: result

generate_compliance_reportA

Generate comprehensive cryptographic compliance report covering FIPS 140-3, CNSA 2.0, post-quantum readiness, and code audit.

Produces a unified report suitable for security assessments, compliance audits, and migration planning.

Args: algorithms: Comma-separated algorithm names to evaluate scan_text: Optional source code or config text to audit system_type: System type - "nss", "federal", or "general" data_sensitivity: Data sensitivity - "low", "medium", "high", or "critical" data_shelf_life_years: How many years data must remain confidential

Returns: JSON comprehensive compliance report across all standards

Inputs: algorithms (required), scan_text, system_type, data_sensitivity, +1 more. Returns: result

generate_keyA

Generate a cryptographically secure random key.

Args: length: Key length (8-64 characters) charset: Character set - alphanumeric, hex, alpha, or full purpose: Description of key purpose for audit log

Returns: JSON with generated key and security info

Inputs: length, charset, purpose. Returns: result

manage_key_lifecycleA

Manage cryptographic key lifecycle per NIST SP 800-57.

Actions: create, transition, check, inventory, rotation, policies, destroy_guidance, report, validate_practice

Args: action: Action to perform - "create", "transition", "check", "inventory", "rotation", "policies", "destroy_guidance", "report", "validate_practice" key_id: Key identifier (required for create, transition, check) name: Human-readable key name (for create) key_type: Key type e.g. "symmetric_encryption", "tls_key", "api_key" (for create) algorithm: Algorithm e.g. "AES-256", "RSA-4096" (for create) key_length_bits: Key length in bits (for create) new_state: Target state for transition - "active", "deactivated", "compromised", "destroyed" reason: Reason for state transition owner: Key owner/custodian location: Key storage location (e.g. "HSM", "AWS KMS") purpose: Key purpose description practice_description: Text description of key management practices (for validate_practice)

Returns: JSON key lifecycle management result

Inputs: action (required), key_id, name, key_type, +8 more. Returns: result

rot13A

Apply ROT13 cipher (self-inverse: encoding = decoding).

Args: text: Text to encode/decode

Returns: JSON with ROT13 result

Inputs: text (required). Returns: result

validate_keyA

Validate a key's strength for the specified algorithm.

Args: key: Key to validate algorithm: Target algorithm (caesar, vigenere, xor)

Returns: JSON with validation results and recommendations

Inputs: key (required), algorithm. Returns: result

vigenere_decryptC

Decrypt ciphertext using Vigenère cipher with known key.

Args: ciphertext: Text to decrypt key: Decryption key

Returns: JSON with decrypted plaintext

Inputs: ciphertext (required), key (required). Returns: result

vigenere_encryptA

Encrypt plaintext using Vigenère cipher.

Args: plaintext: Text to encrypt key: Encryption key (letters only) validate: Whether to validate key strength (default: True)

Returns: JSON with encrypted ciphertext

Inputs: plaintext (required), key (required), validate. Returns: result

xor_cipherA

XOR encrypt/decrypt text with a key.

Args: text: Text or hex string to process key: XOR key input_hex: If True, treat input as hex string

Returns: JSON with XOR result in multiple formats

Inputs: text (required), key (required), input_hex. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 18 tools

    Disambiguation4/5

    Most tools have distinct purposes: Caesar encrypt/decrypt/crack are clearly different; Vigenere and XOR similarly. Compliance tools (FIPS, CNSA, PQC, combined report) overlap somewhat but descriptions clarify their scope. A few analytical tools (frequency_analysis, detect_cipher_type) are distinct. Overall, minimal confusion.

    Naming Consistency4/5

    Names are all lowercase with underscores. Most follow a verb_noun pattern (e.g., generate_key, check_fips_compliance). However, 'frequency_analysis' uses noun_noun and 'rot13' is just a name, deviating from the pattern. Predominantly consistent.

    Tool Count4/5

    18 tools is slightly above the ideal range (3-15) but still reasonable for the breadth of coverage: classical ciphers, compliance, key management, and analysis. Not excessive; each tool serves a clear function.

    Completeness3/5

    The set covers classical ciphers and compliance/audit well, but lacks modern cryptographic operations (AES encryption, hashing, digital signatures). Key management is about metadata, not key pair generation. These are notable gaps for a 'crypto tools' server.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      C
      maintenance
      Enables AI assistants to perform quantum-resistant cryptographic operations using NIST-standardized algorithms including ML-KEM, ML-DSA, and SPHINCS+. Supports key generation, encryption, digital signatures, and security analysis for post-quantum cryptography research and development.
      25
      1
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Post-quantum readiness for AI coding agents: scans code for quantum-vulnerable cryptography (RSA/ECDH/ECDSA/DH) and returns NIST ML-KEM/ML-DSA/SLH-DSA (and hybrid) migration guidance, with fix verification and dependency checks. Content-based, advisory tools only; runs local (npx @quantakrypto/mcp) or as a hosted OAuth endpoint.
      16
      16
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables querying NIST CMVP data for FIPS 140 certificate status, validation history, vendor holdings, CVE associations, Modules in Process phases, and upcoming sunset dates through read-only MCP tools.
      MIT