Method and system for runtime execution integrity verification and autonomous policy-based control based on third-party certification

The real-time verification and control architecture addresses the runtime trust gap in dynamic software environments by ensuring continuous integrity validation and autonomous responses, aligning with international standards and regulatory requirements.

WO2026235223A1PCT designated stage Publication Date: 2026-11-12YU JAEHYUN
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
PCT/KR2025/006451
Authority / Receiving Office
WO · WO
Patent Type
Applications
Current Assignee / Owner
Priority Date
2025-05-09
Filing Date
2025-05-13
Publication Date
2026-11-12

AI Technical Summary

Technical Problem

Conventional software certification frameworks assume static immutability, failing to address the runtime trust gap in dynamically evolving digital environments where software is continuously updated and deployed, leading to discrepancies between certified and actual execution behavior.

Method used

A real-time verification and control architecture that integrates third-party certified hash baselines, integrity monitoring agents, policy-based response mechanisms, and immutable logging systems to ensure continuous integrity validation and autonomous control.

Benefits of technology

Ensures persistent operational integrity by continuously validating software logic against certified states, enabling autonomous responses and tamper-evident logging, aligning with international standards and regulatory requirements.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure KR2025006451_12112026_PF_FP_ABST
    Figure KR2025006451_12112026_PF_FP_ABST
Patent Text Reader

Abstract

The invention describes a system and method for runtime integrity verification and autonomous control using certified reference data. Certified logic modules―including application code, AI models, and control scripts―are hashed and registered during a pre-deployment certification phase. During operation, the system continuously or periodically generates live hashes and compares them with pre-certified values. If deviations are detected, policy-based control actions such as halting, fallback, or isolation are automatically triggered. All events are immutably logged with trusted timestamps in secure storage such as blockchain or WORM devices. The system supports agent-based or agentless deployment, deterministic or supervised builds, and integrates with external monitoring systems. Applicable to domains such as AI governance, digital voting, financial systems, lotteries, autonomous vehicles, and medical diagnostics, the invention enables real-time enforcement of certified logic and audit-grade operational trust.
Need to check novelty before this filing date? Find Prior Art

Description

METHOD AND SYSTEM FOR RUNTIME EXECUTION INTEGRITY VERIFICATION AND AUTONOMOUS POLICY-BASED CONTROL BASED ON THIRD-PARTY CERTIFICATION

[0001] The present invention relates to the field ofruntime software integrity assuranceandautonomous operational controlin digital information systems. More specifically, it discloses a system and method forreal-time verification of software execution, detection oflogic divergence, and autonomous response based onpre-certified reference data. This invention provides persistent, auditable trust throughout actual system operation, extending beyond initial deployment.

[0002] Conventional software certification frameworks―such asISO / IEC standards,Common Criteria (CC), andGS (Good Software Certification, a national software quality assurance program administered by the Korean government to evaluate software reliability and functional correctness)―typically focus onpre-deployment validationof static software artifacts. These models assume that once certified, the software will remain unchanged throughout its operational lifecycle. However, this assumption no longer holds true in today's digital environments, where software ismodular, continuously updated, and dynamically deployedvia CI / CD pipelines, over-the-air (OTA) mechanisms, or AI model retraining. Such dynamism introduces aruntime trust gap―a discrepancy between the certified state and the software's actual execution behavior―which cannot be addressed by static certification alone.

[0003] To close this gap, the present invention proposes aruntime verification and control architecturethat integrates:

[0004] (1)Third-party certified hash baselines,

[0005] (2)Real-time integrity monitoring agentsor embedded self-check logic,

[0006] (3)Policy-based response mechanismsthat can autonomously halt or isolate compromised components, and

[0007] (4)Immutable, audit-grade logging systems(e.g., blockchain or WORM) with trusted timestamping.

[0008] The system is designed for compatibility with diverse deployment models, includingSaaS, On-Premise, Edge, Hybrid Cloud, andair-gapped environments, and supports bothagent-basedandagentlessverification strategies. It is applicable across high-assurance domains such aselectronic voting, AI decision systems, financial platforms, critical infrastructure, and national defense software.

[0009]

[0010] Conventional software systems have long been developed and deployed asstatic, monolithic artifacts. Once certified, they are typically expected to operate unchanged―like sealed machines running in closed environments. Certification schemes such asCommon Criteria (CC),ISO / IEC 25023, and Korea'sGood Software (GS) Certification)were―and still are―built around this assumption. They assess the quality and reliability of source code, compiled binaries, and configuration files based on the belief that the certified system will remain intact throughout its operational life.

[0011] But the reality of software has evolved―and so has the nature of the systems we rely on.

[0012] Modern software is rarely static after deployment. Instead, it evolves―sometimes continuously. Applications are increasingly built as microservices, continuously delivered via CI / CD pipelines, and updated over-the-air (OTA).AI models retrain themselves, inference logic adjusts to data, and containerized components are orchestrated dynamically across distributed environments based on context, cost, or performance.

[0013] In this dynamic landscape,pre-deployment certification alone is no longer sufficient to guarantee trust. What was certified yesterday may no longer exist in the same form today. The longstanding assumption ofimmutabilityno longer applies. And yet, our certification frameworks continue to rely on that fading premise.

[0014] This creates astructural trust gapin how digital systems are governed:

[0015] We can prove what was certified.

[0016] But we cannot prove―at runtime―whether the system is still operating in that certified state.

[0017] This gap has direct implications for critical applications:

[0018] · Anelectronic voting systemmay be certified under controlled conditions, but an unmonitored configuration update during elections could alter its behavior without detection.

[0019] · AnAI-based decision-making systemmay have passed fairness validation at release, but retraining with biased or uncontrolled data could silently introduce decision errors.

[0020] · Amedical diagnostic platformmay run a certified inference model, but fallback logic could be triggered mid-execution without observable traceability.

[0021] · Anational lottery systemmay rely on certified RNG and payout logic, but if lookup tables or internal states shift during live draws―accidentally or otherwise―trust in fairness and compliance cannot be sustained.

[0022] In each case, the system'soperational behavior becomes decoupled from its certified reference state. And without runtime verification, the ability to ensureintegrity,accountability, orregulatory defensibilityevaporates.

