Autonomous Infrastructure & Code Remediation.
Iron Core delivers closed-loop defense from active zero-days to post-quantum horizons: deploy Force Guard with Mythos & Wiz Engines to ingest scanner CVEs, cloud posture misconfigurations, and toxic attack paths—executing automated, reversible fixes across physical, cloud, and container topologies, and secure cryptographic assets with Force Guard PQC and Iron Ledger. By unifying autonomous exploit neutralization with post-quantum crypto-agility, enterprise SecOps teams eliminate vulnerability backlogs before attackers—or quantum adversaries—can strike.
Mythos & Wiz Remediation: Ingest. Correlate. Remediate. Revert.
Rather than just displaying passive vulnerability alerts from Wiz CNAPP/CSPM/CIEM or Mythos and AWS scanners, ForceGuard transforms findings into actionable, automated, and strictly reversible remediation workflows across cloud workloads, Kubernetes, IAM policies, and application codebases.
Kernel, Container Base Images & Cloud Engines
Automated package, container base image, and managed engine bumps requiring zero application code rewrites.
- ◆ Linux Kernel Livepatch: Netfilter privilege escalation (CVE-2024-1086)
- ◆ Wiz SBOM Package Bump:
fastify@^4.28.1(CVE-2024-34069 ReDoS) &ioredis@>=5.4.1 - ◆ Container Base Bump:
node:20.18.0-alpinemulti-stage rebuild - ◆ Cloud Engine Upgrade: AWS Aurora DB (
aws rds modify-db-cluster)
Cloud Security Groups, Network Rules & Terraform
Automated Infrastructure-as-Code (IaC) diffs, Wiz CIEM IAM least-privilege scoping, and cloud security policies without manual drift.
- ◆ Wiz CIEM IAM Scoping: Pruning wildcards (
dynamodb:*) in ECS Task role policies (CWE-732) - ◆ Wiz DSPM S3 SSL Enforce: Adding
aws:SecureTransport: truedeny condition (CWE-319) - ◆ Ingress Lockdown: Revoking 0.0.0.0/0 rules (
aws ec2 revoke-security-group-ingress) - ◆ Terraform IaC Flip:
enable_internal_network_scan = false
Application Logic, Connection Pools & Gateways
Targeted Abstract Syntax Tree (AST) code patches, configuration diffs, and sanitization routines accompanied by unit tests, Git PR branches, and Jira ticketing.
- ◆ Strict TLS Verification: Injecting
rejectUnauthorized: true& RDS CA bundle into DB pools (CWE-295) - ◆ Wiz Code Patches: Automated PR branch creation with verified unit tests &
WIZ-Jira ticket sync - ◆ Concurrency Mutex: Injecting Redis mutex locks to resolve thundering-herd issues
- ◆ Input Sanitization: AST parameterized queries eliminating SQL/NoSQL injections
Neutralizing Toxic Combinations Across Cloud & Code
Force Guard correlates Wiz cloud security findings with source code Abstract Syntax Trees and Terraform infrastructure definitions, turning multi-vector toxic combinations into automated pull requests, hardened IAM policies, and verified rollback routines.
Multi-Scanner Format Ingestion
Seamlessly accepts Wiz JSON/CSV exports and Mythos security audit files. Intelligent format auto-detection identifies report origins and normalizes disparate risk schemas automatically.
Toxic Combination & Attack Path Resolution
Correlates internet-exposed entry points, vulnerable container packages (e.g. Fastify ReDoS), and overprivileged IAM roles, remediating the root cause rather than creating noisy alerts.
Generative AI Remediation Scripts
Leverages Claude AI to synthesize context-aware bash livepatches, Terraform HCL diffs, and AST source code fixes with passing unit tests and deterministic zero-downtime execution.
Reversible Rollback & SecOps Routing
Every remediation script pairs with an autonomous rollback verification routine. Synchronizes dedicated Jira tickets (WIZ- / MYTH- prefixes) and isolated GitHub PR branches.
The "Harvest Now, Decrypt Later" Crisis
Nation-state threat actors are actively vacuuming encrypted enterprise traffic and intellectual property today. When cryptanalytically relevant quantum computers (CRQCs) arrive on Q-Day, all recorded RSA and ECC communications will be decrypted instantaneously.
Harvest Now, Decrypt Later (HNDL)
Adversaries are intercepting and storing high-value encrypted TLS sessions, financial records, medical archives, and trade secrets today to decrypt them retroactively using Shor's algorithm.
Shor's Algorithm on Q-Day
Unlike classical brute-force limits, Shor's quantum algorithm solves integer factorization (RSA) and discrete logarithms (ECC, Diffie-Hellman) in polynomial time, rendering current public-key cryptography obsolete.
NSA CNSA 2.0 Compliance Mandate
The US Government, NIST, CISA, and international regulators require all software, cloud providers, and critical infrastructure to adopt quantum-resistant algorithms by 2026-2030 or face compliance disqualification.
Global PQC Migration Roadmap (NSA CNSA 2.0 & NIST)
Scan. Map. Remediate. Enforce.
Force Guard by Iron Core combines deep cryptographic static code analysis with generative AI agents to replace vulnerable primitives with zero downtime.
Autonomous CBOM Discovery
Scans git repositories, container images, TLS terminators, and API gateways to compile an exhaustive Cryptographic Bill of Materials (CBOM).
- ◆ Uncovers hidden hardcoded RSA & ECC keys
- ◆ Maps third-party library dependencies
- ◆ Exports CycloneDX & SPDX compliant CBOMs
AI Cryptographic Analysis Agent
Evaluates cryptographic posture against Shor's algorithm threat vectors and assigns risk scores prioritized by data retention longevity.
- ◆ Context-aware semantic AST inspection
- ◆ HNDL vulnerability score per API endpoint
- ◆ Exploitability modeling for quantum timelines
Generative Code Remediation
Force Guard's AI synthesizes production-ready pull requests, refactoring legacy primitives to NIST-approved lattice cryptography with passing unit tests.
- ◆ Drop-in replacements for Python, Go, Java, C++, Rust
- ◆ Hybrid Classical/PQC transition bridges
- ◆ Automated GitHub & GitLab PR integration
Continuous Crypto-Agility
Decouples application logic from specific algorithms so your architecture can swap future primitives via config without recompiling.
- ◆ Algorithm abstraction layer injection
- ◆ Dynamic key exchange negotiation
- ◆ Instant algorithmic rollover without outages
CI/CD Guardrails & Gatekeeper
Blocks new classical asymmetric crypto from entering production branches via pre-commit hooks and pipeline gates.
- ◆ GitHub Actions, GitLab CI, Azure DevOps hooks
- ◆ Policy enforcement (e.g. FIPS 203 Mandatory)
- ◆ Real-time developer IDE linting plugins
Executive Compliance Governance
Comprehensive real-time posture dashboard mapping compliance directly to NIST, NSA CNSA 2.0, PCI-DSS 4.0, and ISO/IEC standards.
- ◆ One-click audit readiness reports
- ◆ Executive risk heatmaps & progress tracking
- ◆ Continuous cryptographic drift alerts
Live Force Guard AI Scanner
Experience how Force Guard detects quantum-vulnerable cryptography in legacy code and synthesizes drop-in NIST FIPS 203/204 lattice replacements.
Automated Cryptographic Bill of Materials (CBOM)
You cannot protect what you cannot see. Force Guard crawls your complete ecosystem to generate a real-time ledger of every algorithm, key length, certificate, and protocol.
| Cryptographic Asset / URI | Component Type | Discovered Primitive | Quantum Threat Level | Force Guard Recommendation | Status |
|---|
Supported NIST Post-Quantum Standards
Force Guard's AI remediation engine natively integrates the newly finalized NIST Federal Information Processing Standards (FIPS).
ML-KEM
The primary NIST standard for general encryption and secure key exchange. Protects against Shor's algorithm via Learning With Errors over Module Lattices.
ML-DSA
NIST primary standard for digital signatures, identity verification, and software code signing. Immune to quantum forgery and polynomial reduction.
SLH-DSA
A non-lattice contingency digital signature scheme based entirely on cryptographic hash functions. Guarantees mathematical hedge against lattice breakthroughs.
FN-DSA
High-performance digital signature standard with compact signature footprint, ideal for constrained IoT devices and high-frequency financial protocols.
Quantum Exposure & HNDL Risk Calculator
Calculate your organization's exposure to "Harvest Now, Decrypt Later" adversaries and find your recommended migration deadline under NSA CNSA 2.0.
CRITICAL QUANTUM EXPOSURE
Your encrypted assets are in severe danger from "Harvest Now, Decrypt Later" adversaries. Intercepted ciphertext today will be retroactively decrypted before data lifespan ends.
Iron Ledger: Quantum-Safe Blockchain
Standard Ethereum relies strictly on ECDSA secp256k1 for transaction signing and BLS12-381 for validator consensus—both fundamentally broken by Shor's algorithm on cryptanalytically relevant quantum computers. Iron Ledger re-engineers the Ethereum Virtual Machine (qEVM) with NIST FIPS 203/204 lattice cryptography, ensuring mathematical quantum immunity with native EVM and Solidity compatibility.
Quantum-Resistant EVM Runtime
Lattice-Based Consensus
Replaces vulnerable BLS12-381 validator aggregation with Module-Lattice Signatures (ML-DSA-65). Provides mathematical hardness based on the Shortest Vector Problem (SVP), impervious to Shor's period-finding.
Standard: NIST FIPS 204 ValidatedQuantum-Resistant EVM (qEVM)
Direct bytecode opcodes and precompiles at 0x0b (ML-KEM) and 0x0c (ML-DSA).
Existing ERC-20, ERC-721, and Uniswap/Aave contracts execute seamlessly with zero gas inflation penalty.
Post-Quantum Account Abstraction
Native ERC-4337 smart wallets with hybrid & pure PQC signature verification. Users sign transactions using hardware tokens or WebAuthn passkeys backed by Falcon-512 and ML-DSA signatures.
Interface: qAA Bundlers & Paymasterszk-STARK Quantum Rollup
High-throughput Layer 2 execution powered by hash-based transparent zk-STARKs. Unlike zk-SNARKs, zk-STARKs require no trusted elliptic curve setup, achieving complete post-quantum provability at 4,500+ TPS.
Scalability: 4,500+ TPS / Hash-ProofQuantum Cryptanalysis Simulation
Evaluate the cryptographic resistance of standard Ethereum ECDSA secp256k1 vs Iron Ledger ML-DSA lattice encryption against a 4096-qubit quantum simulator.
Real-Time Iron Ledger Mainnet Stream
Live simulated block validation with post-quantum lattice signatures and sub-second finality.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
/**
* @title QuantumVault - Protected by Iron Ledger ML-DSA Precompiles
* Native precompile at address 0x0c performs NIST FIPS 204 signature validation
*/
contract QuantumVault {
address constant ML_DSA_PRECOMPILE = address(0x0c);
bytes public quantumOwnerPublicKey; // 1952 bytes ML-DSA-65 public key
event Deposit(address indexed sender, uint256 amount);
event QuantumWithdrawal(bytes32 txHash, uint256 amount);
constructor(bytes memory _mlDsaPublicKey) {
quantumOwnerPublicKey = _mlDsaPublicKey;
}
function withdrawWithPqcSignature(
uint256 amount,
bytes memory signature, // 3293 bytes ML-DSA-65 signature
bytes32 messageHash
) external {
// Call Iron Ledger native qEVM precompile: (pubKey, msgHash, sig) -> (bool valid)
(bool success, bytes memory result) = ML_DSA_PRECOMPILE.staticcall(
abi.encode(quantumOwnerPublicKey, messageHash, signature)
);
require(success && abi.decode(result, (bool)), "Invalid ML-DSA Signature: Quantum Check Failed");
payable(msg.sender).transfer(amount);
emit QuantumWithdrawal(messageHash, amount);
}
}| Protocol Layer | Standard Ethereum (Mainnet) | Shor's Algorithm Threat Matrix | Iron Ledger (qEVM Architecture) | Cryptographic Standard |
|---|---|---|---|---|
| Transaction Signatures | ECDSA (secp256k1, 256-bit curve) | BROKEN: Private keys extracted in polynomial time via Shor | ML-DSA-65 (Dilithium) | NIST FIPS 204 |
| Validator Staking & Consensus | BLS12-381 (Pairing-friendly elliptic curve) | BROKEN: Stakers forged, consensus compromised | Lattice Aggregation + SLH-DSA | NIST FIPS 205 |
| PQC RPC / Node Telemetry | Classical TLS (ECDHE / RSA-2048) | BROKEN: HNDL harvesting decrypts mempool & node traffic | ML-KEM-768 Enclave RPC | NIST FIPS 203 |
| Smart Contract State Proofs | Keccak-256 Merkle Patricia Trie | Grover's speedup reduces hash collision resistance | Keccak-512 + Lattice Vector State Tree | 256-bit Post-Quantum |
| Account Abstraction Wallets | ERC-4337 with classical ECDSA paymasters | Vulnerable to quantum private key derivation | Quantum Account Abstraction (qAA) | Hybrid & Pure PQC |
Engineered for Uncompromising Defense
Built with hardened cryptographic engineering standards for enterprise clouds, national defense, and decentralized quantum-safe financial backbones.
Iron Core Enterprise Architecture
A battle-tested foundation for cyber-resilience. Designed to operate in air-gapped defense enclaves, on-premises datacenters, or hyper-scale cloud deployments.
Force Guard Autonomous Engine
Continuous cryptographic vigilance. Combines heuristic code analysis, automated pull request generation, and runtime crypto-agility enforcement.
Iron Ledger Quantum Blockchain
Ethereum-derived, lattice-secured Layer 1/2 infrastructure. Features post-quantum consensus, qEVM execution, and native NIST FIPS 203/204 precompiles.
Frequently Asked Questions About Post-Quantum Cryptography
Essential technical insights on quantum computing threats, NIST FIPS 203/204/205 standards, cryptographic bill of materials (CBOM) discovery, and quantum-safe blockchain migration.
Post-Quantum Cryptography (PQC) refers to cryptographic mathematical systems—primarily public-key encryption, Key Encapsulation Mechanisms (KEMs), and digital signature algorithms—that are mathematically secure against attacks by both classical supercomputers and Cryptographically Relevant Quantum Computers (CRQCs).
Today's internet and global commerce depend on asymmetric cryptography (RSA, Diffie-Hellman, ECDSA, Ed25519) to encrypt web traffic (TLS), sign software, and secure banking and blockchain transactions. When quantum computers reach sufficient fault-tolerant scale, Shor's algorithm will break these mathematical assumptions instantly. PQC transitions systems to lattice-based, hash-based, and code-based problems that resist quantum cryptanalysis.
Classical asymmetric algorithms rely on problems that are hard for classical computers:
- RSA: The integer factorization problem of finding prime factors $p$ and $q$ of a large number $N = pq$.
- ECC & Diffie-Hellman: The discrete logarithm problem over finite fields or elliptic curve groups.
In 1994, mathematician Peter Shor proved that a quantum computer leveraging quantum superposition, entanglement, and Quantum Fourier Transforms can find the periodic structure of these mathematical groups in polynomial time $O((\log N)^3)$. While factoring an RSA-2048 key would take billions of classical CPU-years, a quantum computer with a few thousand logical qubits could solve it in hours.
Contrastingly, lattice-based cryptography (like ML-KEM and ML-DSA) relies on the hardness of high-dimensional geometric problems (such as the Shortest Vector Problem, or SVP), for which no efficient quantum or classical algorithms are known. Inspect our Quantum Threat Analysis for deep algorithmic comparisons.
Harvest Now, Decrypt Later (HNDL)—also referred to as Store Now, Decrypt Later (SNDL)—is an ongoing espionage and data capture tactic executed by nation-state adversaries and advanced threat actors.
Adversaries intercept and archive encrypted network traffic (VPN tunnels, TLS web traffic, government telemetry, intellectual property transfers, and bank settlements). While they cannot decrypt this data today with classical computers, they are holding the raw ciphertext until a quantum computer capable of running Shor's algorithm becomes operational.
Who is at risk today? Any organization whose data has a confidentiality shelf life exceeding 5 years: defense contractors, healthcare and genomic databases, critical infrastructure, patent portfolios, and financial records. If your data must remain secret past 2030, transmitting it over classical RSA/ECC encryption today guarantees exposure.
In August 2024, the U.S. National Institute of Standards and Technology (NIST) officially released the world's first finalized Federal Information Processing Standards (FIPS) for Post-Quantum Cryptography:
- FIPS 203 (ML-KEM): Module-Lattice-Based Key-Encapsulation Mechanism, derived from CRYSTALS-Kyber. Designed as the primary standard for general encryption and secure key exchanges across TLS and VPNs.
- FIPS 204 (ML-DSA): Module-Lattice-Based Digital Signature Algorithm, derived from CRYSTALS-Dilithium. The primary standard for digital signatures, software signing, and authentication.
- FIPS 205 (SLH-DSA): Stateless Hash-Based Digital Signature Algorithm, derived from SPHINCS+. A backup signature standard reliant strictly on hash functions rather than lattice mathematics.
- FIPS 206 (FN-DSA / Falcon): Fast-Fourier Lattice-Based Digital Signature Algorithm, anticipated for compact signature requirements.
These standards align with the NSA's Commercial National Security Algorithm (CNSA) Suite 2.0 mandate, requiring full migration across sensitive and national security systems between 2025 and 2033. Explore technical specifications in our NIST Standards Matrix.
A Cryptographic Bill of Materials (CBOM) is a structured, machine-readable inventory (standardized in CycloneDX 1.6 and SPDX formats) that documents every cryptographic asset in an application, library, container, or network infrastructure.
A complete CBOM captures:
- Cryptographic algorithms (e.g., RSA, ECDSA, AES, ML-KEM)
- Key lengths and curves (e.g., 2048-bit, secp256k1, prime256v1)
- Cryptographic libraries and dependency versions (e.g., OpenSSL, BouncyCastle, cryptography.io)
- Protocol configurations (TLS 1.2 vs 1.3, cipher suites, certificate chains)
Government directives (U.S. National Security Memorandum 10, CISA guidelines, and EU NIS2 directives) now mandate that organizations catalog their cryptography to systematically identify and eliminate classical algorithms. Test our live CBOM Discovery Explorer.
Manual cryptographic remediation is notoriously slow, costly, and error-prone. Force Guard transforms PQC migration from a multi-year consulting project into continuous, automated DevSecOps:
- Static & Dynamic Supply Chain Scanning: Scans GitHub, GitLab, and Bitbucket repos, analyzing Abstract Syntax Trees (ASTs) in Python, Go, Java, Rust, and C++.
- Automated Pull Request Generation: Detects legacy primitives (e.g.
rsa.generate_private_keyorecdsa.GenerateKey) and writes drop-in code refactors replacing them with NIST FIPS 203 (ML-KEM) and FIPS 204 (ML-DSA) implementations. - Hybrid Fallback Support: Generates dual-signature and hybrid encapsulation schemes (e.g., X25519 + ML-KEM-768) ensuring legacy clients stay connected while quantum security is established.
- Pre-Commit & CI/CD Guardrails: Blocks quantum-vulnerable cryptography from being reintroduced into production repos.
Mythos is ForceGuard's specialized security intelligence engine that ingests, correlates, and resolves infrastructure and code vulnerabilities imported from autonomous security scanners (via CSV uploads or presets such as AWS Cloud & Code run samples).
Rather than just displaying passive vulnerability reports, ForceGuard transforms Mythos findings into actionable, automated, and strictly reversible remediation workflows across three archetypes:
- NO_CODE_UPGRADE: Linux kernel upgrades (e.g. Netfilter CVE-2024-1086), container
base image bumps (
node:20.18.0-alpine), and AWS Aurora DB upgrades requiring zero application rewrites. - INFRA_CONFIG: Automated IaC diffs and cloud CLI security policy adjustments (revoking permissive 0.0.0.0/0 ingress, flipping Terraform variables).
- CODE_REMEDIATION: Targeted AST code patches, configuration diffs, and
sanitization routines (enforcing TLS
rejectUnauthorized: true, injecting Redis mutex locks).
Force Guard natively ingests vulnerability findings and cloud telemetry exported from Wiz CNAPP (including CSPM, CWPP, CIEM, and DSPM in JSON or CSV formats). An intelligent format engine auto-detects report schemas and normalizes findings alongside Mythos.
Instead of leaving engineering teams with complex multi-vector toxic combinations (such as an internet-facing API Gateway connected to a container with vulnerable libraries and an overprivileged IAM role), Force Guard resolves each finding across its proven three-tier architecture:
- NO_CODE_UPGRADE: Container layer dependency bumps (e.g. updating
fastifyto resolve CVE-2024-34069 ReDoS oriorediscluster desync) with zero application code changes required. - INFRA_CONFIG: Automated Terraform IaC updates enforcing S3 SSL in-transit encryption (
aws:SecureTransport: trueCWE-319) and scoping overly permissive IAM role wildcard policies to least-privilege definitions (CWE-732). - CODE_REMEDIATION: Abstract Syntax Tree (AST) patches enforcing strict TLS verification (
rejectUnauthorized: true) and RDS CA root bundles with automated Git PR creation and passing unit test suites.
All remediations dynamically generate deterministic reversible rollback scripts and synchronize with enterprise issue tracking using dedicated WIZ- Jira ticket keys.
Virtually all contemporary blockchains (Bitcoin, Ethereum, Solana) use ECDSA with the secp256k1 curve. Whenever a user initiates a transaction, their public key is exposed on-chain. A quantum computer running Shor's algorithm can derive the private key from the public key in minutes, draining balances and compromising validator consensus.
Iron Ledger is an Ethereum-derived, quantum-safe Layer-1 blockchain engineered to permanently solve this existential vulnerability:
- Lattice Consensus (ML-DSA): Validator voting and block proposal signatures use NIST FIPS 204 lattice cryptography instead of classical BLS or ECDSA.
- qEVM (Quantum EVM): 100% Solidity and Ethereum bytecode compatible, upgraded with
native precompiles (
0x203for ML-KEM,0x204for ML-DSA) for on-chain post-quantum cryptographic operations. - Quantum Account Abstraction (EIP-4337 QAA): Enables users to sign wallet transactions with post-quantum keypairs without sacrificing throughput or paying exorbitant gas fees.
Review architectural diagrams and live testnet stats in the Iron Ledger qEVM Platform Section.
Proposed by world-renowned cryptographer Dr. Michele Mosca, Mosca's Theorem (Theorem of Quantum Risk) provides the mathematical formula used by CISOs and risk officers to assess quantum exposure:
If (X + Y) > Z, then your enterprise is ALREADY exposed to catastrophic risk.
- X (Shelf-Life): The number of years your encrypted data must remain confidential (e.g. 10 to 30 years for healthcare, financial records, defense data).
- Y (Migration Time): The number of years required to re-architect, re-compile, and deploy post-quantum cryptography across all software, firmware, and vendors (typically 5 to 8 years).
- Z (Collapse Time): The estimated number of years until a Cryptographically Relevant Quantum Computer (CRQC) becomes functional (estimated by consensus between 2029 and 2034).
If $X + Y > Z$, any data transmitted today will be retroactively harvested and decrypted by adversaries. Calculate your organization's exact Mosca threshold with our Interactive Quantum Risk Calculator.
Deploy Force Guard
Request a private architecture briefing, trial sandbox, or automated cryptographic audit for your organization.
Privacy Policy
How Iron Core safeguards enterprise cryptographic metadata, scanning telemetry, and user information.
01 Zero Raw Code Retention
Iron Core operates under a strict Zero Raw Code Retention architecture. When Force Guard AST engines parse source code or generate a Cryptographic Bill of Materials (CBOM), AST traversal executes entirely within ephemeral, customer-authorized memory enclaves (on-premises or private enterprise cloud).
- Source code strings, proprietary business logic, and intellectual property are never written to non-volatile storage.
- Scanners do not send application source code to public LLMs or external model training corpora.
- Only localized cryptographic syntax tokens (e.g., algorithm identifiers, key size invocations, cipher suite references) are analyzed.
02 Telemetry & Cryptographic Agility Metadata
To provide quantum risk posture scoring and compliance progress (such as NIST FIPS 203/204/205 and NSA CNSA 2.0 readiness), our platform processes anonymized cryptographic metadata:
- Counts and distribution of classical vs. post-quantum algorithms detected.
- Vulnerability remediation status and git commit hashes associated with automated pull requests.
- Under no circumstances are private keys, seed phrases, certificates containing private keys, or plaintexts collected or stored.
03 Hybrid Post-Quantum Encryption in Transit
All API requests, telemetry transmissions, and administrative portal interactions are secured end-to-end via hybrid TLS configurations combining NIST FIPS 203 (ML-KEM-768/1024) with classical elliptic-curve key exchange, eliminating vulnerability to Harvest Now, Decrypt Later (HNDL) adversarial collection.
04 Enterprise Data Sharing & Third Parties
Iron Core does not monetize, sell, or rent enterprise diagnostic information or telemetry. Data processed under enterprise Master Service Agreements is kept strictly confidential and accessed solely by credentialed Iron Core security engineers for support and service level assurance.
05 Data Subject Rights & Regulatory Compliance
We comply with applicable global privacy frameworks including EU GDPR, UK GDPR, and CCPA/CPRA. Enterprise administrators maintain full ownership of their CBOM data and may request comprehensive data exports or complete cryptographic purge at any time by contacting privacy@ironcore.security.
Terms of Service
Master platform terms governing Force Guard, Iron Ledger, and Post-Quantum Security services.
01 Acceptance & Enterprise Scope
By accessing the Iron Core platform, deploying Force Guard scanners, utilizing Iron Ledger blockchain nodes, or provisioning enterprise evaluation sandboxes, your organization agrees to these Terms of Service. If you represent an entity, you confirm you have authority to bind that entity to these terms.
02 License & Authorized Deployment
Iron Core grants authorized enterprise subscribers a limited, non-exclusive, revocable license to deploy Force Guard scanning agents, CI/CD pre-commit hooks, and Iron Ledger verification modules within approved internal environments.
- Reverse engineering, decompiling, or attempting to replicate the proprietary AST heuristic neural classifiers is strictly prohibited.
- Scanners may only be deployed against codebases, repositories, and networks owned or explicitly authorized by your organization.
- Export and deployment of cryptographic algorithms must adhere to relevant international export regulations.
03 Post-Quantum Remediation & Cryptographic Agility
Force Guard provides automated code remediations and CBOM generation adhering to NIST standards (FIPS 203, 204, 205) and NSA CNSA 2.0 directives. While our remediation engines generate validated drop-in code transforms, cryptanalytic threats evolve; organizations remain responsible for compiling, testing, and certifying remediations within their continuous integration environments prior to production release.
04 Intellectual Property
All software, AI remediation algorithms, neural pattern classifiers, patents, trademarks (including Force Guard and Iron Ledger), and documentation remain the exclusive property of Iron Core Inc. Customer source code, proprietary algorithms, and enterprise CBOM records remain 100% customer property.
05 Limitation of Liability & SLA
Enterprise uptime guarantees, vulnerability remediation SLAs, and indemnification terms are governed by specific Enterprise Master Service Agreements (MSAs). Except as expressly provided in an executed MSA, Iron Core provides services on an "as is" and "as available" basis without warranties of non-infringement or uninterrupted operation.
Cookie & Privacy Preferences
Manage your cryptographic telemetry, session, and platform experience choices. Customize each category below.