Software Component Memory Randomization for Virus Protection

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Software applications and system software without virtual memory are vulnerable to a class of computer viruses that replicate by exploiting known relative memory locations, posing a significant threat to personal computers, PDAs, mobile phones, and internet switches and routers.

Innovation Solution

The method involves dividing software applications into components and creating distinct copies by varying their memory locations, using pseudo-random processes to ensure different loading positions for each copy, thereby making it extremely difficult for viruses to replicate and propagate.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Speed

If software applications are run without virtual memory to maintain system simplicity and performance, then system complexity is reduced and execution speed is improved, but the software becomes vulnerable to virus attacks that exploit known memory locations

Engineering Contradiction:
Improvesoftware execution speedVSAvoidvirus attack vulnerability
Core Design Contradiction:
SpeedVSObject-affected harmful factors

Solution Approach 1:

The software application is divided into multiple loadable modules that can be loaded into different memory locations. Instead of loading the entire application at a fixed location, the system segments the application into modules that are dynamically positioned, preventing viruses from exploiting predictable memory addresses while maintaining execution efficiency.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent implements dynamic memory allocation where software modules are loaded at varying memory locations across different execution instances. This dynamic positioning ensures that even if a virus identifies a memory location in one instance, it cannot reliably attack the same location in subsequent instances, thus protecting against location-based virus attacks while maintaining system simplicity.

Inventive Principle:
Principle #15Dynamics

2Reliability

If distinct copies of software are created with varying component locations to prevent virus propagation, then virus resistance is improved, but the complexity of software deployment and management increases

Engineering Contradiction:
Improvevirus resistanceVSAvoidsoftware deployment complexity
Core Design Contradiction:
ReliabilityVSDevice complexity

Solution Approach 1:

The patent creates a universal software distribution package that contains all necessary modules with embedded metadata describing their possible locations and dependencies. This single universal package can generate multiple distinct executable copies with different memory layouts, providing virus resistance without requiring manual creation and management of separate software versions.

Inventive Principle:
Principle #6Universality (Multi-functionality)

Solution Approach 2:

Instead of manually creating and managing distinct software copies, the system uses automated copying mechanisms where a single source package is replicated into multiple executable instances with automatically assigned different memory locations. This automation reduces deployment complexity while maintaining the security benefits of location variation.

Inventive Principle:
Principle #26Copying

Data Source

PatentUS8689193B2Method and apparatus for protecting a software application against a virus
Publication Date: 2014.04.01 AT&T CORP
  • US8689193B2 patent drawing
  • US8689193B2 patent drawing
  • US8689193B2 patent drawing

AI summary

A method and apparatus for protecting computer systems from a virus are disclosed. For example, the present method protects against a class of computer viruses that replicate themselves by making use of the knowledge that a specific piece of software code or data component that always resides at a specific relative memory location in RAM for all instances of the software. In one embodiment, the present method divides a software application into a plurality of components and creates distinct copies of the software application by varying the locations of the components when loaded onto a computer system.