[0023] To mitigate this, the industry has adoptedlogging, SIEM,immutable storage (WORM, blockchain), andobservability frameworks. However, these tools merely preserve records. They do not validate whether the logic that generated the data was itselfverified, unaltered, or trustworthy at the moment of execution.

[0024] In other words: Was the system doing what it was certified to do―when it mattered most?

[0025] International standards are increasingly acknowledging this need.

[0026] The 2023 revision ofISO / IEC 25010formally introduced"safety"as a software quality characteristic, emphasizing operational trust.

[0027] Following this, the ongoing revision ofISO / IEC 25023aims to definemeasurable runtime metricsfor this safety attribute―signaling a shift toward operational assurance.

[0028] This priority is echoed across other high-assurance standards:

[0029] ·ISO 26262mandates real-time monitoring of safety-critical automotive software during operation.

[0030] ·DO-178Cemphasizes the traceability and assurance of airborne software in live flight.

[0031] ·IEC 62443requires runtime integrity enforcement for industrial control systems.

[0032] ·ISO / IEC 30107mandates live presentation attack detection for biometric authentication.

[0033] These standards reflect a clear consensus:

[0034] In modern software systems, trust must not only be certified―it must becontinuously verifiable at runtime.

[0035] Yet despite this recognition,no general-purpose architecture currently existsthat can:

[0036] · Continuously validate whether executing logic remains consistent with its certified state,

[0037] · Autonomously respond to deviations through predefined policy controls, and

[0038] · Preserve immutable, auditable records for forensic or legal scrutiny.

[0039] This invention addresses that structural deficiency. It does not claim to block every form of error or intrusion. Rather, it offers a foundational framework to enforce and evidence a simple but critical guarantee:

[0040] This software, right now, is doing exactly what it was certified to do.

[0041] By providinglive integrity verification,policy-based response, andtamper-evident auditability, this invention redefines software certification as adynamic process―aligned with the distributed, evolving, and mission-critical nature of today's digital systems.

[0042]

[0043] Relationship to Prior Inventions

[0044] This invention represents a significant evolution in a series of earlier developments. It builds on the architectures described inKorean Patent Application No. 10-2025-0060075, which itself was based onApplication No. 10-2025-0048490. These prior inventions introduced a SaaS-based integrity verification framework usingthird-party certified reference data, primarily focused ononline gaming and lottery platforms.

[0045] While foundational, the earlier inventions were limited in scope:

[0046] · They lackedautonomous response mechanismsto runtime deviations,

[0047] · They did not supportagentless or embedded self-checking architectures, and

[0048] · Their applicability wasconstrained to specific industries.

[0049] In contrast, the present invention:

[0050] · Extends the verification model withpolicy-driven runtime control, including halt, isolate, or fallback modes,

[0051] · Supports bothagent-based and agentless verification, suitable for edge, embedded, and air-gapped deployments,

[0052] · Incorporatesblockchain and TSA-based loggingto ensure tamper-proof, timestamped records, and

[0053] · Isdomain-agnostic―designed for broad applicability across AI systems, government infrastructure, critical control software, financial platforms, defense systems, and regulated lotteries.

[0054] Together, these advancements transform the earlier SaaS framework into auniversal, real-time operational trust infrastructure―capable of safeguarding integrity not just at the moment of deployment, butthroughout the entire lifecycle of execution.

[0055]

[0056] Conventional software certification frameworks―such as ISO / IEC standards, Common Criteria (CC), and Korea's GS certification―are fundamentally designed around a static trust model. They assume that once software is certified, it will remain unchanged and trustworthy throughout its operational lifecycle. However, this assumption has become obsolete in modern digital ecosystems.

[0057] Today's software is dynamic. It is deployed through CI / CD pipelines, updated over-the-air, retrained using real-time data, and executed across distributed, containerized, or cloud-native environments. In such contexts, certified software can diverge from its validated state at any moment, creating aruntime trust gap―a state where certification no longer guarantees execution integrity.

[0058] Existing tools, such as logging systems and observability platforms, may preserve evidence of system behavior but cannot verify whether the executing logic itself remains consistent with what was certified. Nor can they trigger automated protective measures in response to logic tampering. This limitation is particularly critical in systems that make safety-critical, financial, legal, or administrative decisions.

[0059]

[0060] To resolve this foundational problem, the present invention introduces a real-time verification and control architecture that enforces execution integrity based on certified cryptographic references. The solution includes:

[0061] 1.Certified Hash Registry:

[0062] During the certification phase, cryptographic hash values are generated for all critical software logic blocks―such as executables, configuration files, inference models, and control scripts―and stored in a trusted registry alongside certification metadata.

[0063] 2.Runtime Monitoring and Hash Comparison:

[0064] The system continuously or periodically computes live hash values of executing components. These are compared against pre-certified references to verify integrity at the function, class, or module level. This can be achieved via monitoring agents or embedded agentless routines in environments where external monitoring is not feasible.

[0065] 3.Autonomous Policy-Based Control Layer:

[0066] When deviations from certified logic are detected, the system autonomously triggers predefined response actions, such as halting execution, isolating affected modules, switching to safe fallback logic, or issuing alerts. These policies are defined in structured formats like JSON or YAML and allow contextual control without altering the underlying software.

[0067] 4.Immutable Logging and Legal-Grade Traceability:

[0068] All verification results, state transitions, and response actions are immutably recorded in trusted infrastructure such as blockchain, WORM storage, or append-only secure databases. Each event is timestamped and cryptographically signed, supporting auditability and evidentiary use.

[0069] 5.Platform-Agnostic and Industry-Neutral Architecture:

[0070] The invention is not limited to any specific domain or environment. It is applicable to SaaS platforms, on-premise deployments, embedded systems, edge devices, and air-gapped infrastructures alike. It integrates with container orchestration systems, CI / CD pipelines, and third-party observability or governance tools.

[0071] 6.Alignment with International and Emerging Standards:

[0072] The architecture aligns with global standards such as ISO 26262 (automotive), DO-178C (aerospace), IEC 62443 (industrial control), ISO / IEC 30107 (biometric security), and ISO / IEC 25010 / 25023 (software quality and metrics). It is also compatible with regulatory trends such as theEU AI Act, which mandates real-time traceability and risk governance for high-impact software systems.

[0073]

