Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Crypto Implementation Reviewer

    1

    Technical auditor for detecting weak hashing, insecure AES modes, and flawed key derivation in source code.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Crypto Implementation Reviewer

    Crypto Implementation Reviewer

    Example session with this skill installed

    Review the crypto implementation in our auth module and check for NIST compliance.

    • Read your context and instructions
    • Compiled the crypto implementation reviewer

    I have completed a cryptographic audit of the auth module. I identified two critical vulnerabilities related to legacy hashing and insecure cipher modes.

    Cryptographic Audit Report

    ComponentFound ImplementationRisk LevelRecommendationNIST Requirement
    Password Hashingpbkdf2_sha256MediumMigrate to Argon2idSP 800-132
    Data EncryptionAES-128-ECBCriticalUse AES-256-GCMSP 800-38A/D
    Randomnessos.urandom()SecureKeep current implementationSP 800-90A
    Comparison== operatorHighUse constant_time_compareConstant-time

    Vulnerability Details

    1. Insecure Block Cipher Mode (ECB)
    The current implementation uses Electronic Codebook (ECB) mode. This is insecure as it does not provide serious data confidentiality; identical blocks of plaintext result in identical blocks of ciphertext.
    Remediation: Replace with an authenticated encryption mode like GCM (Galois/Counter Mode).

    2. Non-Constant-Time Comparison
    Detected standard string comparison for MAC verification. This is vulnerable to timing attacks.
    Remediation: Use cryptography.hazmat.primitives.constant_time.bytes_eq.

    Next steps

    1. Update requirements.txt to include modern KDF libraries like argon2-cffi.
    2. Refactor the encryption wrapper to include an Initialization Vector (IV) and Authentication Tag.
    3. Replace all equality checks on sensitive hashes with constant-time comparison functions.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Cryptograhic vulnerabilities often hide in plain sight within application code. This skill audits your source files to detect weak hashing, insecure cipher modes, and flawed key derivation functions before they reach production.

    What it does

    • Algorithm auditing identifies broken or deprecated primitives like MD5, DES, and SHA1.
    • Cipher mode verification flags insecure configurations such as AES-ECB and RSA-PKCS1v1.5.
    • Enforcement of modern standards recommends transitions to AES-256-GCM, ChaCha20-Poly1305, and Argon2id.
    • Entropy analysis verifies cryptographic random generation and ensures constant-time string comparisons.

    How it works

    1. Source scan parses your workspace for cryptographic primitives and cipher suite declarations.
    2. Vulnerability detection matches implementation patterns against a catalog of known weak algorithms and modes.
    3. Standards mapping compares current logic against NIST SP 800-series requirements.
    4. Remediation reporting generates a list of required upgrades for authenticated encryption and key derivation.

    Frameworks & tools

    The skill is designed for standardized libraries including Python's cryptography.io and the Node.js crypto module. It adheres to NIST SP 800-series cryptographic standards for enterprise compliance.

    Why this beats prompting it yourself

    Generic prompts often miss subtle implementation flaws like non-constant-time comparisons or hardcoded salts. This skill uses a deterministic workflow aligned with NIST specifications to ensure no cryptographic primitives are overlooked during static analysis.

    Use cases

    • Audit legacy codebases for deprecated MD5 or SHA1 hashing logic.
    • Identify insecure AES-ECB block cipher modes in API communication.
    • Transition password storage from PBKDF2 to modern Argon2id implementations.
    • Verify that random number generation uses cryptographically secure sources.

    Known limitations

    Static analysis is restricted to the active project workspace. It does not perform dynamic runtime analysis or memory-dump inspections.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Web3 & Crypto.

    Restricted to static analysis within the active workspace. Cannot detect vulnerabilities in pre-compiled binaries or external third-party services.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 4 days ago

    File System Read/Write (strictly scoped to current project workspace `./`). Zero global installation or elevated privileges required.

    Permissions

    Read Files

    Target Use Cases: - Audit our encryption code for weak ciphers or flaws. - Review password hashing implementation in Python. - Check if our AES cipher implementation is secure.

    Listed4 days ago

    What's inside

    Frequently Asked Questions

    The skill focuses on identifying structural cryptographic flaws like insecure AES-ECB modes, weak hashing (MD5/SHA1), and improper key derivation that generic security scanners often overlook. It maps your code directly against NIST SP 800-series standards to ensure enterprise-grade compliance.

    This skill is optimized for environments using Python's cryptography.io and Node.js crypto modules. It functions within any AI agent or IDE extension that supports static source code analysis and workspace parsing.

    No, the skill performs static analysis on your source files to identify implementation errors without needing to execute the code. It does not require access to your production environment or live encryption keys to function.

    You receive the full cryptographic auditing logic, a pre-configured workflow for NIST compliance mapping, and a remediation reporting template. The purchase also includes access to logic updates as new cryptographic standards and vulnerabilities are identified.

    As a static analysis tool, it cannot detect runtime-only issues such as side-channel attacks via power analysis or vulnerabilities hidden in pre-compiled binary dependencies. It is strictly designed to audit the cryptographic logic within your active workspace.

    New in Web3 & Crypto