Client-Event Signed Transactions Using Behavioral Hashes
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Client-generated transactions are susceptible to man-in-the-middle and parameter tampering attacks due to their human-readable formats and lack of encryption, making them vulnerable to unauthorized modifications during transmission.
Innovation Solution
Implementing a cyber-security process that generates behavior-generated, event-type signed transactions by mapping client-specific events to unique codes and using user interface interactions to create authentication hashes, ensuring transaction immutability through hash comparisons.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If transactions are transmitted in human-readable formats (JSON/XML), then data analysis and processing are easier, but transactions become susceptible to man-in-the-middle and parameter tampering attacks
Solution Approach 1:
The patent changes the fundamental parameter of data representation from human-readable formats (JSON/XML) to binary-encoded formats. This parameter change maintains ease of processing through structured binary protocols while eliminating the security vulnerabilities associated with human-readable formats, as attackers cannot easily interpret or modify binary transaction data without detection
Solution Approach 2:
The patent introduces cryptographic hashing and digital signatures as intermediary mechanisms between the transaction data and the transmission channel. These intermediaries verify data integrity and authenticity, preventing tampering while allowing the transaction to remain in a processed format. The hash function acts as a mediator that detects any modification without requiring encryption of the entire transaction
2Reliability
If transactions are encrypted to prevent tampering, then transaction security improves, but computational cost increases and data analysis becomes difficult
Solution Approach 1:
The patent extracts the security function from full encryption and implements it through selective cryptographic operations. Instead of encrypting the entire transaction payload, the system extracts only the critical integrity verification function and implements it through hashes and signatures on specific fields. This reduces computational overhead while maintaining security against tampering
Solution Approach 2:
The patent uses cryptographic hashes as digital fingerprints or copies of the transaction data. These hash copies verify integrity without requiring the actual encrypted data to be processed. The hash acts as a lightweight copy that can be computed and verified efficiently, providing security without the computational burden of full encryption
3Productivity
If client-generated transactions are transmitted without encryption, then processing speed is maintained, but transactions become vulnerable to interception and modification during transmission
Solution Approach 1:
The patent applies preliminary cryptographic actions to the transaction data before transmission. Hash functions and digital signatures are computed in advance on the transaction payload, creating integrity markers that travel with the data. This preliminary action ensures that any interception or modification during transmission can be detected, while the transmission itself remains unencrypted and fast
Data Source
AI summary
Computer-implemented cyber-security, behavior-generated, event-type signed processes and machines provide for authentication and immutable transactions to overcome security risks. Clients submit requests for an immutable transactions and interactions responsive to the request are sent by the server to the client. The server generates behavioral expectations for the interactions, stores them for future comparison purposes, and transmits those to the client. The client executes user events for the interactions. The client behaviorally analyzes the user events and generates behavioral vectors corresponding to the user events. Intermediate client hashes that culminate in a final client hash are generated. User events are sent to the server. The server generates a server hash based on the behavioral expectations and the user events. The server compares the final client hash to the server hash to determine if the transaction is authentic and should be stored as immutable.