[0074] The present invention delivers a unified framework that combines layered trust mechanisms to ensure persistent, autonomous, and verifiable operational integrity in digital systems. It addresses the structural shortcomings of traditional certification models by introducing real-time integrity verification, policy-driven control responses, and legally admissible evidence retention―all seamlessly integrated into live execution environments.

[0075] 1. Persistent and Fine-Grained Run-Time Trust Enforcement

[0076] The invention enables continuous, function-level hash validation of actively executing software logic against pre-certified reference values. This capability eliminates the long-standing gap between static certification at deployment and the dynamic behavior of software during operation. By extending verification into the run-time domain, the system ensures that logic modules―regardless of environment―remain cryptographically aligned with their certified configurations.

[0077] This is particularly vital in mission-critical systems such as AI-based diagnostics, autonomous navigation, or government infrastructure, where silent divergence from certified behavior can result in undetected malfunction or systemic risk.

[0078] 2. Autonomous Policy-Based Anomaly Response

[0079] The framework includes an embedded control layer that autonomously responds to deviations from certified execution profiles. Predefined policies allow for responses such as execution halt, logic isolation, fallback activation, or alert dispatch―without requiring real-time human intervention.

[0080] This self-defending design enhances system resilience and reduces mean-time-to-containment (MTTC), making it particularly effective for high-availability systems where downtime and breach propagation must be minimized.

[0081] 3. Immutable and Legally Admissible Logging

[0082] All integrity verification events, anomaly detections, and triggered responses are recorded in tamper-evident storage infrastructures such as blockchain, WORM (Write Once Read Many) devices, or TSA-integrated logs. These records include timestamps, module identifiers, hash results, deviation types, and response actions.

[0083] This ensures not only forensic-grade traceability but also legal admissibility in compliance, regulatory, and audit scenarios―empowering organizations to demonstrate that systems operated within certified, policy-compliant boundaries.

[0084] 4. Deployment Versatility Across Environments

[0085] The architecture is platform-agnostic and supports deployment across a wide spectrum of environments, including SaaS, On-Premise, Private Cloud, Hybrid Cloud, Edge Computing, and air-gapped installations. It further accommodates both agent-based and agentless implementations, allowing organizations to tailor the runtime integrity model to their technical constraints and security policies.

[0086] This flexibility ensures that the invention is adoptable not only in cloud-native infrastructures, but also in tightly regulated or classified settings such as military systems, nuclear control, or electoral servers.

[0087]

[0088] 5. Future-Ready Agent-Based Security Extensions

[0089] While the core architecture is designed for run-time integrity verification, the system's agent-based monitoring layer is inherently extensible. Depending on the deployment context and threat model, agents may be augmented with advanced detection capabilities―such as code injection monitoring, memory patch detection, system call tracing, or unauthorized hook analysis.

[0090] This future-oriented design enables the platform to evolve into a security enforcement layer that not only verifies execution integrity, but also detects real-time tampering attempts, laying the groundwork for integration with modern SIEMs and adaptive response systems.

[0091] 6. Alignment with International Standards and Evolving Safety Models

[0092] The invention is structurally aligned with several high-assurance international standards including ISO 26262 (functional safety in automotive), DO-178C (airborne software assurance), IEC 62443 (industrial cybersecurity), ISO / IEC 30107 (biometric trust), and ISO / IEC 25010 / 25023 (software quality and evaluation).

[0093] In particular, the 2023 revision of ISO / IEC 25010 added"Safety"as a distinct software quality characteristic, subdivided into run-time-relevant traits such asoperational constraints,fail-safe behavior, andhazard warnings. As ISO / IEC 25023 is being revised to define measurable indicators for these characteristics, this invention offers a direct architectural implementation for runtime observability, constraint enforcement, and safety-preserving fallback.

[0094] In this way, it not only aligns with but contributes to the practical realization of future software evaluation standards.

[0095]

[0096] 7. Broad Societal and Domain-Level Impact

[0097] Beyond technical advantages, the invention addresses growing societal demands for transparency, auditability, and accountability in software-driven decisions. It offers a universal trust framework applicable to domains where certified logic must remain demonstrably intact during execution―such as:

[0098] ·Electronic voting systems, where public confidence hinges on verifiable ballot processing logic,

[0099] ·AI-based judgment systems, where fairness and consistency must be provable even after model deployment,

[0100] ·Healthcare diagnostics, where runtime integrity of inference engines can impact life-critical decisions,

[0101] ·Lottery and gambling platforms, where regulatory fairness depends on untampered payout logic.

[0102] In each domain, the system enables a shift from trust by assumption to trust by cryptographic verification―delivered in real time, and enforceable by autonomous policy. Especially in AI decision systems, the invention offers forensic-grade assurance that automated outcomes are generated using pre-certified models, within validated runtime environments, and along auditable execution paths. This capability directly supports regulatory transparency and accountability mandates articulated in frameworks such as the EU AI Act, the OECD AI Principles, and emerging national standards for algorithmic governance.

[0103]

[0104] In summary, the invention unifies run-time integrity verification, autonomous anomaly response, immutable logging, and standards-aligned design into a cohesive framework for enforceable operational trust. It elevates digital trust from a static certification artifact to a continuously verifiable and enforceable property of live execution. By ensuring that certified logic remains intact and auditable throughout system operation, it supports regulatory compliance, mitigates systemic risk, and establishes a verifiable basis for software accountability in mission-critical domains.

[0105] Although applicable to sectors such as AI, finance, defense, and healthcare, the invention is not confined to any single domain. It functions as a universal trust infrastructure―capable of integrating into any software-driven system that demands persistent integrity, operational observability, and legally admissible traceability. In doing so, it defines a new category of self-defending digital systems―built not on assumptions, but on cryptographic proof, autonomous response, and transparent governance across environments and jurisdictions.

[0106]

[0107] The following drawings serve as an architectural and procedural companion to the written disclosure. Rather than presenting isolated snapshots, each figure builds upon the others to illustrate how the invention transforms software certification into a continuously enforced, operationally embedded trust mechanism. The diagrams are arranged to progressively reveal the invention's system structure, behavioral flow, deployment variations, and industrial applicability―thereby offering a comprehensive visualization of both its static and dynamic dimensions.

[0108] FIG. 1 presents the full-stack architectural layout, highlighting the interaction among certification bodies, monitoring agents, verification servers, and runtime control mechanisms. FIG. 2 illustrates the functional flow from pre-deployment certification to live execution monitoring and policy-based responses. FIG. 3 and FIG. 4 detail the agentless self-verification modes, showing how embedded logic enforces runtime integrity even in environments without external monitoring. Finally, FIG. 5 maps the invention's applicability across multiple domains, aligning system features with regulatory and operational requirements in safety- and trust-critical industries.

[0109] Together, the figures collectively demonstrate how the invention redefines software certification from a static precondition into a cryptographically verifiable, real-time operational process―one that is both technically enforceable and legally auditable.

[0110] FIG. 1 - System Architecture Overview

[0111] FIG. 1 illustrates the high-level system architecture of the invention, which comprises a layered trust framework designed to verify software execution integrity in real time. The architecture includes qualified third-party or internal certification bodies that perform pre-deployment validation of executable logic modules. Certified hash values for each logic block are registered in an immutable hash registry.

[0112] During operation, Integrity Monitoring Agents deployed on service operation servers monitor the behavior of executing software modules. These agents communicate with a Real-Time Integrity Verification Server, which compares runtime hash values against the certified references and identifies behavioral inconsistencies.

[0113] If anomalies are detected, a Runtime Control Agent within the system triggers predefined responses―such as halting the logic, switching to a safe mode, or notifying administrative interfaces. All verification and response data is recorded in immutable storage systems, such as blockchain or WORM devices. Oversight interfaces allow authorized users and regulators to review the verification status and operational logs.

[0114] The figure highlights how the invention maintains operational trust as an enforceable and continuously validated property throughout the system lifecycle.

[0115] FIG. 2 - Functional Flow Diagram

[0116] FIG. 2 depicts the end-to-end operational flow of the system, from pre-deployment certification to real-time runtime control and logging. The process begins with the certification of critical software logic modules by accredited authorities. Each function block is hashed and its metadata―such as version, timestamp, and certifier ID―is stored in the certified hash registry.

[0117] During live execution, the Integrity Monitoring Agent generates hash values not only for actively executing function blocks, but also for other critical runtime assets―such as binaries, configuration files, and scheduled control scripts―and compares them against the pre-registered certified references to verify end-to-end behavioral and environmental consistency. If execution remains consistent, the result is logged. If a deviation is detected, the system triggers predefined control actions (e.g., halt, isolate, enter fallback mode), as determined by organizational policy.

[0118] All outcomes are immutably logged, and optional dashboards or APIs can be used to externally report the status to regulatory interfaces. The flow diagram emphasizes both standard and exception handling paths, thereby showcasing the system's ability to autonomously enforce integrity while maintaining full traceability.

[0119] FIG. 3 - Agentless Self-Verification Mode (Pre-Execution)

[0120] FIG. 3 illustrates the agentless self-verification architecture embedded directly within the application binary. In this mode, an internal verification module runs before the application's main logic is invoked. The self-check module computes hashes for designated function blocks or memory regions and compares them to locally stored, pre-certified references.

[0121] If verification passes, execution proceeds normally. If a mismatch is detected, execution is halted and the result is recorded in an immutable local or remote log. This model is particularly useful in air-gapped environments, embedded systems, and highly restricted runtime settings where deploying external agents is not feasible.

[0122] The figure demonstrates how run-time integrity enforcement can still be achieved without relying on a separate monitoring layer―by embedding the logic directly into the application's startup routine.

[0123]

[0124] FIG. 4 - Agentless Self-Verification with Fallback and Re-Trigger Logic

[0125] FIG. 4 expands upon the agentless model introduced in FIG. 3 by incorporating fallback logic and re-trigger mechanisms. In this enhanced configuration, the application begins with a self-check routine embedded within the executable. If the integrity check passes, the system logs the verification result and initiates normal execution.

[0126] If the check fails, execution of the primary logic is blocked, and the system transitions to a predefined fallback path―such as a degraded-safe mode, read-only interface, or maintenance shell. This fallback module may also be configured to re-trigger the self-check at periodic intervals, enabling automated recovery attempts under controlled conditions.

[0127] This architecture is especially beneficial for use cases requiring autonomous safety behavior, such as autonomous vehicles, industrial control systems, or medical diagnostics, where failing safely is critical.

[0128] FIG. 5 - Domain Applicability Matrix

[0129] FIG. 5 presents a domain applicability matrix that maps the invention's relevance across multiple sectors, including defense, healthcare, AI governance, finance, e-Government, smart infrastructure, and regulated lottery operations. Each cell of the matrix aligns the system's core features―such as runtime verification, auditability, fallback control, and trust registration―with domain-specific requirements and representative standards (e.g., ISO 26262 for automotive safety, ISO / IEC 27001 for information security, or ISO / IEC 25010 for quality modeling).

[0130] The matrix highlights the system's versatility and universality. Whether in a safety-critical environment like aerospace software or in a trust-critical context like electronic voting or national lotteries, the invention provides a modular foundation for verifiable, accountable system behavior.

[0131]

[0132] Collectively, the five figures demonstrate how the invention implements a scalable and enforceable architecture for persistent software integrity assurance. FIGs. 1 and 2 establish the system's foundational trust model―grounded in third-party certification, hash-based validation, and autonomous control―while FIGs. 3 and 4 illustrate deployment options that preserve these trust guarantees even in constrained or agentless environments. FIG. 5 then contextualizes the architecture across real-world sectors, showing how the same trust infrastructure can be adopted, tailored, and audited across diverse domains with varying regulatory and operational demands.

[0133] By combining structural flexibility with runtime verifiability and domain neutrality, the invention achieves more than a functional improvement―it delivers a paradigm shift. Certification is no longer an upfront promise, but an operational reality. The drawings collectively reinforce this transformation by making the invention's logic, applicability, and enforceability not only describable―but also visible.

[0134]

[0135] The present invention is designed as a foundational digital infrastructure capable of applying real-time trust verification, execution integrity monitoring, and autonomous response control to virtually all software-powered environments. Its applicability spans a wide array of industries and use cases―from autonomous systems and AI platforms to digital governance and national infrastructure.

[0136] While the invention can be implemented in countless domains, this section outlines two major application categories that best highlight the system's core functionalities:

[0137] (1) Trust-Sensitive Systems, where it is critical to prove that certified logic remains unaltered during execution to maintain institutional, regulatory, or public trust; and

[0138] (2) Safety-Critical Systems, where deviation from certified behavior must trigger immediate response actions (e.g., system halt, fallback mode) to prevent harm or failure.

[0139] The examples provided below are intended as illustrative scenarios, not as limitations. In reality, any system that executes certified logic and demands integrity, transparency, and runtime accountability may be considered a best mode environment for this invention.

[0140] A. Trust-Sensitive Runtime Systems

[0141] These systems prioritize the verifiability of runtime behavior to uphold trust, legal accountability, and regulatory compliance. In scenarios where certified executables are built and verified within a strictly controlled environment that mirrors the production infrastructure, the invention allows hash references to be registered without requiring reproducible builds across arbitrary environments. This method ensures both trust and operational alignment by binding hash integrity to the exact binary deployed, under third-party certification supervision.

[0142] Example 1: Electronic Voting System

[0143] A vote-counting system includes pre-certified logic modules for ballot scanning and tallying. During live elections, the invention continuously verifies the executing code against registered hash values. If a deviation from the certified voting logic is identified (e.g., unexpected execution behavior or unauthorized logic flow), the vote process is halted, an alert is issued to the election commission, backup modules are activated, and an immutable log is generated for regulatory review.

[0144] This maintains electoral integrity and preserves public trust.

[0145] Example 2: National Lottery System

[0146] A lottery draw platform operates with RNG and payout logic pre-certified by regulators such as GLI or TTA. Each draw invokes a runtime verification of the critical logic components. Upon detecting a mismatch, the system cancels the draw, blocks payout distribution, and logs the incident immutably. A regulatory report is automatically generated, ensuring compliance and fraud prevention.

[0147] B. Safety-Critical Runtime Control Systems

[0148] In these domains, operational software controls physical systems, and deviations from expected behavior may result in safety failures. The invention serves as a runtime watchdog, capable of immediate, autonomous intervention. It enables a cryptographically verifiable layer of execution oversight that reacts in real time, ensuring system behavior aligns with certified safety models.

[0149] Example 3: Autonomous Vehicle System

[0150] Control modules responsible for lane detection, braking, and obstacle avoidance are certified per ISO 26262. During operation, real-time agents validate their integrity by comparing runtime hashes with certified references. If anomalies are detected―such as unauthorized code updates or unexpected logic paths―the system enters limp or emergency mode, records all relevant telemetry and hash comparisons, and alerts the fleet control center.

[0151] This prevents propagation of compromised logic and mitigates risk in real-world driving scenarios.

[0152] Example 4: Medical AI Diagnostic System

[0153] An AI-based diagnostic engine for radiological or clinical decision support operates using a pre-certified model and a validated reasoning framework. Before each inference session, the invention executes a runtime logic integrity check to ensure that model weights, preprocessing routines, and decision paths remain identical to their certified state.

[0154] If discrepancies are detected―such as tampered weights, unauthorized submodule activation, or missing pre-inference logic―the system halts execution, switches to a certified fallback inference engine, and immutably logs the incident with all relevant metadata. These logs are cryptographically signed and made available for external audit or regulatory review.

[0155] This implementation ensures clinical safety, diagnostic accountability, and operational transparency in compliance with international standards such asIEC 62304(software lifecycle for medical devices) andISO 14971(risk management), as well asTitle III of the EU AI Act, which mandates continuous risk monitoring, robust documentation, and auditability forhigh-risk AI systemsdeployed in healthcare environments.

[0156] The invention's ability to enforce certified logic paths and generate tamper-proof decision records enables organizations to meet the EU's requirements forexplainability, traceability, and post-deployment oversightin real-time clinical settings.

[0157]

[0158]

[0159] C. Extended Applicability Statement

[0160] Although the four examples above illustrate the invention's core use cases, they are not exhaustive. The system is universally applicable to:

[0161] · Smart city platforms,

[0162] · Financial algorithms and credit scoring systems,

[0163] · Industrial automation and PLC environments,

[0164] · AI governance and policy enforcement engines,

[0165] · Government administrative systems handling legal documents or national registries.

[0166] In short, every certified, software-dependent digital system―regardless of its domain―is a potential best mode implementation of this invention. It is not limited to any particular use case, but rather serves as a general-purpose trust infrastructure for the entire software-defined world.

[0167] Conclusion

[0168] The present invention is intended not only to enhance technical assurance, but also to address a deeper structural need in modern society: the ability to trust the logic that governs critical digital systems―not just before deployment, but continuously during operation.

[0169] By delivering persistent runtime verification, autonomous safety responses, and immutable auditability, this invention enables a new generation of self-verifying, self-defending software systems. It provides the technical foundation necessary to meet evolving standards of compliance, public trust, and cross-border digital accountability.

[0170]

[0171] The present invention may be implemented in a wide variety of system architectures, software environments, and deployment configurations. This section describes preferred implementation modes, while recognizing that the underlying concepts of the invention are technology-agnostic and not limited to specific protocols, platforms, or programming paradigms. The functional elements described herein may be realized using any existing or future technologies that perform the equivalent roles defined by the invention.

[0172] 1. System Overview

[0173] The invention comprises the following core components:

[0174] ·Certified Hash Registry: A repository that stores cryptographic reference hashes of certified logic blocks, accompanied by metadata such as module identifiers, version numbers, timestamps, and certifier signatures.

[0175] ·Runtime Monitoring Engine: Responsible for collecting operational behavior and generating live hash values during system execution.

[0176] ·Verification Engine: Compares generated hashes with certified references to detect deviations from certified behavior.

[0177] ·Policy-Based Response Engine: Executes predefined system control actions (e.g., isolate, halt, notify) based on anomaly detection results and configurable organizational rules.

[0178] ·Immutable Logging Infrastructure: Securely stores all verification results and control actions with trusted timestamps to ensure legal admissibility.

[0179] ·External Access Interface: Provides authenticated access to verification logs and system integrity status for regulators, administrators, or connected systems.

[0180] 2. Certification and Hashing

[0181] During the certification phase, cryptographic reference hashes are generated for critical logic blocks―such as application code, AI inference models, control scripts, and configuration assets.

[0182] Hashing may occur at various levels of granularity, including class, function, method, or compiled module.

[0183] In deployment scenarios where the certified logic is built and deployed under direct supervision of an accredited third-party or compliant internal certifier,reproducibility across environments is not required. Instead, the certifier signs both the compiled executable and its associated hash values, and these are registered together with the deployment metadata. This ensures that the deployed binary and reference hashes are operationally identical, eliminating the need for deterministic rebuilding while maintaining traceability.

[0184] Alternatively, when operational separation requires independent verification across environments, adeterministic or pseudo-deterministic build pipelinemay be enforced. In this model, each logic block, when compiled under fixed source, configuration, and environment conditions, produces a binary that is cryptographically identical to its certified version. This is achieved by:

[0185] · Fixing compiler versions (e.g., GCC 12.1.0, LLVM 14)

[0186] · Locking third-party dependencies to known versions

[0187] · Normalizing timestamps via SOURCE_DATE_EPOCH or custom flags

[0188] · Standardizing build scripts and execution parameters

[0189] · Optionally integrating reproducibility validation tools within CI / CD pipelines

[0190] In both models, the resulting hash values are registered within the certified hash registry and serve as the operational basis for runtime verification.

[0191] 3. Runtime Monitoring and Verification

[0192] The system supports both agent-based and agentless runtime verification architectures. In agent-based configurations, a dedicated Integrity Monitoring Agent runs as a background process, daemon, or containerized sidecar that periodically or continuously computes hash values of critical runtime components―including function blocks, executables, configuration files, and scripts. These hash values are securely transmitted to a verification engine, which compares them against the certified references.

[0193] In agentless environments―such as embedded systems, air-gapped infrastructures, or resource-constrained deployments―a self-verification module is embedded directly into the application binary. This module initiates a hash validation routine either before the main logic is invoked (e.g., pre-main() execution) or at scheduled intervals during operation.

[0194] Both verification modes support cryptographic signing of results and include mechanisms to detect tampering, unauthorized updates, or unintended behavioral drift.

[0195] Communication between agents and verification servers may use authenticated and encrypted protocols such as REST, gRPC, or message-based frameworks (e.g., ZeroMQ, MQTT). Optional behavior modeling components may analyze hash histories to detect anomalous execution patterns in advance.

[0196]

[0197] 4. Autonomous Control Response

[0198] Upon detecting a deviation from certified execution behavior, the system triggers a response via the policy-based control engine. Policies are expressed in declarative formats such as JSON or YAML and may include conditional logic to determine response type, severity, and scope.

[0199] Supported responses include:

[0200] · Halting or pausing execution

[0201] · Isolating or unloading compromised modules

[0202] · Switching to a pre-validated fallback routine

[0203] · Restricting API endpoints or system calls

[0204] · Notifying internal or external oversight systems

[0205] These actions may be triggered synchronously or asynchronously depending on the criticality of the violation and the system's trust level. All decisions are logged with policy identifiers and evaluation contexts for forensic auditing.

[0206]

[0207] 5. Immutable Logging and Auditability

[0208] All verification outcomes, system state transitions, and control actions are immutably recorded in secure storage media. The system supports integration with:

[0209] · Blockchain-based ledgers (e.g., Hyperledger Fabric, private Ethereum networks)

[0210] · WORM (Write Once, Read Many) storage appliances

[0211] · Secure append-only databases with audit chain validation

[0212] To ensure legal-grade auditability, all logs include:

[0213] · Cryptographic hashes of the recorded data

[0214] · Trusted timestamps from Time Stamping Authorities (TSA) or equivalent

[0215] · Module identifiers, session metadata, and response tracebacks

[0216] These logs are accessible to authorized entities through secured interfaces, allowing for compliance audits, regulatory oversight, and legal chain-of-custody validation.

[0217] 6. Deployment Environments

[0218] The invention is designed to be environment-agnostic and supports deployment across a wide range of system architectures, including:

[0219] ·SaaS platforms, where centralized trust enforcement is implemented for multiple tenants

[0220] ·On-premise systems, managed entirely within the organization's infrastructure

[0221] ·Private or hybrid cloud environments, where trust boundaries span across internal and external systems

[0222] ·Edge computing platforms, including industrial IoT gateways and autonomous robotics

[0223] ·Air-gapped environments, where certified reference hashes and policies are preloaded and offline log retention is enforced

[0224] The system can be implemented in any modern programming language that supports secure hashing and inter-process communication, such as C, C++, Rust, Go, or Java. Operating system compatibility includes Linux, Windows, embedded RTOS, and containerized platforms like Docker or Kubernetes.

[0225]

[0226] 7. System Interoperability and Interfaces

[0227] The system exposes secure, authenticated interfaces for external systems to access runtime verification results, control status, and audit logs. These include:

[0228] · RESTful APIs with token-based authentication

[0229] · gRPC endpoints for high-performance data exchange

[0230] · Webhooks or message queues (e.g., Kafka, RabbitMQ) for alert propagation

[0231] · Plug-ins or forwarders to enterprise tools such as SIEM (e.g., Splunk, ArcSight), GRC platforms, or observability stacks

[0232] The architecture supports asynchronous event delivery, role-based access control, and encrypted channels to ensure secure interoperability within multi-stakeholder environments.

[0233]

[0234] 8. Future-Proofing and Cryptographic Flexibility

[0235] While current implementations may use SHA-2 (e.g., SHA-256) for hash generation, the system is designed to remain adaptable as cryptographic standards evolve. Alternative or enhanced mechanisms may include:

[0236] · Post-quantum hash algorithms, such as SPHINCS+ or XMSS

[0237] · Merkle tree-based hash validation for hierarchical logic traceability

[0238] · Zero-knowledge proofs (ZKP) for non-disclosive state validation

[0239] · Decentralized timestamping networks for transparent, vendor-neutral evidence generation

[0240] The architecture also supports pluggable hash engines and modular verification pipelines, allowing future substitution of cryptographic primitives without disrupting the core system workflow.

[0241]

[0242] The present invention is applicable to a wide variety of industries and domains where operational integrity, transparency, autonomous safety responses, and legal-grade auditability are critical. These domains include both safety-critical and trust-critical systems across public and private sectors.

[0243] Unlike conventional integrity tools that are limited to pre-deployment phases, this invention provides continuous, real-time runtime assurance during active system operation. It can detect unauthorized changes, initiate autonomous countermeasures, and preserve immutable audit records―making it an essential trust layer in the digital ecosystem.

