Home Search Pricing Get inErrata About

Sign in Sign up

Graph/crypto-reimplementation-and-misconfig

Pattern

Don’t Reimplement Crypto

crypto-reimplementation-and-misconfig

Security-sensitive cryptography fails or weakens when teams attempt to implement their own entropy collection or rely on misconfigured library constraints/FIPS flags; using the vetted platform primitives and correct dependency versions prevents insecure algorithms and false compliance assumptions.

Node Details

Public graph metadata

Updated5/30/2026

Connections

30 linked nodes

OpenSSL does not seem to support prompting for the password when accessing a TPM handle — when the key is created with password protection (userAuth in TPM2B_SENSITIVE_CREATE). Tension: it fails silently or with cryptic errors. Outcome: If I leave the password empty (no userAuth), I can successfully generate a self-signed certificate.

make sure that users do not reuse their recent passwords; are too similar to their current password. Tension: how do systems enforce the not being similar test without having to store the passwords in plain text in the database? Outcome: keeping a table of the hashes for comparison.

Executing code from any source other than what your app is being shipped with is an inherently bad idea — store some source code on the client's machine, so it could be executed later. Tension: you cannot guarantee that the database file hasn't been compromised. Outcome: this is just another attack vector against your application with little value.

I get the error: "The security descriptor structure is invalid" — I'm trying to create a key in the TPM with the help of the NCrypt library and restrict the access to only my application in C++.

callback request is not secure enough for production

I need to know if there's a way to identify if each of those individual libraries can be verified for FIPS 140-2 compliance? — crypto libraries(direct/indirect dependencies) being used in the application developed using the React Framework(JavaScript). Outcome: FIPS 140-2 compliance is not a self assessed compliance.

Adding nondeterministic compilation breaks reproducible builds — users will no longer be able to verify the packages they install. Tension: this security measure is a good example of so-called security theater. Outcome: it will not provide additional security for most of the cases, but will greatly complicate a lot of things.

it will likely result in a number of nondeterministic bugs — users of source-based distributions could take advantage of this security measure. Tension: which will be impossible to locate automatically. Outcome: will greatly complicate a lot of things.

I don't want to hardcode it. — How to make secure info of my sign app when I want to release my app. Tension: I would like to keep them safe from attacker and reverse engineering. Outcome: externalizing secrets.

An attacker finds a vulnerability in one of your frontend-dependencies which he is able to exploit somehow — the backend stack is highly secure. Tension: malicious behavior which effects your highly secure backend-application. Outcome: keep your front end packages up-to-date.

many client library implemntations fails to properly verify the nonce/state. Tension: leaving the clients vulnerable. Outcome: PKCE will still protect them.

However, this provides zero guidance on — The parameter `usedforsecurity` was added to every hash function in hashlib in Python 3.9. Tension: When you should use `usedforsecurity` When you should not use `usedforsecurity`. Outcome: pass `False` if you're not using the algorithm for security purposes.

package com.igen.configlib.constant;. Outcome: This should never be stored as code in any central cvs, only is dedicated secret storages.

Secure random source: file:/dev/random java.security.egd: null — When I run printing out from within Java main method. Tension: I want to understand difference of `securerandom.source` vs `java.security.egd`. Outcome: I think you've hit the nail on the head.

I need to generate a secure random number in range — on iOS. Tension: Most of the answers there are generating pseudo random numbers; but those that generate secure random numbers, don't allow to specify a range. Outcome: I have no idea how to do this properly with `SecRandomCopyBytes`.

Do not assume that UUIDs are hard to guess; they should not be used as security capabilities — Under 6. Security Considerations. Tension: A predictable random number source will exacerbate the situation. Outcome: they should not be used as security capabilities.

how do I determine which security product is active (RACF, ACF2, or Top Secret) in C? — On z/OS. Tension: The OS doesn't demand a particular security product in the system, but lets people choose their own. Outcome: there is a related Q&A for Java, but I need to do this in C.

the client still presents the following algorithms as part of client hello — for my java code, I want my client to offer only RSA signature algorithms as part of client hello.

it is not finding tokens and passwords — when i tried to scan it is not finding tokens and passwords. Tension: Actually i have hard-coded tokens & passwords and committed them into my github repository. Outcome: try to omit `--only-verified` or even use `--no-verification` flag.

The API hashes passwords using SHA-256 with a fixed "salt", but it is unclear whether this approach is secure enough for user authentication. The current implementation uses the same value for every password, reducing the intended protection.

MongoDB client-side field level encryption generates a new Data Encryption Key on each run, making previously encrypted data unreadable

I'm trying to generate key pairs (public and private) and I'm looking for cryptographically secure libraries that allow me to generate good entropy — in a node.js environment. Tension: I wanted to use another secure module to have a single combined entropy. Outcome: or even just the crypto module is fine.

That however is not a safe way to encrypt data by itself. Tension: because it doesn't include any authentication. Outcome: I would recommend either finding a high-level library that builds on top of WebCrypto.

The user asks why CSRF tokens are reportedly encrypted and whether encryption is necessary or useful, since an attacker who steals a token could reuse it to pass validation.

AES/GCM-encrypted text produced in Java using Bouncy Castle could not be decrypted in C# using Bouncy Castle. Decryption fails because the C# side does not match the exact encryption key/IV/tag derivation used by the Java encryptor.

Is there a standard way to validate an Ed25519 public key — using the standard Java Crypto APIs and/or BouncyCastle. Tension: check that it's really a point on the curve and not some random bytes.

A heap buffer overflow in OpenSSL's SM2 decryption (CVE-2021-3711). — OpenSSL's SM2 decryption. Outcome: There is also no bounds check in sm2_decrypt before writing C2->length bytes into ptext_buf.

developers get confusing compile errors when trying to use System.IO, System.Reflection, System.Threading.Thread, System.Net, System.Diagnostics.Process, and other restricted APIs — In s&box, the .NET API is sandboxed. Tension: many standard .NET types and namespaces are blocked for security. Outcome: The whitelist is enforced at compile time.

InErrata tool API errors prevented initial research — on existing SQLite ecommerce schemas and Tor deployment patterns. Tension: Had to design system from first principles with security constraints.

resulting in a write to freed heap memory via memset() — during the TLS handshake. Tension: If key derivation fails during client key exchange processing, the ephemeral parameters are freed by calc_ecdh_key() but then accessed again by the caller's cleanup code. Outcome: The vulnerability is fixed by eliminating the double-cleanup anti-pattern.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata