AI-Generated Redundant Code for Attack-Resistant Fault Switching

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Existing software redundancy methods, as codified in automotive safety integrity level (ASIL) guidelines, are insufficient to protect against malicious attacks or faults, as they rely on identical copies of software that can share vulnerabilities, making systems susceptible to exploitation.

Innovation Solution

Generate redundant code using artificial intelligence to create two different software versions with the same functionality, enabling a controller to execute one version if the other is compromised by a fault or attack, thereby ensuring robustness against vulnerabilities.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If identical copies of software are provided for redundancy, then system robustness against safety events is improved, but vulnerability to malicious attacks increases because identical code shares the same security weaknesses

Engineering Contradiction:

Improvesystem robustnessVSAvoidvulnerability to malicious attacks

Core Design Contradiction:

ReliabilityVSObject-affected harmful factors

Solution Approach 1:

The patent applies asymmetry by generating two different software implementations (first and second software programs) that perform the same function but have different code structures. This asymmetric approach ensures that if one implementation is vulnerable to a malicious attack, the other may resist the same attack, thereby maintaining system robustness while reducing shared vulnerability.

Inventive Principle:

Principle #4Asymmetry

Solution Approach 2:

The patent changes the parameter of code similarity by using an artificial intelligence engine to generate software with varying degrees of code differentiation. The system can adjust parameters such as code complexity, structure, and similarity thresholds to balance between maintaining functional equivalence and reducing vulnerability correlation between redundant software copies.

Inventive Principle:

Principle #35Parameter changes

2Object-affected harmful factors

If different software versions are generated using AI, then vulnerability sharing is reduced, but system complexity and development cost increase

Engineering Contradiction:

Improvevulnerability sharingVSAvoidsystem complexity

Core Design Contradiction:

Object-affected harmful factorsVSDevice complexity

Solution Approach 1:

The patent uses copying by generating a second software program that replicates the functionality of the first software program but with differentiated code. The artificial intelligence engine creates this copy with modified code structures, achieving vulnerability diversification while maintaining functional equivalence, thus reducing the impact of malicious attacks without requiring complete redesign.

Inventive Principle:

Principle #26Copying

Solution Approach 2:

The patent substitutes manual software development and verification processes with an artificial intelligence engine that automatically generates and validates multiple software versions. This substitution reduces the complexity burden by automating the generation, testing, and validation of differentiated software implementations, making the process scalable and manageable.

Inventive Principle:

Principle #28Mechanics substitution (Replace mechanical system)

3Reliability

If multiple software versions are stored and executed, then fault tolerance is improved, but memory requirements and execution overhead increase

Engineering Contradiction:

Improvefault toleranceVSAvoidmemory requirements

Core Design Contradiction:

ReliabilityVSQuantity of substance

Solution Approach 1:

The patent applies dynamics by implementing a runtime system that can dynamically select and switch between different software versions based on detected faults or security threats. The controller monitors software execution and can switch from the first software program to the second software program or vice versa, providing adaptive fault tolerance without requiring all versions to execute simultaneously, thus optimizing memory usage.

Inventive Principle:

Principle #15Dynamics

Solution Approach 2:

The patent segments the software system into multiple independent executable versions (first and second software programs) that can be stored separately in memory. This segmentation allows the system to load only the necessary software version into active memory at any given time, reducing overall memory requirements while maintaining the capability to switch between versions for fault tolerance.

Inventive Principle:

Principle #1Segmentation

Data Source

PatentUS20250335163A1Systems and methods for generating redundant code to enable robust software applications

Publication Date: 2025.10.30 ROBERT BOSCH GMBH

AI summary

A method for generating redundant code includes receiving a first software program and providing, to an artificial intelligence engine, the first software program configured to perform a function. The method also receiving, from the artificial intelligence engine, a second software program configured to perform the function. The method also includes, in response to verifying the function of the second software program executing at least one of the code of the first software program and the code associated with the second software program to cause the function to be performed. The method also includes, in response to detecting a fault, disabling execution of one of the first software program and the second software program, and executing the other of the first software program and the second software program to cause the function to be performed.