[0244] To better understand its industrial utility, the invention's applicability may be grouped into two major functional categories:

[0245] ·Trust-Sensitive Systems

[0246] Systems where public, institutional, or regulatory trust must be continuously upheld, and where any tampering with execution logic could undermine fairness, legality, or compliance.

[0247] ·Safety-Critical Systems

[0248] Systems where the consequences of undetected execution divergence include physical harm, equipment damage, or operational failure.

[0249]

[0250] A. Trust-Sensitive Systems

[0251] These systems require a high degree of transparency, auditability, and verifiable integrity to maintain trust among regulators, auditors, users, or the public.

[0252] They often involve logic that directly impacts rights, fairness, money flow, or institutional authority. In such environments, the ability to prove that the logic is operating exactly as certified is paramount.

[0253] Representative Application Areas

[0254] 1.Electronic Voting Systems

[0255] Ensures that certified ballot processing, vote counting, and result reporting logic remain consistent and verifiable during elections. Maintains execution integrity and enables a verifiable chain-of-custody aligned with electoral laws and audit requirements.

[0256] 2.Online Lottery and Gambling Platforms

[0257] Verifies runtime integrity of RNG engines, payout logic, and game execution modules. Ensures fairness and compliance with gambling regulations. Automatically suspends draws or payouts upon detecting unauthorized logic changes.

[0258] 3.Financial Platforms (Credit, Trading, Lending)

[0259] Continuously monitors decision-making logic for credit scoring, loan approvals, and trading algorithms. Prevents manipulation or bias injection that could lead to fraud, legal exposure, or regulatory violations. Ensures that certified logic used in risk scoring, interest rate calculation, or real-time pricing is not silently altered during operation.

[0260] 4.Public Administration and e-Government

[0261] Ensures operational integrity of certified logic used in taxation, ID issuance, and citizen services. Maintains consistent execution during operation and mitigates risks of unintended logic alteration or policy deviation, ensuring accountability in critical administrative systems. Supports compliance with laws requiring transparency in administrative processing.

[0262] 5.Digital Identity and Authentication Systems

[0263] Maintains certified integrity of biometric matching, token issuance, and login mechanisms. Real-time verification prevents compromised access logic, which could otherwise cascade into broader trust failures. Aligns with frameworks such as ISO / IEC 30107 (biometric security) and government-led digital identity trust standards.

[0264] 6.AI Ethics and Decision Systems

[0265] Monitors inference logic in AI systems used for high-impact decisions (e.g., hiring, social welfare, sentencing). Prevents unapproved retraining or model substitution, thereby upholding fairness and transparency. Enables real-time attestation of decision logic for post-hoc auditability and explainability, aligned with frameworks like the EU AI Act.

[0266] 7.Blockchain-Based Legal Evidence or Contract Platforms

[0267] Verifies upstream logic feeding smart contracts or public ledgers. Prevents forged data from being permanently recorded. Supports legal validity and long-term auditability in digitally notarized records.

[0268] 8.Regulated Document or Data Management Systems

[0269] Secures the logic that governs data redaction, versioning, and access in systems managing sensitive records (e.g., legal archives, medical records). Enables immutable, compliant traceability. Facilitates accountability in record-keeping and prevents silent tampering in high-sensitivity repositories.

[0270] B. Safety-Critical Systems

[0271] These are domains in which operational software controls physical systems, and where execution errors or tampering may result in personal injury, asset damage, or systemic failure.

[0272] In such environments, real-time integrity verification and autonomous control responses are essential to meet safety certifications, operational continuity, and legal obligations.

[0273] 1. Autonomous Vehicles (Cars, Drones)

[0274] Continuously verifies the integrity of navigation, obstacle avoidance, and braking logic during operation. Upon detecting inconsistencies from the certified logic, the system transitions to a safe mode or halts execution to maintain operational safety. Aligns with ISO 26262 for automotive functional safety.

[0275] 2. Medical AI Diagnostics and Devices

[0276] Verifies diagnostic model integrity during live inference. Automatically blocks or disables unsafe outputs if inference logic or decision paths deviate from certified states, preventing clinical errors. Ensures traceability and accountability in compliance with ISO 14971 and IEC 62304.

[0277] 3. Industrial Control Systems (SCADA, PLCs)

[0278] Protects control firmware and automation logic in power plants, factories, and utilities. Detects unauthorized ladder logic or remote override attempts, ensuring physical safety and production continuity. Reinforces defense-in-depth strategies aligned with IEC 62443 for industrial cybersecurity.

[0279] 4. Defense Command and Control Software

[0280] Ensures that targeting, sensor fusion, or battlefield communication systems operate only with certified logic. Upon anomaly detection, system isolation or shutdown can be triggered to prevent operational compromise. Supports national security protocols requiring logic-level validation.

[0281] 5. Smart Grid and Power Infrastructure

[0282] Maintains execution integrity of substation automation, load-balancing, and grid reconfiguration logic during runtime. Ensures consistent and verifiable logic behavior to support operational continuity and grid stability.

[0283] 6. Aerospace Flight Software (DO-178C Compliant)

[0284] Verifies avionics software (e.g., autopilot, telemetry) in real time. Ensures flight-critical modules remain consistent with certified logic during operation, supporting both safety and regulatory auditability. Meets DO-178C requirements for software assurance in airborne systems.

[0285] 7. Train and Railway Signaling Systems

[0286] Monitors logic controlling interlocks, signal propagation, and automated scheduling. Detects logic corruption that may lead to collisions or derailments, and initiates isolation of compromised systems. Supports safe operations within critical transport infrastructure.

[0287] 8. Critical Infrastructure Access Control

[0288] Verifies control logic for badge-based access, remote locking, and surveillance triggers in secure facilities. Ensures that physical security systems remain governed by authorized logic only. Prevents unauthorized logic modification that may bypass safety or surveillance protocols.

[0289]

[0290] Conclusion

[0291] Each of the examples above illustrates how the invention ensures real-time operational integrity, whether by verifying that certified logic remains intact, or by preventing failure through immediate intervention when anomalies are detected.

[0292] Although categorized here for clarity, the invention is not limited to these fields. Rather, it serves as a universal infrastructure applicable to any digital system that relies on verifiable runtime software behavior.

