One-Time-Programmable Version Counter to Block Software Rollback

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing computer systems lack a mechanism to ensure that software versions can only be updated in one direction, preventing rollback to insecure or obsolete versions, which is crucial for maintaining security and functionality.

Innovation Solution

Implementing unidirectional counters using one-time-programmable memory, such as flash or EEPROM, to store a minimum software version that can only be incremented, ensuring that only newer, secure versions can be installed.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If traditional memory devices are used to store software version information, then the system allows flexible updates and rollbacks, but security and reliability are compromised due to ability to revert to insecure versions

Engineering Contradiction:
Improvesoftware version securityVSAvoidsoftware update flexibility
Core Design Contradiction:
ReliabilityVSAdaptability or versatility

Solution Approach 1:

The memory device is segmented into multiple bits, where each bit represents a specific software version threshold. This segmentation allows the system to store version information in a way that enables unidirectional updates while maintaining security, as each bit can be independently set but not reset, preventing rollback to insecure versions.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent changes the state parameter of memory bits from reversible (0-1 transitions) to irreversible (one-time programming). By using one-time-programmable memory, the software version counter can only increase, never decrease, ensuring that once a security threshold is crossed, the system cannot revert to a previous, potentially insecure state.

Inventive Principle:
Principle #35Parameter changes

2Reliability

If unidirectional memory structures are implemented, then security is improved by preventing version rollback, but device complexity increases due to specialized memory requirements

Engineering Contradiction:
Improveversion control securityVSAvoidmemory structure complexity
Core Design Contradiction:
ReliabilityVSDevice complexity

Solution Approach 1:

The one-time-programmable memory automatically enforces unidirectional version control without requiring additional complex control logic or external monitoring systems. The memory hardware itself provides the security function by physically preventing write operations that would decrease the version counter, eliminating the need for software-based protection mechanisms.

Inventive Principle:
Principle #25Self-service

3Adaptability or versatility

If software versions can be freely updated in both directions, then adaptability is maintained, but harmful factors increase due to potential installation of insecure versions

Engineering Contradiction:
Improvesoftware update capabilityVSAvoidinsecure version installation
Core Design Contradiction:
Adaptability or versatilityVSObject-affected harmful factors

Solution Approach 1:

The one-time-programmable memory pre-establishes version thresholds before any updates occur. Once a threshold is reached, the memory physically prevents any attempt to write a lower version number, proactively blocking harmful actions before they can occur rather than reacting to attempted rollbacks.

Inventive Principle:
Principle #9Preliminary anti-action

Data Source

PatentUS20260073053A1Unidirectional counter
Publication Date: 2026.03.12 MELLANOX TECHNOLOGIES LTD(IL)
  • US20260073053A1 patent drawing
  • US20260073053A1 patent drawing
  • US20260073053A1 patent drawing

AI summary

Apparatuses, systems, and techniques that implement a unidirectional counter with one-time-programmable memory that prevents the counter from reversing direction. In at least one embodiment, a unidirectional counter is implemented with a base value represented as a binary number and an offset represented as a bit field where each bit represents an equal amount.