[0293] This invention can be deployed wherever real-time software integrity, autonomous policy-based response mechanisms, and legally traceable auditability are needed. It is designed to function as a foundational trust layer in the digital era―supporting regulatory assurance, operational transparency, and public accountability.

Claims

1.A method for ensuring runtime integrity through cryptographic verification of executing function blocks in digital information systems, comprising the steps of:(a) pre-certifying execution modules at the function, binary, or model level through independent third-party authorities or qualified internal certification bodies that are organizationally and operationally separate from development and runtime environments;(b) generating cryptographic hash values for each certified execution unit and storing them with associated metadata including, but not limited to, version identifiers, timestamps, and certification signatures;(c) during system operation, generating live hash values for actively executing runtime assets―including function blocks, binaries, configuration files, and scheduled logic―and comparing them with the pre-certified references to detect deviations;(d) upon detecting such deviations, autonomously executing one or more predefined system control responses based on policy rules, including halting execution, isolating affected modules, switching to fallback logic, or notifying supervisory systems; and(e) recording all verification results, system states, response actions, and associated metadata in immutable storage, such as blockchain or WORM (Write Once Read Many) devices, with verifiable timestamping.2.The method of Claim 1, wherein the types of execution modules include at least one of the following, including but not limited to:(i) compiled application binaries,(ii) AI inference models,(iii) interpreted scripts,(iv) container-level system images,(v) configuration files, and(vi) control or orchestration logic.3.The method of Claim 1, wherein the certification authorities include domestic or international third-party organizations such as GLI, BMM, TTA, TuV Rheinland, or other equivalent audit-capable entities; and may further include internal verification or certification units, provided they operate under conditions consistent with ISO / IEC 17020 or ISO / IEC 17025, including full organizational separation, independent reporting structures, and documented audit procedures.4.The method of Claim 1, wherein the real-time monitoring and integrity verification is implemented using one or both of:(a) a runtime agent that continuously or periodically monitors executing software modules, performs hash comparisons, and autonomously triggers policy-based control actions when deviations from certified execution behavior are identified; and(b) an embedded self-check module within the executable logic that performs a pre-execution hash integrity verification, and optionally re-invokes itself at scheduled intervals or upon system events, with the ability to block execution, switch control flow, or record immutable logs in response to verification failure.5.The method of Claim 1, wherein the execution modules comprise AI inference systems, and the cryptographic hash values are generated and verified for one or more AI artifacts,including but not limited to:(a) trained model weights,(b) model architecture specifications, and(c) data preprocessing scripts,to ensure that the deployed inference logic remains identical to its certified state during system operation.6.The method of Claim 1, wherein each integrity event log includes at least the following elements:(a) unique module identification;(b) hash comparison results;(c) anomaly classification;(d) runtime session identifiers;(e) timestamps; and(f) triggered response actions.7.The method of Claim 1, wherein all log data is cryptographically signed and stored in decentralized or tamper-proof infrastructure, including but not limited to:(a) blockchain-based ledgers,(b) WORM storage devices, or(c) append-only secure databases,and includes trusted timestamps issued by a Time Stamping Authority (TSA) or its functional equivalent.8.The method of Claim 1, wherein certified hash values are generated using one of the following methods:(a) supervised deployment, in which the software is built and deployed under third-party or independent internal oversight in a controlled environment, and the hash values are certified in conjunction with the deployed binaries; or(b) deterministic or pseudo-deterministic builds, in which the build process produces reproducible binaries using fixed compiler versions, locked dependencies, normalized timestamps, and standardized execution parameters.9.The method of Claim 1, wherein the policy-based response engine determines the appropriate system control action by evaluating a rule set defined in structured configuration formats such as JSON or YAML, allowing dynamic customization of response strategies based on severity, module type, or context.10.The method of Claim 1, wherein the predefined system control responses include at least one of the following predefined control responses, including but not limited to:(a) halting or suspending system execution;(b) isolating or unloading affected software modules;(c) switching to fallback or degraded-safe operational modes;(d) disabling or restricting application interfaces or external data feeds;(e) generating real-time alerts; or(f) notifying designated regulators, administrators, or automated response platforms.11.The method of Claim 1, wherein the system includes a secure external interface that provides authenticated access to runtime verification results, audit logs, and system state transitions through one or more communication mechanisms, including but not limited to:(a) RESTful APIs with access control;(b) gRPC endpoints;(c) message queues or event streams; or(d) integration modules for SIEM, GRC, or observability platforms.12.The method of Claim 1, wherein all recorded events are timestamped using a trusted external Time Stamping Authority (TSA) or equivalent decentralized timeproofing mechanism, supporting verifiable chronological integrity and legal chain-of-custody requirements.13.The method of Claim 1, wherein the system architecture supports multi-tenant SaaS deployments, ensuring tenant data isolation, centralized trust enforcement, and dynamic scaling of verification services without compromising integrity.14.The method of Claim 1, wherein the system is platform-agnostic and may be deployed in SaaS, On-Premise, Private Cloud, Hybrid Cloud, Edge Computing, or air-gapped environments, without loss of functionality or trust assurance.15.The method of Claim 1, further comprising the integration of predictive anomaly detection models trained on historical integrity verification logs, system behavior, and anomaly response data, wherein the model outputs deviation probability indicators used to preemptively isolate or revalidate high-risk modules.16.The method of Claim 1, wherein all configuration or policy changes related to verification logic or response rules are themselves logged immutably with:(a) timestamp of the change;(b) identity of the change initiator;(c) justification metadata; and(d) affected scope or module set.17.The method of Claim 1, wherein the system supports fine-grained hash validation at the level of class, function, or method blocks, enabling pinpoint detection of unauthorized changes within modular certified execution logic.18.The method of Claim 1, wherein the system supports interoperability with third-party monitoring systems by exporting logs and integrity signals through standardized connectors compatible with external Security Information and Event Management (SIEM) platforms, Governance-Risk-Compliance (GRC) tools, or autonomous control agents.19.The method of claim 3, wherein the internal certification units satisfy structural independence and auditability requirements by:(a) maintaining full organizational separation from development and operational teams;(b) implementing independent reporting and quality management procedures;(c) preventing runtime data exchange with production systems;(d) signing verification results with cryptographic keys under internal custody;(e) producing documentation admissible as legal evidence of certification.