Distributed transaction processing and authentication system
The described system addresses ACID consistency and security issues in large-scale transaction processing by employing hash chains and a directory service for real-time, secure transactions, achieving high transaction rates and eliminating the need for reconciliation accounts.
Patent Information
- Application Number
- JP2024118373
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2016-07-08
- Filing Date
- 2024-07-24
- Publication Date
- 2024-11-26
- Estimated Expiration
- 2037-07-07
AI Technical Summary
Existing transaction processing systems face challenges in achieving ACID consistency while ensuring high availability and performance, leading to issues like missing records, duplicated transactions, and credit overdrafts, particularly in large-scale systems such as bank payment networks and IoT environments, where trade-offs between consistency, availability, and partition tolerance result in compromised security and data integrity.
A method for authenticating and processing transactions in real-time using a system that records ACID-compliant transactions at scale, employs hash chains with zero-knowledge proofs, and utilizes a directory service to support mesh networks, enabling secure real-time communications across multiple private ledgers, and a data services layer for various transaction types, all while maintaining a modular framework for device updates and secure communications.
The system enables real-time transaction processing and completion at scale with zero incremental cost, ensuring ACID compliance, enhancing security and data integrity, and supporting high transaction rates without the limitations of traditional trade-offs, thus eliminating the need for reconciliation accounts and improving system resilience.
Smart Images

Figure 2024164013000001_ABST
Abstract
Description
[Technical field]
[0001] The present invention relates to a method and system for performing all types of transactions securely in real time at large scale in a single implementation. [Background technology]
[0002] Transaction processing includes a wide range of distributed computer-based systems and multiple transactors that perform transactions related to payments, but also trade with other financial assets and transactions, physical access control, logical access to data, management of devices that make up the Internet of Things (IoT), and monitoring devices.
[0003] Nowadays, when developing a transaction processing system, engineers must make difficult trade-offs. This includes choosing between speed and resilience, throughput and consistency, security and performance, consistency and scalability, etc. Such trade-offs invariably result in compromises that affect the entire system. Payment processing systems demonstrate the effects of such trade-offs. They may have to process anywhere from 600 to tens of thousands of transactions per second, but only partially process them and store the details for further processing at some point in the system's workload. This often creates problems such as reconciling lost records, duplicating transactions, exposing credit issues where accounts are over-debited between the time of the transaction and the time of the transaction processing, and more. But the problems are not limited to payments.
[0004] ACID (Atomicity, Consistency, Isolation, and Durability) is a consistency model for databases where each database transaction must succeed if the overall transaction can be rolled back (atomicity), cannot leave the database in an inconsistent state (consistency), cannot interfere with each other (isolation), and will persist even when the server is restarted (durability).
[0005] This model is generally considered incompatible with the availability and performance requirements of large-scale systems such as existing bank payment networks and other "big data" transactional systems. Instead, such systems rely on BASE consistency, soft state, and eventual consistency. This model argues that it is sufficient for the database to eventually reach a consistent state. Banking systems operate in this mode because they must frequently perform reconciliation checks and suspend the processing of transactions to reach a consistent state. The notion that tradeoffs must be made in high-volume transaction processing is made explicit in the CAP consolidation, which shows that no distributed computer system in its basic form can provide all three of these simultaneously: consistency, availability, and partition tolerance. Current best practice solutions contain too many limitations and tradeoffs to meet today's emerging requirements.
[0006] The question of how to reconcile data generated by the IoT arises from the trade-offs that engineers find they need to make when building networks and transaction processing systems. One of those effects is the lack of security for communications between the devices and servers that together make up the Internet of Things. Another is the inability to guarantee that the data collected by a device is actually related to the specific events detected by that device.
[0007] Cloud-based information storage systems also exhibit the effect of such trade-offs, but in many cases involve a huge number of servers and systems that can only guarantee ultimate consistency. Therefore, there is a need to provide ACID consistency for large systems that can only benefit from BASE consistency in known systems. Summary of the Invention [Problem to be solved by the invention]
[0008] As discussed above, the present invention relates to a new method of processing transactions that need not be weighed or limited by current tradeoffs. The present invention provides a method for authenticating and processing transactions in real time at a rate several times greater than existing systems, and for paying or processing and completing such transactions in real time.
[0009] Real-time payments does not only apply to financial transactions: it applies to any transaction that can benefit from or requires, in part or in whole, instantaneous authentication, authorization, processing and completion, from access control to records validation, records and document exchange, command and control instructions, and so on.
[0010] The method is structured into seven main areas: A method for recording ACID-compliant transactions at extremely high scale in any database product Enablement of hash chains that convey record authentication across multiple private ledgers with full mathematical proof at extremely high scale within a single real-time session A directory service that supports a mesh network of transaction service providers, rather than enabling a "hub and spoke" architecture that creates scalability issues. An extensible framework that allows merchant or user devices to update the applications (or apps) they use to process transactions over the air and from one transaction to the next. A data services layer that acts as a migration matrix between applications supporting a variety of different transaction types and a common database structure A method for assembling and proposing an adhoc set of credentials that allows a service or device to access a set of services or features. How to create secure real-time communications over any protocol, including Near Field Communications (NFC) and Unstructured Supplementary Service Data (USSD) The system of the present invention provides a method for achieving real-time transaction processing and completion at zero incremental cost due to the inherent growth in the number of transactions within the processing method. [Means for solving the problem]
[0011] According to one embodiment, a method for recording data transactions in a device associated with a first entity is provided, the method comprising: determining first seed data; generating the record of a first data transaction between the first entity and a second entity; combining at least the first seed data and the record of the first data transaction to determine second seed data; hashing the second seed data to generate a first hash, the first hash comprising a history of data transactions associated with the first entity; and storing the first hash for the record of the first data transaction in a memory. According to another embodiment, a device associated with a first entity is provided for performing the method. According to another embodiment, a computer readable storage medium is provided comprising a plurality of code portions which, when executed, cause a computing device to perform the method.
[0012] According to another embodiment, a licensing device is provided that receives a first hash from a device associated with a first entity, the first hash including a history of data transactions associated with the first entity, combines the license hash with the first hash to provide a license input, hashes the license input to generate a second license hash, and stores the second license hash in memory.
[0013] According to another embodiment, a directory device is provided that receives a first hash from a device associated with a first entity, the first hash including a history of data transactions associated with the first entity, combines the directory hash with the first hash to provide a directory entry, hashes the license entry to generate a second directory hash, and stores the second directory hash in memory.
[0014] According to another embodiment, a method for accessing a first service from a device is provided, the method comprising the steps of providing an identifier of the device to a request server, authorizing the device to request access to the first service based on the identifier, and causing the device to access the first service from a first host server on which the first service is located, the access being via the request server. According to another embodiment, a device is provided for performing the method. According to another embodiment, a computer readable storage medium is provided, the computer readable storage medium comprising a plurality of code portions which, when executed, cause a computing device to perform the method.
[0015] According to another embodiment, a data migration method is provided, comprising the steps of: providing a request for switching first data from a first data store to a second data store; determining an identifier of the first data store from a directory server based on an identifier included in the request; and migrating the first data from the first data store to the second data store. According to another embodiment, a device is provided for performing the method. According to another embodiment, a computer readable storage medium is provided, comprising a plurality of code portions which, when executed, cause a computing device to perform the method.
[0016] According to another embodiment, there is provided a method of communication comprising the steps of: sending a first communication from a first entity to a second entity, the first communication comprising two or more data fields, each field comprising an individual label; and sending a second communication from the first entity to the second entity, the second communication comprising the two or more data fields, the order of the fields in the second communication being different from the order of the fields in the first communication. According to another embodiment, there is provided a device for performing the method. According to another embodiment, there is provided a computer readable storage medium comprising a plurality of code portions which, when executed, cause a computing device to perform the method.
[0017] According to another embodiment, there is provided a method of communicating via unstructured supplementary service data (USSD) comprising the steps of opening a USSD session between a first device and a second device, generating cypher text for communication over the session at the first device, encoding the cipher text at the first device, and transmitting the encoded cipher text from the first device to the second device for decryption at the second device. According to another embodiment, there is provided a device for performing the method. According to another embodiment, there is provided a computer readable storage medium comprising a plurality of code portions that, when executed, cause a computing device to perform the method.
[0018] According to another embodiment, there is provided a method of communication between a first device associated with a first entity and a second device associated with a second entity, the method comprising the steps of: generating, at the first device, a first PAKE session between the first device and the second device using a first shared secret; receiving from the second device a registration key and a second shared secret; and hashing the first shared secret, the registration key, and the second shared secret to provide a third shared secret for generating a second PAKE session. According to another embodiment, there is provided a device for performing the method. According to another embodiment, there is provided a computer readable storage medium comprising a plurality of code portions that, when executed, cause a computing device to perform the method.
[0019] According to another embodiment, there is provided a method of accessing a service, the method comprising providing credentials and a context for said credentials, and authenticating access to said service based on said credentials and said context. According to another embodiment, there is provided a device for performing said method. According to another embodiment, there is provided a computer readable storage medium comprising a number of code portions which, when executed, cause a computing device to perform said method.
[0020] According to another embodiment, a method of communication between modules in a computer system is provided, the method comprising the steps of communicating a shared memory channel from a first module to a proxy, communicating the shared memory channel from the proxy to a second module, the proxy including a handoff module for transmitting data between the first module and the second module bypassing the kernel of the computer system, and transmitting data from the first module to the second module. According to another embodiment, a computing device is provided for performing the method. According to another embodiment, a computer readable recording medium is provided, the computer readable medium comprising a plurality of code portions that, when executed, cause a computing device to perform the method.
[0021] The first seed data may include an initiation hash. The initiation hash may be a result of hashing a record of a previous data transaction associated with the first entity. The initiation hash may include a random hash. The random hash may include at least one of a signature from the device, a date and / or a time the random hash was generated.
[0022] Providing second seed data may further include combining the first seed data and the record of the first data transaction with a first zero-knowledge proof and a second zero-knowledge proof, where the first zero-knowledge proof may include a proof that the starting hash includes the true hash of the previous data transaction associated with the first entity. The second zero-knowledge proof may include a proof that the second hash includes the true hash of the previous data transaction associated with the second entity. Providing second seed data may further include combining the first seed data, the record of the first data transaction, the first zero-knowledge proof and the second zero-knowledge proof with a third zero-knowledge proof. The third zero-knowledge proof may be generated from random data. The third zero-knowledge proof may be an iteration of the first zero-knowledge proof or the second zero-knowledge proof. The third zero-knowledge proof may be constructed using a second record of the first data transaction corresponding to the second zero-knowledge proof.
[0023] The first data transaction may include at least two stages, and providing second seed data may include combining records of the first stage of the first data transaction with the first zero-knowledge proof, and combining records of the second stage of the first data transaction with the second zero-knowledge proof. Providing second seed data may include constructing a third zero-knowledge proof from records of the second stage of the first data transaction, and combining records of the second stage of the first data transaction with the second zero-knowledge proof and the third zero-knowledge proof. The first data transaction may include at least three stages, and providing second seed data may further include combining records of the third stage of the first data transaction with the first zero-knowledge proof, and combining records of the third stage of the first data transaction with the third zero-knowledge proof.
[0024] The first data transaction may include at least three stages, and providing second seed data may further include combining a record of the third stage of the first data transaction with the first zero-knowledge proof and combining random data with the third zero-knowledge proof. The first data transaction may include at least three stages, and providing second seed data may include combining a record of the third stage of the first data transaction with the first zero-knowledge proof and combining a record of a fourth stage of the first data transaction with the second zero-knowledge proof, and the fourth stage of the first data transaction may be a repetition of the third stage of the first data transaction.
[0025] The first data transaction may include at least three stages, and providing second seed data may further include combining a record of the third stage of the first data transaction with a third zero-knowledge proof.
[0026] The first zero-knowledge proof may be constructed by the device associated with the first entity, and the second zero-knowledge proof may be constructed by a device associated with the second entity.
[0027] Constructing the first zero-knowledge proof and the second zero-knowledge proof may include using a key exchange algorithm, which may include the PAKE algorithm.
[0028] The method may further include transmitting the first hash to a device associated with the second entity, receiving a second hash from a device associated with the second entity, the second hash including a hash of a previous data transaction associated with the second entity, generating a record of a second data transaction between the first party and the second party, combining the first hash and the second hash with the record of the second data transaction to determine third seed data, hashing the third seed data to generate a third hash, the third hash including a history of data transactions associated with the first entity and a history of data transactions associated with the second entity, and storing the third hash for the record of the second data transaction in the memory.
[0029] Providing third seed data may further include combining the record, the first hash, and the second hash of the second data transaction with a third zero-knowledge proof and a fourth zero-knowledge proof, where the third zero-knowledge proof includes a proof that the first hash contains a true hash of the first data transaction and the fourth zero-knowledge proof includes a proof that the second hash contains the true hash of the previous data transaction associated with the second entity, where the previous data transaction associated with the second entity may be the first data transaction.
[0030] The method may further include associating each of the hashes with an identifier of the first entity and / or the second entity. The method may further include recalculating the first hash and comparing the generated first hash to the recalculated second hash to determine a match. The method may further include canceling the additional data transaction if the comparison is unsuccessful. The method may further include generating a system hash in a system device that corresponds to the first data transaction.
[0031] Providing second seed data may further include combining the first seed data and the record of the first data transaction with the system hash, which may be a result of hashing records of previous data transactions on the system device.
[0032] The step of providing second seed data may further include receiving a license hash from a licensed device and combining the license hash with the first seed data and the record of the first data transaction to provide the second seed data.
[0033] The method may further include, at the licensing device, receiving the first hash, combining the license hash and the first hash to provide a license input, and hashing the license input to generate a second license hash.
[0034] The step of providing the second seed data may further include the steps of receiving a directory hash from a directory device and combining the first seed data and the record of the first data transaction with the directory hash to provide the second seed data.
[0035] The method may further include, at the directory server, receiving the first hash, combining the directory hash and the first hash to provide a directory entry, and hashing the directory entry to generate a second directory hash.
[0036] Providing second seed data may further include generating a key hash from an encryption key for the first data transaction, and combining the first seed data and the record of the first data transaction with the key hash to provide the second seed data, which may include a public or private key for encryption.
[0037] The step of combining the first seed data and the record of the first data transaction may be performed upon completion of the first data transaction. The memory may be located on a remote device. The method may further include comparing, at the remote device, the first hash with hashes received from other devices. The method may further include notifying other devices connected to the device to expect to receive the first hash.
[0038] The method may further include storing the hash chain in the memory. The method may further include transmitting the hash chain to a second memory located on a device configured to restrict access to the transmitted hash chain. The method may further include modifying or deleting a hash from the hash chain, where modifying or deleting a hash from the hash chain may include regenerating a hash of a target in the hash chain, determining if the record has been modified, recording the regenerated hash, modifying or deleting the record, hashing the combination of the hash of the target and the modified and deleted records to generate a new hash for the record, and recording the new hash. The method may further include generating a system hash using the new hash.
[0039] The device may include a server. The device may include a user device. The user device may include at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things (IoT) enabled device. The user device may store the first hash in a memory on the device. The user device may store the first hash in a memory on the device only if the device is offline from the server. The device may send the first hash to a device associated with the second entity. The device may sign the record of the first data transaction and send an encrypted copy to the device associated with the second entity, the signature including an indication of a destination server for the record of the first data transaction. The device may sign the record with a particular offline public key. The device may sign the record with a key belonging to the device. Only the destination server may decrypt the encrypted copy of the record of the first data transaction. When the device regains connectivity with the corresponding server, the device may send the associated hash and the encrypted record of its offline data transaction to the corresponding server. The device may transmit a copy of a record of a data transaction held by the device relating to another entity to a server corresponding to the device for transmission to the server corresponding to the other entity. The transmission may include notifying all servers to which the record applies to expect to receive the record. The device may generate a unique internal transaction number to identify its part in the first data transaction.
[0040] The authorizing step may include verifying whether the user device is authorized to access the first service based on the identifier. The verifying step may include verifying whether the user satisfies at least one criteria based on the identifier. A first criterion may be stored on the first host server or the request server, and a second criterion may be located on another server. The authorizing step may include verifying a signature on a communication between the request server and the first host server.
[0041] The authorizing step may be performed at the request server. The authorizing step may include determining at the request server whether the device has previously been authorized to access the first service.
[0042] The step of authorizing may be performed by a directory server. The step of authorizing may include the request server requesting authorization for the device from the directory server. The step of allowing may include the directory server sending an identifier for the first host server to the request server. Data authorizing the identifier may be stored in the directory server.
[0043] The method may further include the steps of requesting access to a second service, authorizing the device to access the second service based on the identifier, and allowing the device to access the second service via the request server. The second service may be located on the first host server. The second service may be located on a second host server.
[0044] The step of authorizing the device to access the first service may be performed in a first directory server, and the step of authorizing the user device to access the second service may be performed in a second directory server.
[0045] The method may further include the steps of requesting access to a third service, authorizing the device to access the third service based on the identifier, and allowing the device to access the third service.
[0046] The second service may be located on the first host server, the second host server or a third host server. The step of allowing the device to access the third service may be performed on a third directory server.
[0047] Providing the identifier may include the device communicating with the request server through an encrypted tunnel. The method may further include caching the received data at each respective server. Each host server may provide two or more services.
[0048] The device may include at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things enabled device. The migrating step may include the steps of: at the directory server assigning a beginning timestamp for the data in the second data store; and assigning an ending timestamp for the data in the first data store.
[0049] The method may further include instructing a requesting server attempting to access the data via the first data store after the end timestamp to search for the user in the second data store via the directory server. The data in the first data store may include a first account registration with a first account provider, and the data in the second data store may include a second account registration with a new account provider. The migrating step may include transmitting information about the first account registration from the current account provider to the new account provider. The information may include at least one of registrations, balances, configurations, and / or payment instructions. The migrating step may include verifying an authentication code indicating that the first registration is to be switched from the current account provider to the new account provider. The first account registration may include first user credentials, and the second account registration may include second user credentials. The first user credential may be registered with a first server and the second user credential may be registered with a second server. The method may further include receiving a communication delivered by the first account provider to a user using the first user credential and routing the communication to the second account provider using the second user credential. The method may further include reversing a data transaction made with the first registration provider using the first credential to the second registration provider using the second user credential. The method may further include determining that the user used the first user credential during the data transaction. A server sending the communication must be authorized to access the second user credential.
[0050] The device may include at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things enabled device. The method may further include adding random fields to the second communication, each field including two or more features, and the method may further include mixing cases of features in at least one field.
[0051] The method may further include decrypting and ordering the fields in the second communication by the second entity prior to processing the second communication. The method may further include discarding fields that cannot be processed by the second entity. At least one of the first entity and the second entity may include a server. At least one of the first entity and the second entity may include a personal computer, a smartphone, a smart tablet, or an Internet of Things enabled device. The device may include at least one of a personal computer, a smartphone, a smart tablet, or an Internet of Things enabled device.
[0052] The encoding step may include encoding the cipher text into a 7-bit or 8-bit character string. The method may further include splitting the cipher text into two or more parts and transmitting the two or more parts separately if the length of the cipher text is longer than the allowed space in the USSD session. The decryption may further include reassembling the two or more parts into the entire cipher text from the second device.
[0053] The method may further include authenticating the first and second devices. The authenticating may include using an algorithm that provides privacy and data integrity between two communicating computer applications. The authenticating may include using transport layer security (TLS). The using TLS may include generating a first session key.
[0054] The method may further include using the first session key to encrypt a PAKE protocol negotiation to generate a second session key, and encrypting additional communications in the session between the first device and the second device with the second session key.
[0055] The method may further include authenticating the first entity and the second entity. The authenticating may include using an algorithm that provides privacy and data integrity between two communicating computer applications. The authenticating may include using TLS. The method may further include generating a second PAKE session between the first device and a third device using a fourth shared secret. The fourth shared secret may include an authentication code generated by the third device for the first device.
[0056] The first shared secret may include an authentication code generated by the second device for the first device. The authentication code may be transmitted to the first device together with an identifier for the first device. The identifier may include a mobile number or a serial number of the first device. The first shared secret may include a personal account number (PAN) of a bank card associated with the first entity. The first shared secret may include an encoded serial number of a bank card associated with the first entity.
[0057] The device may include at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things enabled device. The step of authenticating access to the service may include authenticating access to a portion of a service based on the credentials and / or the context. The credentials may include a first credential for a device and a primary user of the device. The credentials may further include a second credential for a device and a secondary user of the device. The step of authenticating access to the service based on the credentials may include authenticating access to different services for the primary user and the secondary user based on the first credential and the second credential, respectively. The device may include the different services and bank cards with different spending limits for the primary user and the secondary user. The credentials may be selected based on the context. The services may include a plurality of services selected based on the context. An administrator or user may modify, add or revoke the context or credentials. The credentials may include at least one of a password, a PIN, and / or other direct authentication credentials. The context may include at least one of the device providing the credentials, an application on the device, a network to which the device is connected, a geographic location of the device, and / or the service being accessed.
[0058] The device may include at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things enabled device. The method may further include batching a plurality of requests into a batched message in a buffer memory of the first module, queuing the batched message to be sent to the second module, setting at least one system flag to enable a system function, checking the at least one system flag in the second module, and processing the batched message in the second module.
[0059] The method may further include setting up at least one shared memory channel between the first module and the second module. The method may include the second module responding to the first module via the at least one shared memory channel. The at least one shared memory channel may receive and assemble the batched messages and pass ownership of the memory to the second module. The at least one shared memory channel may receive the batched messages via a network stack of the computer system. The at least one shared memory channel may include an HTTP gateway. The HTTP gateway may be used as a web service.
[0060] The communications may use a password authenticated key exchange protocol. The method may further include using zero-copy networking in a network stack of the computer system. The method may further include using user-mode networking in a network stack of the computer system.
[0061] The method may further include serializing data such that the components of the data transmission from the first module are combined into a single data stream and separated into the components at the first module, the serialization being abstracted at the edge of each module.
[0062] The buffer memory of each module may have a configurable buffering threshold. The first module and the second module may be located on the same computing device. The first module and the second module may be located on different computing devices.
[0063] The data transmitted from the first module to the second module may carry a version ID. The method may further include verifying that the version ID is up to date for the data transmitted from the first module to the second module. The method may further include re-verifying the version ID to a current version if any of the data is updated. If the version ID is not verified, the data transmission may fail.
[0064] At least one of the first and second modules may include at least one data service module, and each data processing in the computer system may be performed via the at least one data service module. The at least one data service module may communicate with a data store implemented by a core database store. The at least one data service module may be a component of the computer system that directly accesses the data store. The core database store may include at least one distributed database. The at least one distributed database may have separate read and record access channels. The data store may provide an interface to at least one heterogeneous database. The data store may provide multiple interface types. The multiple interface types may include at least one of a Structured Query Language (SQL) interface, a cell and column interface, a document interface, and a graph interface on the core database store. All records for the data store layer may be managed by a single shared module that controls all or a portion of one or more data transactions.
[0065] The method may further include activating a redundant backup of at least one of the shared modules. All data changes may be made through the single shared module in a serial rapid sequence. The single shared module may use a hot backup redundancy model that presents itself to a data transactor cluster, the data transactor cluster being a set of modules in a hierarchy, each module may control data transactions in case of a master module failure. The method may further include partitioning data across modules or data stores based on rules configured by domain. The method may further include hashing target data of records of data transactions or records of parent data transactions. The hashing may have the same cardinality as the number of data partitions. The method may further include hashing target data by at least one of listed geographical regions, surnames and / or currencies.
[0066] The method may further include performing at least one data transmission through the at least one data service module across multiple data partitions. The method may further include completing the at least one data transmission through the at least one data service module by a multiplexing module. The method may further include persisting the at least one data transmission on the at least one data service module on multiple data storage nodes in the data store.
[0067] The computer system may include multiple data service modules, each of which may contain a cached representation of all the hot data for that instance and may host an in-memory / in-process database engine. The computer system may include multiple data service modules, each of which may include multiple heterogeneous or homogeneous database engines.
[0068] The method may further include using a multiversion concurrency control (MVCC) version system to manage concurrency of accesses to the datastore such that all data reads are consistent and accurately reflect the corresponding data records.The method may further include using pessimistic consistency to manage concurrency of accesses to the datastore such that a data record must be recorded in the datastore and confirmed to have been recorded before any subsequent data transaction accesses the data record.
[0069] The computer system may further include an application layer, wherein the application layer cannot proceed with the data transaction until the at least one data service module has confirmed that it has recorded the record and completed the data transmission.
[0070] All optional features of the first to twenty-sixth embodiments relate to all other embodiments mutatis mutandis only. Variations of the described embodiments are envisaged, for example, features of all disclosed embodiments may be combined in any manner. [Brief description of the drawings]
[0071] [Figure 1]This shows the modular concept of Tereon. [Diagram 2] An example of the Tereon system architecture is shown. [Figure 2a] It shows how Tereon abstracts services and devices into functional domains and contexts, devices, components and protocols. [Diagram 3] Shows communication initiated over a TLS connection through an intermediary proxy. [Figure 4] We demonstrate the use of shared memory and message passing with proxy memory. [Figure 4a] 3 shows a shared memory and semaphore handover module. [Diagram 5] Here is a hash chain containing four accounts: [Figure 6] Here is a hash chain containing two accounts on the same system. [Figure 6a] Shown is a hash chain containing three accounts on the same system with interleaving transaction steps. [Figure 7] Shows the dendritic nature of the license hash. [Figure 8] Here's a hash chain that includes four devices that will be offline for some time. [Figure 9] Illustrates the reverse lookup functionality implemented by two servers. [Figure 10] This shows the communication settings between Tereon servers. [Figure 11] This shows a communication in which a user moves to another server. [Figure 12] Shows how the directory service can connect a requesting server to two other servers. [Figure 13] We illustrate the case where a server must obtain credentials from three servers to construct a multi-sided credential. [Figure 14] This shows the relationship between the bank and the user. [Figure 15]This shows the process by which an account is credited. [Figure 16] 2 illustrates the process by which a registered mobile number is changed. [Figure 17] Shows possession of pre-registered mobile number to access two currencies. [Figure 17a] This involves having a pre-registered mobile number to access two currencies, each on a separate server. [Figure 18] The workflow is shown. [Figure 19] An alternative workflow is shown. [Figure 20] 1 shows an alternative workflow. [Figure 21] 1 illustrates an exemplary computing system. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0072] Embodiments of the present invention will now be described, by way of example only, with reference to the accompanying drawings, in which like reference numerals are used to refer to like parts, and in which: Tereon is an electronic transaction processing and authentication engine. It is implemented in mobile and electronic payment processing systems, and can be used in other implementations as part of IoT communication systems.
[0073] Tereon provides transaction capabilities for any IP (internet protocol) enabled device and any device that can interact with such IP enabled devices. Each device has a unique ID. Tereon use cases range from IoT devices to medical record access and management, mobile, ubiquitous payments such as payment terminals or ATMs (Automated Teller Machines). In the initial implementation, Tereon supports mobile, card, and POS (point-of-sale) terminals and unique reference IDs. Tereon provides the functionality necessary to enable consumers and merchants to pay, receive payments, send funds, receive funds, refund, receive refunds, withdraw funds, review account data, and view mini statements of past transactions. Tereon supports cross-currency and cross-country transactions. Thus, consumers can hold accounts in one currency but transfer, for example, in another currency.
[0074] In Tereon's initial incarnation, the end user's ability to perform a particular transaction depends on the application they are using at the time: the merchant or the merchant's terminal can initiate some transactions, while the consumer device can initiate others.
[0075] When Tereon is used to process payments, transactions are broken down into the following modes: paying, receiving payments, mobile consumer to mobile merchant, mobile consumer to online merchant portal, mobile consumer without a customer to mobile merchant, consumer account to merchant account in an account portal, NFC-Tereon card consumer to card merchant, NFC or other card consumer to card merchant, transferring and receiving funds, consumer account to consumer account in an account portal, mobile consumer to peer to peer mobile consumer, mobile consumer to peer to peer card consumer, card consumer to peer to peer mobile consumer, card consumer to peer to peer card consumer, mobile consumer to peer to peer non-user, card consumer to peer to peer non-user, non-user to peer to peer non-user, non-user to peer to peer mobile consumer, and non-user to peer to peer card consumer, where a non-user refers to a person not previously registered for the payment service, such as a non-recipient of a funds transfer.
[0076] System Architecture Internally, the Tereon server contains two main components: the Tereon Rules Engine (TRE) and the Smart Device Application Services Framework (SDASF).
[0077] SDASF allows the Tereon to manage a variety of different devices and interfaces by allowing the Tereon to use and link together a series of abstraction layers to define the way in which those devices and interfaces operate and connect to the Tereon.
[0078] For example, all bank cards use a base card abstraction layer. A magnetic stripe abstraction layer would be applied to cards with a magnetic stripe, an NFC layer for cards with an NFC chip, and a microprocessor layer for cards with chip contacts. If a card uses all three, Tereon defines the card with a main card abstraction layer and three interface layers. The NFC layer itself does not only apply to cards; it can also apply to any device that can support NFC, including mobiles. SDASF uses these abstraction layers to generate modules for each device or interface.
[0079] Externally, each connection and each service to a device or network is a module. Thus, services such as peer-to-peer payment services, deposit services, and mini-statements are all modules, as are interfaces to card manufacturers, banks, service providers, terminals, ATMs, etc. Tereon's architecture can support a variety of modules.
[0080] Modular view Figure 1 illustrates the modular concept of Tereon. Essentially, Tereon is a collection of modules, most of which contain modules. A module is defined by the business logic that determines the context and functional domain in which it operates, and the functions it needs to perform. Such functions could be any type of electronic transaction, for example, managing operations and communications between IoT devices, managing and transacting electronic or digital payments, managing and configuring identification or request authorization credentials, or managing and operating any other form of electronic transaction or device.
[0081] Tereon Server As shown in FIG. 1, the modules that make up the Tereon server 102 can be viewed at two levels: the SDASF 104 and the rules engine 106. The rules engine 106 itself defines the functional domain and context of each of the modules 108 (some of which are shown in FIG. 1, including modules that define services, protocols (not shown), smart devices, terminals, etc.), which in turn define the structure of the SDASF 104. The SDASF 104 and the resulting services and interfaces it supports define the system protocols that Tereon can utilize. These protocols in turn define the rules and services that Tereon can support (e.g., smart devices, terminals, etc.), which themselves define the functional domain and context that Tereon provides. This cyclical or iterative approach is used to ensure that the definitions of modules and the functions or requirements they support match each other. This allows modules to be updated, upgraded, and replaced in place without restricting the operation of the system.
[0082] The blocks and modules interface using abstracted APIs (application programming interfaces) which themselves define the functional domain and context that Tereon provides. Where possible, they communicate using a custom-made semaphore handoff module that can use shared memory, an example of which is shown in Figure 4a, described below. In this manner, the internal operation and functionality of the blocks and modules can be updated or replaced without disrupting the operation of the overall system.
[0083] Framework infrastructure components The infrastructure components are also modular: in the case of SDASF, they themselves contain modules.
[0084] Multiple interfaces Each interface is configured as a separate module connected to the core server. Thus, Tereon's modular architecture can support multiple interfaces including back offices and core systems, cards, payment institutions, merchants, mobile phones, services, service providers, storage, terminals, SMS (short messenger service) gateways, HLR (home location register) gateways, etc.
[0085] The database interface supports all structured query language (SQL) entry and graph analysis of the stored data. The interface also supports access control to partition fields within the database. Different user rules and permission levels can access defined data sets and fields. Access is controlled by a variety of security measures. Access, authentication, and authorization can be provided through a variety of industry standard access methods including access control lists (ACLs), lightweight directory access protocol (LDAP), custom role-based access such as cell and row security, and access interfaces restricted to individual roles.
[0086] E-commerce portals Tereon may support e-commerce portals through an API so that portal operators can create plugins for their portals.
[0087] Rules engine The rules engine 106 orchestrates together various components that are abstracted into transactions to build new services or to support new devices. Rules define the business logic for distributed services and allow service providers and others to tailor such services to individual users.
[0088] The rules are defined in a unified modelling language (UML) or plain English-like code. The engine can parse the rules and generate services from abstracted components.
[0089] The abstracted nature of components allows new service or device modules to be created quickly, allowing Tereon to support new services or devices as needed.
[0090] Tereon's internal interfaces are protocol agnostic, meaning that external protocol modules can be exchanged without affecting functionality. For example, to interface to a banking core system, a custom data exchange protocol is used in one part of the organization and an ISO20022 protocol module in the other.
[0091] SDASF 104 allows Tereon to support multiple smart devices and protocols. The idea of SDASF 104 is to abstract entities into device types and protocols. SDASF 104 defines multiple protocols, with each device calling the protocol required for a particular service or function.
[0092] SDASF 104 can be extended by adding new modules to an existing installation without affecting the operation of the installation. Using either method, all services can be defined in the back office server. Once installed in merchant terminals, Tereon terminal applications communicate with SDASF to provide services to consumers.
[0093] 2 illustrates the Tereon system architecture 200. Where diagrams and depictions herein show particular components through a particular solution, this is simply because that is the component or language chosen in the embodiment. Bespoke systems can be built to replace such components or use other languages and systems that may prove more efficient.
[0094] The Tereon server The Tereon service 202 is a logical construct that is identified as a monolithic artifact, although in reality it may exist as a set of isolated microservices, each differing in functionality and scope.
[0095] ·The communications layer The communication layer 204 is initiated via a transport layer security (TLS) connection through the intermediary proxy, also shown in FIG. 3. TLS is a cryptographic protocol that provides communication security over computer networks, typically transmission control protocol / internet protocol (TCP / IP) networks. Each component has an access control list (ACL) that specifies which users or system processes can connect to or access the system, object, or service. This allows the intermediary to configure incoming, original connections only, enhancing inherent security and reducing the risk profile. In this example, the proxy uses an HTTP gateway platform known in the art, with specialized Tereon customizations.
[0096] Private DNS network DNS 206 is used as the basis for directory service 216, which is highly redundant and replicated across geographic locations, but whose structure and functionality go far beyond what existing DNS services can provide, as described below.
[0097] ·Abstractions Figure 2a shows how Tereon abstracts its services and devices into functional domains and contexts, such as consumer or consumer processes and rules, merchant processes and rules, bank processes and rules, transfer processes and rules, device functions and rules, etc. Figure 1 illustrates how Tereon exerts a vision on such abstractions by abstracting the components and services of a system into functional blocks or modules.
[0098] Tereon modules are composed of such abstractions. Each device, each interface, and each transaction type is abstracted to its domain and context. Such abstractions are reusable and may interface to others where it makes sense or is permitted. For example, charge card, credit card, debit card, and loyalty card modules use common base abstractions, as do payment and funds transfer modules.
[0099] Protocols Each of the protocols 204 and 212 that Tereon supports is itself implemented as a module. Tereon makes such modules available to any service or component that requires them.
[0100] Legacy systems struggle to process 100s or 1000s of simultaneous transactions before adding hardware. Instead of updating their systems, banks have relied on periodic payment systems that require reconciliation accounts and high costs to cover credit up to the point of payment. Tereon is insulated from the credit exposure and need for such accounts. It provides an extremely inexpensive system that is required to process 100,000 transactions per second. Tereon is built to be resilient, supporting 1,000,000 transactions per second per server, and is designed to run on high-end commodity hardware without relying on expensive hardware. Tereon also supports horizontal and vertical scaling in a near-linear fashion without compromising ACID guarantees or its real-time performance.
[0101] The licensing subsystem The Tereon License Server 210 ensures that the components of the system communicate with legitimate, authenticated and authorized peer systems within the universe of distributed instances (e.g., individual consumer platforms communicating with each other) within a single distributed instance (a single instance microservice may be a machine, e.g., a physical machine, a logical machine, a virtual machine, a container, or any commonly used mechanism for including executable code and inter-process communication on a single machine regardless of any number or type of machine). The licensing platform is accomplished through a certification authority structure known in the art.
[0102] When components are installed on a system, they communicate their installation details (organization, component type and details, license key, etc.) along with a certificate signing request to the license server over a secure, authenticated connection at defined and configurable intervals.
[0103] The certificate server compares the details with its authorized component directory and, if there is a match, issues a new certificate to the device initiating the installation request, signed with a security signing key (typically via a hardware security module) isolated within the internal Certificate Authority hierarchy and available for a fixed period of time (e.g. one month). All clocks on connected systems are synchronized.
[0104] The caller then uses the certificate as a client certificate when initiating communication with other modules and as a server certificate when acting as the recipient of a connection. A license server that has not received a private key does not have the details that would allow another third party to forge this certificate, even if it is compromised. If necessary, the caller can request two certificates from the license server: a client certificate and a server certificate.
[0105] Each component verifies that server and client certificates are signed by agents of trusted and certified certificate authorities, allowing it to communicate with reasonable confidence that it is not subject to man-in-the-middle attacks or monitoring, and that the counter-party is who it says it is. Each certificate is endorsed by usage code metadata that limits how each module can present itself (e.g., as a lookup server for a particular organization). The organization ensures that all parties are running licensed, legitimate, and valid instances.
[0106] Many certificates expire and are not renewed for a fixed period of time, and are not recognized. However, revocation lists are used when certificates are damaged or licenses are terminated or suspended, and are distributed asynchronously to proxy services as required. An active certificate directory is maintained at all times and is available for periodic auditing.
[0107] Besides the benefit of two-way validity checking (the client is the talker and the server is the reporter of each connection), this implementation allows components to communicate safely with each other without establishing each connection required to communicate with a remote license server, allowing them to communicate safely without reducing the overall reliability of the platform.
[0108] Site to site communications Communication between sites is facilitated through an identified and exposed HTTP gateway instance 212, which performs custom zero-copy and optional user mode functions. This is the platform used by mobile devices, terminals, and other external parties to communicate with the instance as well as connect between sites. It supports industry standard intrusion detection, rate limiting, and distributed denial-of-service (DDOS) attack protection, hardware encryption offload, etc. Functionally, it is a logical instance proxy mechanism that supports all of the same features (including client / server certificate and validation checking) and uses an externally recognized certificate authority for external parties.
[0109] The Tereon data service One of the key features of the Tereon system is its ability to handle many more transactions (in terms of throughput) than previous systems, due to its unique design which provides a highly concurrent, agile and scalable processing network capable of handling the data and transactions, an extremely efficient data services layer, as well as algorithms and tailored modules which minimize processing overhead.
[0110] The described performance characteristics are primarily targeted at scaling to run more on a particular piece of computing hardware, thereby significantly reducing operational costs and power consumption, although the design is not limited to a single system and the Tereon system can scale out enormously both vertically and horizontally with each service capable of running simultaneously on multiple devices.
[0111] To obtain high levels of performance on a single system or server, the system minimizes processing overhead where possible by avoiding unnecessary serialization, avoiding unnecessary stream processing, avoiding unnecessary memory copies, avoiding unnecessary switches from user to kernel mode, avoiding context switches between processes, and avoiding random or unnecessary I / O. When the system operates correctly, this can result in extremely high levels of transaction performance being achieved on that system.
[0112] In the existing model, Server A receives a request. It then constructs and serializes a query for Server B, and immediately sends the query to Server B. Server B then decrypts, deserializes, and interprets the query (if necessary). It then generates and serializes a response, encrypts the response if necessary, and then sends the response back to Server A or another server. Kernel and process context switches occur dozens of times per message, a single message is cast many times into various forms, and memory is copied between many working buffers. All this kernel and process context switching imposes a large amount of processing overhead for each message processed.
[0113] Communications architecture Tereon achieves its throughput by reconstructing the traditional data and communications handled by the system. Where possible, Tereon bypasses the operating system kernel to avoid the processing overhead imposed by the kernel and to avoid security issues that frequently arise with standard data management models.
[0114] Every data transaction in the system is executed through a data service instance 214. This is a scaled-down service (directed data service layer) that is the only component of the system with direct data platform access, so every data transaction on the system must pass through it.
[0115] The data services layer 214 communicates with the data store layer 220 via separate dedicated read and record access channels 226. The data store layer 220 is realized through a core database store 224, which itself contains at least one distributed database. Such a database does not need to provide ACID guarantees; this is managed by the data store layer.
[0116] All records for the data store layer 220 are managed by a single shared transactor through which all data modifications are forwarded in a serial, fast sequence to maintain causality. The transactor design uses a hot backup redundancy model that presents itself as a data transactor cluster 222. If one transactor fails or stops for any reason, one of the other transactions will immediately take over.
[0117] The data platform supports partitioning for all data domains, but such support is not shown. In any case, if a single data store layer (backed by unlimited data nodes) is prohibited or there is a regulatory reason, the data can be partitioned in an imperative or declarative way to store in different data clusters with different transactions. For example, a site may have four data platforms, and the platform may partition customers by geographic or jurisdictional criteria, or by accounts starting with 1-5, or other accounts starting with 6-0. There are processing issues for this, but it is supported by the platform.
[0118] Figure 3 shows communication through the data services layer 214 and the communication layer 204 which routes the communication from there. When a module 350 needs to communicate with another module 360, it first initiates a connection with a proxy 370, authenticating the client certificate in step 302 and checking whether the proxy certificate is validly trusted when constructed in step 304. The module 350 communicates the message to the proxy 370 in step 306. The proxy 370 sets up a correlating connection with the target module 360 in step 308. It first authenticates itself in step 308 and verifies whether the module's certificate is validly trusted in step 310. The proxy 370 communicates the verified details of the initiator (module 350) in step 312 before receiving the module's response in step 314. The proxy 370 returns the details of the target (module 360) and its response in step 316. This establishes a communication channel between module 350 and module 360 via proxy 370, where all two modules are authenticated and identified to one another with a high degree of confidence, and where necessary, all communications and data are encrypted. Proxy 370 relays messages from module 350, step 318, to target module 360, step 320, and relays the target module's response, step 322, to module 350, step 324.
[0119] Such connections use session sharing and keep-alive based on the details of the originator and recipient credentials (e.g., module 350 "closes" a connection to target module 360 via proxy 370 and reopens it without actually building a new end-to-end connection; the connection is never shared with any other circuit). Communications proxy 370 may be an HTTP gateway or other suitable module or component.
[0120] Such an architecture incurs a significant performance cost, primarily due to the use of large amounts of memory. Traditionally, for a module 350 to communicate with a target module 360, it must serialize the payload before transmitting it to the target module 360, encrypt the payload, stream it to a proxy 370 (where the proxy 370 decrypts the payload), deserialize and interpret the content, re-serialize the payload, and encrypt it for the target module 360. The target module 360 may decrypt, deserialize, and interpret the content.
[0121] Tereon uses a variety of techniques to reduce average and maximum latency, reduce memory pressure, and improve performance of a single platform on commodity hardware. This achieves monolithic in-process performance while retaining all of the deployment benefits, maintenance, and security of microservices, without compromising the high level of security and control such a system has to offer.
[0122] Tereon may use a batched messaging model across its communications layer, as shown in Figure 3. Each message communicated, such as the message communicated from module 350 to proxy 370 in step 306, may be a batch of messages. However, Tereon may do much more than this.
[0123] In addition to batched messaging, Figure 4 shows that the servers of the two modules communicate with each other through a proxy module (a custom handover module) to negotiate a shared memory channel. Steps 402-412 are similar to steps 302-312 in Figure 3 and, if necessary, check the attributes of the service to see if it matches the client request. This can occur in steps 302-312.
[0124] An instance of module 450 or module 460 can optimally use both TLS or traditional TLS HTTPS as well as user mode and zero copy HTTP gateways for caller transactions.
[0125] If the source module 450 and the destination module 460 are local, after setting up a connection through the proxy 470 from steps 402-412, the originator and the recipient may optionally request a direct connection through shared memory, which makes this method different from the method set out in Figure 3. If the originator and the recipient request a direct connection with each other, after negotiation, the shared channel is communicated from the module 460 to the proxy 470 in step 414 and from the proxy to the module 450 in step 416, and from this point on the two modules use a direct processing mechanism again using semaphores and shared memory. This is indicated by messages between the modules 450 and 460 in steps 418, 420, 422, etc.
[0126] In the Tereon model, server 450 batches multiple requests in native memory buffers in a manner optimal for the task, queues messages to server 460, and trips semaphores. Server 460 checks flags, handles shared memory directly, and responds to shared memory. Connections use connection maintenance and shared memory based on sender and recipient authentication details and semaphores and shared memory for communication.
[0127] Using the methods described above, communication is single-originator destination, ACL-control, avoids serialization and streaming overhead for security (if contained within the machine), no encryption is required, connections are validated and authenticated, allowed at setup time, cannot be revoked, and processes can share large private memory structures where appropriate.
[0128] Proxy 470 and Tereon code modules 450 and 460 all support zero-copy networking and user-mode networking where possible (when compiled with the required RCP / IP libraries, the HTTP proxy provides a solution that can eliminate the significant cost of kernel context switches for network packets). This is facilitated through network driver specific code that proxy 470 and Tereon code modules can use, minimizing memory usage for small packet requests and responses that constitute a large number of Tereon operations (where many operations fit into a single TCP packet).
[0129] Figure 4a shows how the Tereon system implements a set of custom semaphore handoff modules 408a that can use shared memory to efficiently exchange data between any two components of the Tereon system (e.g., an HTTP gateway 406a and a microservice 410a that provides functionality within Tereon). In Figure 4a, the data services layer 214 is implemented by a microservice 410a. However, a microservice can represent any kind of service module.
[0130] The network stack 404a (including the loopback virtual device) receives and assembles requests from the connection server 402a, and instead of copying it to user mode target memory, it simply passes ownership of the memory grant to the recipient (in this case the HTTP gateway 406a). This is primarily useful at very high loads (e.g., millions of requests per second) where memory bandwidth saturation begins to occur.
[0131] The custom Tereon upstream HTTP gateway module 406a allows the local instance (typically on each container or on each physical, logical, or virtual machine HTTP gateway instance if there is one) the option to use shared memory and proxy memory from the gateway to the module, and vice versa for the corresponding upstream connection. When the HTTP gateway 406a is configured for a shared memory upstream provider, instead of serializing the request and passing it along via existing mechanisms, the HTTP gateway 406a uses shared memory to pass along to the recipient.
[0132] In this case, the shared memory is set up using other HTTP gateways, HTTP gateway instances, or other elements to proxy. Using an HTTP gateway is particularly efficient.
[0133] Instead of using communication hooks provided by the operating system kernel, each data exchange module bypasses the kernel, thereby avoiding kernel overhead, increasing system throughput, and addressing areas of uncertainty that can arise when data is communicated to and from services provided by the kernel. For example, modules within Tereon are used to efficiently exchange data from system components directly to the Data Services Layer 214 and from the Data Services Layer 214 to system components.
[0134] Another example of the benefit this architecture provides is the increased efficiency of the HTTP gateway 406a (achieved by using a handoff module 408a that hands over to the HTTP gateway 406a all input data to the microservices 410a, such as the data services layer 214 or other components, and all output data from the microservices 410a or the data services layer 214). Instead of using the basic HTTP gateway data and messaging handoff, a semaphore handoff module that is efficient in itself and can use shared memory allows data to bypass the kernel and be passed directly from the data racer 214 to the HTTP gateway 406a and from the data layer 214. This not only increases the throughput of the system, but has the added benefit of protecting one of the common areas of weakness in systems that use HTTP gateways.
[0135] Modules that provide or communicate with the shared memory channel batch and serialize / deserialize requests to separate them. The modules that perform the tasks are accountable for the functionality of the modules and the processing overhead that the modules incur when they operate normally. For example, in some cases, a module that itself receives multiple messages (which may or may not be requests) communicates the messages to a shared memory module that batches and serializes the messages for the recipient module, but the batching and serialization overhead prevents the module from otherwise efficiently processing messages at load time. In other cases, a module may batch and serialize messages to a particular recipient before communicating the batch to the recipient over the shared memory channel.
[0136] In a further case, a module that communicates messages to a recipient module may rely on a module that provides a shared memory channel to batch and serialize messages, while a module that receives batch messages may itself deserialize and demultiplex the messages. The question as to which module performs the tasks of batching and serialization, or deserialization and demultiplexing, depends on which choice provides the optimal performance level for the functions performed by the module. The batching and serialization order will vary depending on the message type and the functions provided by the communication module.
[0137] Tereon uses an HTTP gateway 406a to become a web service, avoiding potential problems with network operators blocking non-standard services. Tereon can, of course, masquerade as any other service if desired, making it easy to work with well-known network security configurations.
[0138] Such a design allows the system (which uses modules designed to use available resources) to adopt this modular access approach throughout the entire architecture, avoiding overhead where possible. An additional example is a modular networking system (using Tereon where possible) that supports zero-copy or user-mode networking in the network stack 404a. This avoids much of the overhead of using a kernel for networking. The modular design also allows Tereon to operate in multiple types of systems, with similar custom-made modules providing similar functionality, customized to suit each operating system or hardware configuration.
[0139] Using an intermediary in the manner illustrated in Figures 3 and 4 allows a centralized control point for all internal or external machine communications. This is a single point of control for rate and security control, monitoring and auditing, and special rules or redirection. This allows for flexible deployment of the system while it is in operation, without incurring downtime or significant risk. It also facilitates load-balancing and redundancies without client awareness or complexity.
[0140] When a module 350 shown in FIG. 3 desires to communicate to a target module 360, the use of an intermediary allows the target module 360 to distribute the load across "n" machines and be mobile between any number or types of machines without having to reconfigure all potential clients, instead of simply reconfiguring the intermediary.
[0141] The system uses a password authenticated key exchange (PAKE) protocol that was created to provide the ability for two communicating parties to authenticate each other's key exchange. This is not possible for different well-known shared key exchange protocols (e.g., the Diffie-Hellman key exchange protocol), making the protocol vulnerable to man-in-the-middle attacks. When used correctly, the PAKE protocol is not susceptible to man-in-the-middle attacks.
[0142] When Tereon communicates with an external system, such as an external device or server, an additional layer is added to the communication system. Many key exchange protocols are theoretically vulnerable to man-in-the-middle attacks, and once a connection has been set up using a certificate and a signed message to verify that the communication is between two known entities, the system uses the PAKE protocol to set up a second security session key, so the communication is not susceptible to man-in-the-middle attacks. The communication then uses the PAKE protocol's session key to encrypt all subsequent communications using the TLS session key.
[0143] When communicating with devices that have unavoidable identification strings, TLS may be omitted and the PAKE protocol may be used as the main session key protocol, if necessary, as may occur, for example, when the devices are small hardware sensors that form the set of components of the Internet of Things.
[0144] Communication methods Tereon Data Services 214 provides full ACID guarantees via a coordinating transactor (a device or module that executes, manages, or controls all or part of one or more transactions) and is based on a key-value store with graph capabilities providing n+1 or greater redundancy and selective multi-site replication. Data Services 214 is encapsulated in Data) Domain Services which provide shared memory capabilities as well as zero-copy capabilities and unlimited read scaling, in-memory caching, and very high levels of record performance. This is maintained in a variable-sized data cluster followed by a large memory cache. In very unique circumstances, Data Services can be bypassed in favor of using the key-value store directly.
[0145] Data Services 214 provides high performance basic SQL style functions as well as graph processing capabilities that support functions such as currency flow analysis. Coupled with a highly performant modular communications architecture (providing platform efficiency and performance), Data Services 214 provides a highly efficient design that exceeded 2.8 million transactions per second in testing on commodity server hardware (with combined 10Gbps networking).
[0146] By implementing the following architectural priorities, a system can significantly reduce the number of kernel and process context switches required to process messages sent within and between systems.
[0147] a) Zero-copy networking can minimize transmission costs from the network edge to the service. b) User mode networking can minimize the transmission costs from the network edge to the service.
[0148] c) When serialization is necessary (mainly when crossing machine or server boundaries), highly efficient serialization is used with Protocol Buffers or Avro as opposed to higher overhead serialization like Simple Object Access Protocol (SOAP), which is abstracted at the edge of each server so that a given server can easily communicate with peer servers on other continents over the Internet, albeit at a lower level of performance and efficiency.
[0149] d) Servers can configure buffering thresholds that attempt to batch requests to minimize processing context switches and maximize cache coherency for a particular server. For example, if server A receives 10,000 requests within a 20 ms period, and the platform targets a 20 ms buffer window and needs server B's assistance for those 10,000 requests, it can batch the 10,000 requests into a single request and then flag a semaphore to queue an asynchronous message for server B. Server B can then quickly process the 10,000 requests and provide a single response to server A. This can be configured based on efficiency and maximum response time optimization.
[0150] In fact, by reducing the number of kernel and process context switches, the platform's performance levels have been significantly improved. Instead of many kernel and process context switches occurring per message, the Tereon model generates many kernel and process context switches per block of messages depending on the batch of messages being communicated. Tests have shown that using this model, the performance difference between the existing model and the Tereon model is significant, reaching over 1:1000 for some workloads.
[0151] However, modules and their benefits are not limited to a single system. For example, if Server A and Server B were on separate machines, the Tereon system could still use efficient serialization and batch processing. Whether this is combined with optional zero-copy or user-mode networking, the Tereon model greatly improves network and processing performance.
[0152] Testing has shown that these design elements have demonstrated local server-to-server operation at tens of millions of message requests and responses per second around trips (batch, shared memory modes) over ultra-high speed network wires (e.g., 10 Gbps bonding).
[0153] All such transactions are processed in real time and reconciled immediately, which has many advantages, especially in banking, IoT, healthcare, identity management, transportation, and other environments where accurate data processing is required. In particular, such systems do not currently reconcile transactions in real time. Instead, transactions are reconciled after a period of time, sometimes in batches. For example, financial transactions are typically batched with a separate query process that runs after hours. Using the Tereon system, banks can reconcile all financial transactions in real time in a way that was not possible before. As a result, banks do not need to maintain reconciliation accounts to cover financial transactions that are not accurately reconciled or have not yet been reconciled, because all transactions are reconciled as they are processed.
[0154] Transactions and Data Division All atomic activities in the Tereon system are transactions. A fundamental requirement of a system that supports ACID guarantees for transactions is that they either fail globally or succeed globally. This section briefly describes how this is accomplished, and details the access methods Tereon uses for transactions and data partitioning to mitigate the impact of partitioning on achieving ACID guarantees for transactions.
[0155] As mentioned above, each data operation within the Tereon platform is performed through a Tereon data service instance 214 (which itself can act as a set of microservices 410a). This is an extended service (oriented system) that is the only component of the system with direct data platform access, so all data operations must pass through it. Such data services are extended to perform parallel transactions within the system through the various data service instances that always have consistent read data using instance cache data MVCC (Multiversion Concurrency Control).
[0156] Data processing is performed via atomic messages to a data service instance, with the messages comprising the entire data job. For example, a job may include retrieving several records and attributes, updating or inserting data based on dependent data, or any combination of tasks. A data service instance executes as a two-phased commit transaction across all backing, transactional data stores.
[0157] The Tereon model ensures data consistency through the following techniques: a) Every set of read data has a version ID. Every record (update and dependent insert) verifies that this version ID is up to date against all relevant data as an optimistic transaction. This means that when three sources read a record to get various account attributes (e.g. permissions, balance, and currency data), there is a consistent version ID for this cluster of data. If any of these values are updated or dependent data is recorded (e.g. financial transfer), the version ID is checked again to see if it is the latest version, and if the records are different (currency assumptions changed, exchange rates changed, etc.), the record as a whole fails completely. Downstream services may re-read and evaluate if this changes the transaction in a critical way, if necessary. If not, the transaction is submitted again. If the transaction fails again, this is repeated until a configurable number of retries is reached, and a serious error occurs, which is highly unusual under normal circumstances.
[0158] In the vast majority of real-world scenarios, even with large transaction volumes and account diversity, failed optimistic transactions will not occur. In the rare cases, data will not be damaged and processing overhead will be kept to a minimum. This MVCC / optimistic model also fully protects against deleted records if the platform used is a permanent historical database (except for regulatory deletions required in exceptional circumstances).
[0159] b) The record to the platform for a given data partition (this is a separate concept from horizontal scaling of data services). Many data service instances read from and record to one data partition, and a single data service instance reads from and stores to multiple data partitions. All reading and recording occurs through a single master transactor instance 222, with one or more redundant operating backups as needed. However, only a single instance is active at any time. This ensures that transactional and causal validity is maintained under all circumstances (e.g., no skew during network partitions or brief communication delays). The transactor ensures that all optimistic transactions are valid and persistently refreshes the cache manager in the data service instance with the latest updates that are contextually significant to that instance.
[0160] c) Selective data partitioning Being constrained to a single transactor can potentially limit the scalability of very large Tereon instances (understanding that a single organization can manage multiple Tereon instances per region). Data partitioning is the concept whereby a Tereon Data Services cluster can partition data across transactors 222 or data stores 224 based on Tereon rules configured per domain. The Tereon platform currently supports the following partitioning rules for heterogeneous, multi-component hashing strategies:
[0161] i) Hash the target data for a given element or its ancestors (e.g., hash more precisely by parent records). A high-performance hash has the same cardinality as the number of partitions.
[0162] The system does not currently provide rebalancing, so in the current implementation the hashing must be done up front, even if a future implementation will provide rebalancing (partitions can currently be added using a multi-part rule that includes a hash by origin date / time).
[0163] ii) Data consisting of a hash of the targeted data for a given element or any higher-level element (e.g., by listed geographic region, by last name such as A-K or L-Z, by currency, etc.).
[0164] The data target hash supports alphanumeric, unicode, and other character code ranges, integer ranges, floating point ranges, and named sets.
[0165] iii) A combination of the above In an example implementation, the two letters A and B indicate two separate data sets common across a geographic region with the numbers 1 and 2 indicating two parts of the region. For example, a single partition rule supports a division between top level partitions 1AB and 2AB, such as geographic region, and then further supports a division between A and B subpartitions via account number hashing.
[0166] d) A single job executed through a single data service instance can traverse multiple data partitions, be completed with multiple transactions, and persist across multiple data storage nodes.
[0167] This presents obvious data integrity complications, but data integrity is guaranteed by binding all components of a transaction to a single two-phased commit wrapper, which ensures that the entire transaction for all persistent nodes and actors either completes or fails as a whole, providing the same version guarantees for everything.
[0168] The confluence of architectural designs results in a system that is fully transactionally safe, highly redundant, and horizontally and vertically scalable. Record transactions (which in many scenarios involve a small percentage of processing) are limited by the transactional necessity of a single transactor per partition, but the addition of rule-based partitioning (especially for superior data elements) provides the flexibility to scale the system to conceptually unlimited levels before considering branching instances.
[0169] Realization of Tereon data store The Tereon infrastructure processes over 1,000,000 ACIS-secured transactions per second. This is accomplished by abstracting or otherwise implementing a datastore layer 220 on a distributed database or databases 224 using a high performance key / value distributed database for the storage layer, along with separate read and record access channels 226. (This can be all the deeper levels from abstraction through Tereon Data Services to direct database usage for the storage layer.) Tereon's datastore usage and configuration is unique.
[0170] The data services layer communicates with the datastore layer through its tailored data exchange modules. The databases themselves do not need to provide any ACID guarantees that are handled by the datastore layer 220. They also do not need to provide graph functionality, as this would significantly slow down record processing. The datastore layer 220 provides the interface to the heterogeneous data layers, providing the interface functionality that the rest of the system requires. Thus, the write functionality provides a fast cell and column structure, while the read interface provides a graphical interface, allowing to traverse a distributed datastore in microseconds.
[0171] The Datastore Layer provides a SQL and graphical interface layer on top of the core datastore database and offers a number of key architectural advantages that distinguish Tereon. Each client instance (Tereon Data Services Instance) 214 hosts an in-memory / in-process database engine that contains a cached representation of all hot data for that instance. As a result, an instance hosts the database engine and a cached representation of all current transaction data, the state of each current transaction, and all of the different information regarding the instance's current state within the machine on which it is running or within different high speed memories of the machine or portions of its RAM.
[0172] This allows Tereon Data Services to facilitate many read-oriented tasks at extremely fast rates (millions of isolated queries per instance per second, where hot relevant data is cached locally), and magnitudes beyond the performance levels achieved are achieved by serializing external or non-machine requests to external database systems. If the data is not in the in-process cache, it is retrieved from the key-value store.
[0173] An MVCC version system is used to manage concurrency, and the data layer attributes ensure that data is never deleted (besides forced deletion for regulatory compliance), and the system retains a full history of all record changes during the life of the data system, allowing simple actions like "as of" queries, and auditing of all platform changes.
[0174] The data layer's write implementation uses a single shared transactor, and all data modifications are processed in a single, fast sequence. This minimizes transaction validity, consistency, and modification concurrency overhead, which are burdensome on many database platforms. The transactor design uses a hot-backup redundancy model. When a transactor process changes, it notifies all active query engines (which in this case reside in Tereon Data Services) and updates their in-memory caches as necessary.
[0175] The design provides microsecond latency for reads, writes, and searches regardless of the size of the data store. It also provides a modular architecture that allows components to be updated and replaced without impacting operation. The data store may be abstracted from existing implementations and substituted for other stores of Tereon Data Services.
[0176] If the datastore layer is configured to operate with pessimistic ACID guarantees 226, i.e., it takes an additional step to ensure that a record has been written before proceeding with the next transaction, this adds a short delay but provides absolute guarantees of ACID consistency and data integrity.
[0177] The advantage of this design is that it provides ACID guarantees, as no progress can be made until the data layer has confirmed that the record has been written and the transaction has been completed.
[0178] This means, for example, that problems caused by eventual consistency are eliminated for banking, payments, and other transaction types that must maintain causality. Designing with ACID guarantees also removes the need for reconciliation accounts to make up for shortfalls when the banking system discovers inconsistent processes. Real-time processing also means that the time delays that reconciliation processes in an eventually consistent system would incur are eliminated.
[0179] The design of this platform provides extremely high levels of redundancy and stability on commodity hardware, and excellent scalability (both vertically and horizontally). Theoretical concerns about possible limitations of transactional systems led to the creation of a separate platform with data services to overcome those limitations, but in many scenarios there is no need to use such a platform.
[0180] Lookup / Directory Services The Tereon system includes a directory service 216, which is a directory of credentials and information in the system that identifies what servers a user or device 218 is registered with or that provide a particular function, resource, facility, transaction type, or other type of service. The directory service stores a variety of different types of credentials for a particular user, allowing multiple authentication methods for a user 218, for example, a user 218 can be authenticated using their mobile number, email address, geographic location, primary account numbers (PANs), etc., and caches the data so that they do not have to authenticate each time.
[0181] The directory service 216 provides an abstraction layer that separates the user's authenticated identity from the underlying services, servers, and actual user accounts. It provides an abstraction between the credentials that a user 218 or merchant can use to access a service, and the information Tereon needs to perform the service itself. For example, in a payment service, the directory service 216 might simply link an authenticated identity such as a mobile number, a server address, and perhaps a currency code with the server address. There is no way to determine whether a user 218 has a bank account or which bank the user 218 uses.
[0182] The system architecture allows Tereon to offer a variety of new services or features that easily go beyond the scope of existing systems. The Tereon system architecture is useful because it is scalable and allows for redundant systems. Bank core systems tend to offer modules dedicated to individual channels, for example card management, e-commerce, mobile payments, etc. This reinforces silos and increases the complexity of their IT systems. This complexity is one of the reasons why banks are unable to regularly update their services and systems.
[0183] Tereon is designed to support all devices and all use cases with a highly configurable and customizable modular architecture. At the heart of this is the above mentioned SDASF 104, high level abstraction, and business rules engine 106. It is this combination of extensible frameworks that enables Tereon's flexibility.
[0184] Tereon will offer and support a variety of transaction types using standard carrier-grade systems by its operators. Tereon will support all transactions, regardless of whether the transaction requires authentication or not.
[0185] Special Process Special processes 208 ideally leverage the functionality of data services. However, there are instances where unique requirements do not justify modifying or extending the core data services, so data libraries are leveraged within the special processes to bring in data directly. For example, this may include graphical functional processes such as anti-money laundering (AML), customer relationship management (CRM), or enterprise resource planning (ERP) functions.
[0186] Multiple Services Because each service is a module, Tereon's modular architecture can support various types of services and devices. For example, in payments, this architecture allows Tereon to support multiple payment types and devices including banks, charge cards, credit services, credit unions, debit services, employee schemes, ePurse, loyalty schemes, membership schemes, microfinance, prepay, student services, ticketing, SMS notifications, HLR lookup, etc.
[0187] Multiple end-point devices Tereon's modular architecture supports any endpoint device capable of direct or indirect communication, including magnetic stripe cards, smart cards, feature phones, smartphones, tablets, card terminals, point of sales (POS) terminals, ATMs, PCs, display screens, electronic access control, e-commerce portals, wristbands and other wearables.
[0188] Multiple databases The modular structure has the distinct advantage that the system is not limited to one database, instead various databases can be connected with each module specific to the database in question, allowing the use of a specific database for a specific purpose, or the combination of data records across multiple disparate databases.
[0189] The implementation of the Licensing Subsystem 210 is novel in its use of a certificate authority for licensing purposes, in addition to the authorization and authentication benefits it provides. The most common implementation patterns for modular mission-critical systems are that each module uses simple authentication with a shared database instead of trusting each other's assertions, or delegates to an individual license server (subject to performance and stability overhead) at the time of each connection establishment. In Tereon, the Licensing Subsystem can ensure that connections between modules are inherently secure and have reliable and verified metadata about actors with minimal performance and stability overhead.
[0190] This implementation also limits the scope of potential vulnerabilities in the instance of a license server compromise. In a traditional deployment, such a compromise would merit a major rebuild of all components. In the Tereon model, there is a time-based exposure (if not protected by a hardware security module) that requires a new intermediary signing certificate. All existing certificates granted with pre-compromise are stale and can be updated to a normal schedule. New certificates are granted under the new permissions and other fraudulent certificates are rejected as compromised. This exposure window control helps in worst case scenarios. Any data held by the license server is completely unauthorized information outside of the signing certificate's private key, which is ideally stored in the hardware security module.
[0191] The Tereon design also allows for endpoint devices, such as mobile or IoT devices, to be combined with small Tereon servers that communicate with other Tereon servers as part of such a server network. They would communicate with the Tereon License Server 210, and possibly with one or more operator-run Tereon servers, to collect data and coordinate processing. Nevertheless, the distinction between endpoint devices and Tereon servers (all distinctions based solely on the use cases in which the devices and servers are placed) is an abstract one.
[0192] Hash Chain One of the major drawbacks of blockchain is that it stores an audit of all previous transactions (i.e. it is possible to determine the transaction history within the blockchain which can be used for authentication), which means that the blockchain access method cannot scale infinitely as the size of the blockchain will eventually become too large to be managed in a realistic time frame, while the size of each block limits the maximum transactions per second that the blockchain can register.
[0193] The second disadvantage is that the transaction history is available to anyone with access to the blockchain, and therefore can verify who the transaction parties are, thus presenting significant privacy and regulatory concerns for using blockchain in any meaningful transaction where privacy and / or confidentiality are paramount requirements.
[0194] A further disadvantage is that blockchain cannot hash the outcome or final record of a transaction, and therefore cannot verify the actual process or steps of the transaction itself.
[0195] The hash chain disclosed herein seeks to overcome the above problems by using a specific hash access method to keep records private between transacting parties and provide a distributed authentication network that includes all Tereon users (regardless of whether they are operating on a public or private network).
[0196] This is accomplished through the persistent construction of a distributed chain that operates in real-time across public and private networks without revealing the content of the underlying communications to third parties. This contrasts directly with the standard model of a distributed hash or ledger, where all parties report and accept the content of all communications regardless of whether they are a party to that communication or not.
[0197] Using a protocol where hash chains include zero-knowledge proofs, each step of a transaction and the information or results produced by the steps of the transaction can be authenticated.
[0198] The implementation may occur where parties to a communication generate the same intermediate hash, or where parties generate unique intermediate hashes for the same communication. This structure also allows parties to migrate to new hashing algorithms as existing algorithms are deprecated without affecting the integrity of the hash chain. This contrasts directly with the difficulty of updating or upgrading algorithms used in existing live solutions such as blockchain.
[0199] Tereon generates a hash audit chain for each side of a transaction (account), where: Tereon generates a hash for the record and stores the hash for the record. Tereon generates the hash when the action of creating a record is completed, because it uses the step of creating the record and the information or result generated from the step.
[0200] Tereon uses the hash for the previous record as part of the data for the current record, and The initial hash of every record chain can be a random hash that contains the server's signature, the date and time Tereon generates the hash, and optionally a random number.
[0201] If this record is for an action involving two or more parties, and each party must have a record of its aspect of the action, Tereon will do the following for each action:
[0202] · Share a hash of each party's record with the other party or parties. · That hash is used to form part of the receiving party's record for Tereon which generates a record hash.
[0203] Generate an intermediate hash of the record that includes hashes from other parties or parties. Share the relevant intermediate hashes with the other parties so that each party has a hash that encapsulates some part of the other party for each action.
[0204] · Include the intermediate hash in the action record. Generate a final hash for the action to store and use as part of the next record, and Associate each transmitted hash, or intermediate hash generated by the protocol using zero-knowledge proofs, with the sender’s ID or Tereon number.
[0205] Tereon can provide the ACID guarantees and real-time session transaction and processing speeds required for this, as explained below, and the widespread adoption of blockchain means that developments in this area are not without consideration.
[0206] Once a transaction is completed, the blockchain hashes a record of the transaction. There is no guarantee that the record propagated to the blockchain is in fact the authentic record of the transaction itself. The blockchain is limited to this approach because it relies on a majority of its operators acting honestly, as the underlying hashing structure is designed for the collection of static data, not dynamic and real-time transactions. The blockchain itself is further limited in that it can only provide eventual consistency. ACID consistency is determined not by the chronological order of transactions, but by the order in which those transactions are incorporated into blocks, and by a consensus model for managing forks within the blockchain when two or more blocks are found to contain slightly different sets of transactions.
[0207] FIG. 5 shows the dendritic nature of a hash chain that includes four accounts, 502, 504, 506, and 508. The accounts may be on the same server or on separate servers. Each system supports one or more servers, and each server supports one or more accounts. Where the accounts are located is irrelevant. FIG. 5 also shows five transactions that occur between pairs of accounts. There are two transactions that occur between accounts 502 and 504, two transactions that occur between accounts 502 and 506, and one transaction that occurs between accounts 506 and 508. In the diagram, each box is a step with respect to the account at the top of the column. Each step involves a search within that account, or an action or transaction not visible to that account, such as another account or system not visible to that account. It does not matter what these transactions or actions are. What is important is that they include some Tereon system record in this audit.
[0208] In step 510, the Tereon system obtains the previous hash h502 for this account. As described above, the initial hash is a random hash with the server's signature, the date and time Tereon generated the hash, and optionally a random number. Tereon adds the hash to the record for the transaction or action that occurred in step 510, and then uses it as a seed to calculate the hash h512 for this transaction. The record at this step includes h502 and h512.
[0209] In step 512, the system exchanges hash h510 with the server holding account 504. It adds the hash h504 for this transaction to the record for account 504, generates an intermediate hash h512i, adds it to the record, and then exchanges it with intermediate hash h514i (generated in step 514, as described below) from account 504. It then adds this hash to the record to generate hash h512.
[0210] Hash h512 further includes information that validates the hash chain from account 502 to step 512, and from account 504 to the intermediate step of step 514. Records include h510, h512i, h514i, h504, and h512.
[0211] In step 514, the system exchanges hash h504 with the server holding account 502. It adds hash h510 from account 502 to the record, generates intermediate hash h514i, adds this to the record, and then replaces this with intermediate hash h512i from account 502. It then adds this hash to the record to generate hash h514.
[0212] This chain further includes information that has enabled a hash chain from account 502 to step 512 and from account 504 to step 514 . This sequence is followed for additional transactions between accounts 502, 504, 506, and 508 to generate hashes for the transactions based on the exact same scheme as described above. For example, in step 534, the system takes the previous hash h528 for account 502 generated in step 528, appends it to the record for the transaction or action (not visible) that generated the audit record, and generates a hash h534 for this transaction. This chain includes information that enabled a hash chain for account 502 up to step 534, account 504 up to step 526, account 506 up to step 530, and the intermediate hash from account 508 used to generate h530 in step 530, including records h534 and h528. Tereon generates hash h528 in step 528 from the record that includes h530i generated from h524 in step 530. Hash h524 includes information that validated account 508 from account 508 through the intermediate hash used in step 524 to generate h524.
[0213] Reconciliation If an impostor has altered the record of a previous transaction, adjustments can be made for the first and last "N" transactions to prevent the transaction from being executed. Thus, for example, before Tereon performs the transaction presented in step 522, it can first recalculate the hashes for step 516, and possibly step 512, etc., up to the previous "N" transactions for account 502. The audit trail has enough information to recalculate the final hash value for the transaction. Similarly, the system holding account 504 may recalculate the hashes for steps 526, 520, etc. Tereon does not need to recalculate all the hashes for account 506 for the transaction of step 522.
[0214] In a hash chain, if any of the recorded hashes do not match the recomputed hash, this means that the record has been changed without authorization, and the operator can immediately investigate the issue and / or block further transactions.
[0215] System Hash Chain A system hash may also be added to each record, which is a hash of the record regardless of whether the action is related to the account to which the hashed record belongs, where the seed would be the hash of a previous action on the system. If the system hash is then added to the hash chain within each account, a system-wide hash chain is provided.
[0216] Figure 6 illustrates the arborescent nature of a hash chain containing two accounts 602 and 604 on the same system, with a 'system account' 606 that records all system events. The system generates a new hash of the record for every action that generates it, regardless of where the record resides. There are system hashes h606, h608, h612, etc.
[0217] Figure 6 shows the arborescent nature of a hash chain containing two accounts 602 and 604 on the same system, with a "system account" 606 that records all system events. The system generates a new hash of the record for every action that generates the record, regardless of where the record resides. h606, h608, h612, etc. are system hashes.
[0218] In step 608, Tereon generates a hash of the record of the unseen action or transaction in account 602 that triggered an entry in the system's audit records (the record for account 602 contains the previous record hash for that account, hash h602), and uses h606 to set the new system hash h602. The system then records this hash against the record for the transaction, and in step 610 calculates hash h610 for account 602.
[0219] If the computing power of the system allows, this can use a strong transformation for the system hash that mirrors the behavior of the account hash. In step 610, Tereon exchanges hash h602 with hash h606 from system account 606. It adds hash h606 from system account 606 to its record, generating an intermediate hash h610i. It generates this after completing an unseen action or transaction with account 602 that triggers an entry in the system's audit record and adds the hash to the record. Tereon then exchanges this intermediate hash with intermediate system hash h608i. It then adds this and h608 to its record to generate a new account hash h610.
[0220] In step 612, Tereon exchanges hash h608 generated in step 608 for accounts 602 and 604. It adds h610 and h604 generated in step 610 to its record to generate an intermediate hash h612i. It exchanges accounts 602 and 604 with their intermediate account system hashes h614si and h616si, and the intermediate hashes h614i and h616i corresponding to accounts 602 and 604, respectively. It then generates a new system hash h612. The system then records this hash.
[0221] In step 614, Tereon exchanges the hash h610 generated in step 610 with the system account 606. It adds the hash h608 from the system account 606 (generated in step 608) to the record to generate an intermediate account system hash h614si. It generates a hash after completing the transaction with account 604 (exchanging the intermediate transaction hashes h614i and h616i), adds this to the record, and then exchanges this with the intermediate system hash h612i. It then adds this and h618 to the record to generate the account hash h614.
[0222] In step 616, Tereon exchanges hash h604 with system account 606. It adds hash h608 from the system account to its record, generating an intermediate account system hash h616si, which it generates after completing a transaction with account 602 (and exchanging intermediate transaction hashes h614i and h616i), adding the hash to its record, and then replacing it with the intermediate system hash h612i. It then adds this and h608 to its record to generate the account hash h616.
[0223] In step 612, one option is for the system to send the intermediate system hash h614si to account 604 and the intermediate system hash h616si to account 602. This represents the final record hash for these accounts, providing an additional layer of authenticity since h614 and h616 contain records for the three intermediate system hashes h614si, h614si, and h612i.
[0224] The system hash chain includes not only the hashes of both sides of each individual transaction, but also the hash chain for the entire transaction, strengthening the hash chain significantly.
[0225] If Tereon manages transactions between accounts on different systems, the process is similar for steps 608 and 610 for each of those systems.
[0226] License server hashes Hashes are related to the hashes generated between individual Tereon systems. As such systems interact, they can join a hash tree that contains verified information for all transactions in those systems. However, it only grows as fast as such systems interact. Systems can go a step further and build another layer that ensures that each server can immediately join the global hash tree. This completely distinguishes blockchain from hash chain.
[0227] When a blockchain operator sets up a private blockchain, that blockchain operates separately from all others. The overall speed increase is due to users not being able to rely on the larger blockchain network to verify the validity of their transactions, at the expense of any security that could otherwise be provided. One of blockchain's claims to security is that an attacker would have to compromise many of the blockchain network's nodes to compromise security (compromising around 25-33% of the nodes is enough to compromise the blockchain). A single private blockchain by definition reduces that number to one.
[0228] Using a hash chain, a private Tereon server or network can still benefit from the hash chain generated by public Tereon servers and networks. Operating a private Tereon server or network does not mean that the operator must compromise the authentication strength of the Tereon system, since the system is still a member of the global hash chain. It simply means that transactions (other than those related to the license server) will be kept completely private to the system.
[0229] To achieve this, all servers must interact with the license server, regardless of whether they interact with other Tereon servers or not. A Tereon server may act as a closed-loop server and only interact with other Tereon servers within its loop if that loop consists of two or more servers.
[0230] By adding the license server hash, all servers join the global server hash chain as soon as they interact with the license server (which must be done basically daily). The license server hash is essentially generated by a two party transaction between the Tereon server and the license server. Apart from not affecting the basic data transactions between Tereon servers, the license server transaction also contains information that the system hash for each server is derived from the license server hash and vice versa.
[0231] Figure 7 illustrates the arborescent nature of license hashes. In a simple example, system server 702 is a closed loop system that interconnects system servers 704 and 706. All three must periodically interact with license server 708.
[0232] Upon initial interrogation with the license server 708, each server generates an initial hash from its public key, the date and time the server was first licensed, and a random set of data.
[0233] In step 710, Tereon generates the hash h708, adds it to the record, and replaces it with the intermediate system hash h712i from server 702 to generate an intermediate license hash h710i. It then adds this hash to the record, which then generates a license hash h710 which it adds to the record.
[0234] In step 712, Tereon generates hash h702 to generate an intermediate system hash h712i, adds it to the record, and replaces it with the intermediate license hash h710i from the license server 708. It then adds this hash to the record and generates a system hash h712 which it adds to the record.
[0235] In step 712, Tereon generates hash h702 to generate an intermediate system hash h712i, adds it to its record, and replaces it with the intermediate license hash h710i from the license server 708. It then adds this hash to its record and generates a system hash h712 which it adds to the record.
[0236] In step 716, Tereon generates the hash h704 and exchanges it with the intermediate license hash h714i from the license server 708 to generate an intermediate system hash h716i. It then adds this hash to its record and generates a system hash h716 that it adds to the record.
[0237] In step 718, Tereon generates an intermediate license hash h718i, adds it to its record, and replaces it with the intermediate system hash h720i from server 706. It then adds this hash to its record and generates a license hash h718 which it adds to the record.
[0238] In step 720, Tereon uses hash h706 to generate an intermediate system hash h720i, which it adds to its record, and replaces it with the intermediate license hash h718i from the license server 708. It then adds this hash to its record and generates a system hash h720 which it adds to the record.
[0239] A three license server to Tereon server transaction would yield the following results: The hash h712 generated in step 712 contains information that verifies the following conditions:
[0240] -Hash chain of license server 708 up to intermediate hash h710i -Hash chain of server 702 up to hash h712 The hash h716 generated in step 716 contains information that verifies the following conditions:
[0241] -Hash chain of license server 708 up to intermediate hash h714i -Hash chain of server 702 up to intermediate hash h702ii -Hash chain of server 704 up to hash h716 The hash h720 generated in step 720 contains information that verifies the following conditions:
[0242] -Hash chain of license server 708 up to intermediate hash h718i -Hash chain of server 702 up to intermediate hash hk702ii -Hash chain of server 704 up to intermediate hash h716i -Hash chain of server 70 up to hash h720 The hash h718 generated in step 718 contains information that verifies the following conditions:
[0243] -Hash chain of license server 708 up to hash h718 -Hash chain of server 702 up to intermediate hash hk702ii -Hash chain of server 704 up to hash hk704i -Hash chain of server 706 up to hash h720 Thus, the license and system hash contain information that allows a transaction to be verified on all servers in the network, regardless of whether those servers are interconnected or operate in a closed loop.
[0244] Tereon can achieve a similar layer with a lookup directory service that operates in a similar manner to the hash chain created by the license service. Off-line transactions With this approach, offline transactions can now have the same validity as online transactions, since the persistent communication links between the devices and their servers must be eliminated. Thus, devices such as sensors, mobile payment terminals, and others can communicate with each other and connect with their servers at regular intervals to download and upload data. The system can operate smoothly between connected and disconnected environments.
[0245] The hash chain allows a device to use business rules to determine whether it is involved in offline transactions and to validate and audit transactions during the time that it cannot communicate with the servers. The devices simply reconcile their audit and transaction records with those servers when they are again connected to those servers.
[0246] 8 shows an example of a hash chain that includes four devices that are temporarily offline from the Tereon server of the four devices, three of which, 802, 804, and 806, are made visible (a fourth device, 808, interacts with the chain at step 828).
[0247] To facilitate offline transactions between devices, the devices themselves generate a hash for each transaction they participate in. When a device comes back online and communicates with the server, it sends the hash for that transaction to the server.
[0248] If the device initiating the transaction is offline, it generates a hash for the transaction and stores it. It also sends it to the other device (the device it is transacting with), which sends it to the first device. This is accomplished in the same manner as the hash chain described above. The devices can communicate via bidirectional channels such as Bluetooth, NFC, local Wi-Fi, etc. They also post this code for each transaction stage on a screen for different parties to read. Each device also sends a signed and encrypted copy of its transaction record to the other device, where the signature also includes the server to which the record is to be delivered. Only the server to which the record is to be delivered can decrypt the record.
[0249] When a device regains communication with its Tereon server, it sends an encrypted record of this offline transaction and its associated hashes to the server. It also sends copies of other transactions it has, such as records from the other side, to the server, which then sends those records and their associated hashes to the server where the other device is registered. Each device generates its own unique internal transaction number (such as one generated by a monotonic counter) that identifies this part of the transaction. Also, when a transaction is online, the server connected to the device generates a unique transaction number that both the device and the server use.
[0250] Devices combine an internal transaction number with a date / time stamp, information about device clock skew, and other information to maintain the causality of each transaction. As their servers receive the transaction information, they can reconstruct the order of transactions, maintaining the causality of both online and offline transactions for all devices.
[0251] 8, in step 812, device 802 hashes the transaction record, including hash h802 from server 810, the previous record hash, and hash h810, to generate h812. It then communicates this hash to server 810, where it forms part of the record used to calculate h814 in step 814. Device 802 is connected to this Tereon server 810, meaning it is now online. In step 814, Tereon uses the previous hash h810 for server 810, adds this and h812 to the record, and then calculates h814. The record includes h810, h812, and h814.
[0252] If the operator has configured Tereon to include a system hash, it adds this to the record before computing hash h814, as described above. The record may then include h812, h810, any intermediate system hashes if relevant, and h814.
[0253] In step 816, device 802 is offline and cannot connect to server 810. It transacts with device 804, which is also offline from its respective Tereon server. Devices 802 and 804 follow the hashing procedure described above to generate intermediate hash h 816 from device 802, intermediate hash h 818 from device 804, hash h 816 from device 802, and hash h 818 from device 804 in step 818. Devices 802 and 804 sign their hashes with their offline public keys and communicate them to the other devices along with encrypted copies of the records for that transaction. This is the first offline transaction for device 802 (since it has lost contact with server 810) and the first offline transaction for device 804 (since it has lost contact with the server). The administrator configures the system to allow applications to send up to the last n transactions to unique devices transacting offline.
[0254] This sequence repeats for further transactions in the chain between device 802 and device 804, and between device 804 and device 806. For such transactions, devices 802 and 804 do not need to exchange hashes and records for previous transactions, since they each already have a copy.
[0255] The device 802 continues to operate in this manner until it re-establishes contact with its server 810 in step 830. The device 802 uploads all of the encrypted records of offline transactions and their associated hashes (h816, h822, and h826, as an example, generated in steps 816, 822, and 826, respectively). It also uploads the encrypted transaction records and hashes it has for devices 804, 806, and 808, which the servers store and upload to the servers corresponding to each device 804, 806, and 808. The server 810 registers the records of hashes from devices 804, 806, and 808 and this upload with the transaction and generates hash h832 in step 832. The device 802 clears the records of hashes from devices 804, 806, and 808 and their respective transaction records and generates hash h830 in step 830.
[0256] Device 802, in step 820, maintains a hashed and encrypted record of the transaction between devices 806 and 808 generating hashes h 820 and h 808. In this example, since it is not known how many offline transactions have occurred, h 808 is used to reference the hash for device 808 that was generated for that transaction.
[0257] Server 810 reconciles the offline records it receives from device 802 with those it receives from devices 804, 806, and 808, as well as any other servers that include those transactions. Server 810 will know from what servers it received records because these correspond to the servers to which records of transactions involving device 802 were sent. Device 802 does not expect to receive records from device 808, since device 802 is not transacting with device 808. If devices 804 or 806 transact with offline devices connected to other servers, server 810 may receive additional records from those other servers.
[0258] The server 810 uses date and time stamps on the transaction records and signatures to order and number the transactions and display them as offline transactions.
[0259] The offline mode presents various variants. The first consists in not using an intermediate offline hash, but simply using a hash for each device's previous transaction. This loses the certainty of the hierarchy, but works well. The second consists in generating a dedicated device hash for offline transactions. This simplifies online transactions slightly, but still loses the certainty of the hierarchy. The third variant consists in simply signing all records with the device key, rather than signing the offline transaction records with a specific offline public key. Both the server and the device can see which transactions are online and offline, since they are recorded in the account audit trail. However, running a separate key and a set of transaction numbers for the device makes it easy to show offline and online transactions.
[0260] A fourth variant is that when receiving records of offline transactions from connected devices, each server informs all servers to which those records apply so that they can expect records from that server. For example, in the offline diagram shown in FIG. 8, assume that device 804 later connects to the server and device 806 transacts with other devices (not shown). When device 804 connects to the server, the server sends records for device 802 to server 810. Device 804 does not transact offline with other devices and does not have offline records for other devices. Meanwhile, server 810 sends records for device 804 to the server corresponding to device 804 and informs the server so that it can expect to receive a copy of the same records from device 806 (which device 802 communicates to device 806 during the transaction in steps 826 and 828). Similarly, when device 806 connects to that server, that server will send records for device 802 to server 810, for device 804 to the server serving device 804, for device 808 to the server serving device 808, and so on for the other devices to each of the servers. This also informs both the servers serving devices 802 (server 810) and 804 to expect records from the servers serving the other devices.
[0261] Using hash chains does not add any additional overhead to Tereon: an action rarely involves more than two parties, and is generally a one-to-many send which is itself a collection of one-to-one sends, and a many-to-one send is generally a series of one-to-one sends which are simply a collection of actions between two parties.
[0262] Amending record When a user modifies a record, Tereon does not overwrite the original record. Instead, Tereon simply generates a new record containing the modified record, and this is the version Tereon shows until the record is modified again. Modification is an action. It happens with all financial and transactional records (the result of a transaction, such as a payment), which effectively modifies the result of a previous transaction. It also happens when an operator uses a subset of Tereon to manage other record types, such as email, medical records, etc. This allows Tereon to keep a copy of each version of a record.
[0263] Situations may arise in court, or in the operation of law generally, where an administrator requires a record to be completely erased or the original record to be modified. In such situations, Tereon deletes or modifies the contents of the original record, and possibly the contents of related records. Tereon can accomplish this without invalidating subsequent hashes.
[0264] When Tereon deletes or modifies a history record, the following occurs: Before Tereon deletes or modifies a record, it verifies that the record has not been modified or changed, regenerates the hash of the record, and records the regenerated hash.
[0265] · Record the details of the record that was deleted or modified, and the reason for the deletion or modification, in new fields of the original record. · Add the deletion or modification of the relevant fields in the record, and the date and time of the deletion or modification.
[0266] Generate a new hash for that record. Record the new hash. By following this order, Tereon does not need to modify the hash chain in any way. All hashes of valid records generated from the original hash of the deleted or modified record are valid. The system hash contains the new hash of the deleted or modified record since the deletion or modification is an action. In this way, fraud can be easily identified by finding all recorded hashes that do not match the recomputed hash.
[0267] Hash chain with zero-knowledge proof knowledge proofs) Hash chains provide an additional layer that allows both sides of a transaction to prove to the other that they have hashed the records in question. This is done by including a key exchange algorithm within the hash chain that allows one party to prove to the other party (the verifier) that the hash of a record is the actual hash of that record.
[0268] Any algorithm that allows two parties to negotiate a common key can be used here, it is not necessary to use zero-knowledge proofs. However, a password authenticated key exchange (PAKE) algorithm that uses zero-knowledge proofs is the most efficient to use here. Using the correct PAKE protocol and zero-knowledge proofs at the intermediate steps means that the parties will generate the same intermediate hash, so there is no need to exchange hashes.
[0269] Parties can go even further using algorithms like the PAKE algorithm, which allows both sides to generate the same hash using zero-knowledge proofs. By using zero-knowledge proofs, which can contain and use the information that makes up the transaction to generate a "proof", both parties can generate the same intermediate hash. This means that they do not need to exchange those intermediate hashes with each other. This also means that the steps of generating the records and information, and the results that arise from those steps, become components of the hash chain process. When more than two parties participate, Tereon uses a group variant of the protocol and zero-knowledge proofs to allow all parties to generate a shared hash.
[0270] PAKE algorithms that ensure the parties produce the same hash typically involve two or three passes of information between the parties before they can produce the intermediate hashes. If the transaction requires only two steps to complete (e.g., request and accept / verify), the parties produce only one intermediate hash. If the transaction requires three steps and the algorithm produces the hash in two passes, the parties exchange four sets of information over two passes of three, producing two hashes (the first hash after the first two passes in the transaction, and the second hash after the third pass is repeated).
[0271] An example of such a zero-knowledge proof is the Schnorr NIZK proof, which can be easily extended by adding additional information to all of the information transmitted as part of the proof and used to generate the hash that is part of the proof, as disclosed in the specification for Schnorr NIZK proofs.
[0272] Also, other methods can be used, such as adopting a method for generating a shared key in the SPEKE (simple password exponential key exchange) protocol, the scheme of which is clear from the above.
[0273] It is also straightforward that the key exchange protocol can be extended so that the parties generate a shared key based on transaction data, in other words, not simply illustrated here for the sake of brevity.
[0274] To generate the shared key, the parties simply generate a hash of the shared key, which contains information that can be used to validate the transaction information because that information was used in the processor that generated the shared key and the hash.
[0275] Transaction in two stage An example illustrating how this works is shown in Figure 5, which shows the arborescent nature of a hash chain containing four accounts 502, 504, 506, and 508. The accounts may reside on the same system or on separate systems. It does not matter where the accounts reside. The transaction at steps 512 and 514 requires two stages.
[0276] Two pass PAKE In a first pass, at step 512, account 502 takes the account's previous hash h 510 generated in step 510 and adds it to the first stage transaction information to construct an initial zero-knowledge proof, which it communicates to account 504. The zero-knowledge proof involves the first stage transaction information and the information that constitutes the hash h.
[0277] In the second pass, account 504 takes its previous hash h504 and adds it to the second-stage transaction information to construct a second zero-knowledge proof, which it communicates to account 502. The second zero-knowledge proof entails the second-stage transaction information and the information that constitutes hash h504.
[0278] Accounts 502 and 504 independently construct hash h512i-514i, which is an intermediate hash of both accounts. The two accounts 502 and 504 add this hash to their records. Account 502 generates a hash h512 of the transaction record in step 512, and account 504 generates a hash h514 of the transaction record in step 514.
[0279] Three pass PAKE In this example, in steps 512 and 514, the transaction takes two steps using the PAKE algorithm that allows the parties to construct a common hash after three passes.
[0280] The first and second passes are performed as described above. In the third pass, account 502 takes the information that account 504 sent in the second pass, constructs a third zero-knowledge proof with that information, and sends it to account 504. The third zero-knowledge proof also includes the second-stage transaction information and information that constitutes the hash h504.
[0281] Accounts 502 and 504 independently construct hashes h512i-514i. The two accounts 502 and 504 add hashes to their records. Similar to the two-pass PAKE access method, account 502 generates a hash h512 of the transaction's record in step 512, and account 504 generates a hash h514 of the transaction's record in step 514.
[0282] In both cases, the chain contains information that verifies the chain of hashes from account 502 to step 512 and from account 504 to step 514. Both accounts 502 and 504 contain intermediate hashes h512i, 514i and their hashes for their records. However, the intermediate hashes here are subtly different from those exchanged between the systems in the previous example that did not use zero-knowledge proofs. Here, the intermediate hash is a hash of the transaction between accounts 502 and 504, and is therefore shared by both accounts 502 and 504. The hashes are hashes of the transaction and are generated as part of the transaction. They occur contemporaneously with the transaction. Hash h512 is a hash of account 502's record of that transaction and contains private information to it, while hash h514 of account 504 is a hash of its record of the transaction. Thus, accounts 502 and 504 can attest to both the actual steps in the transaction between them and the record of that transaction.
[0283] Transaction in three stages As another example using FIG. 5, assume that in steps 528 and 530 the transaction involves three separate steps instead of two.
[0284] Two pass PAKE In the first pass, account 502 takes its previous hash h522, generated in step 522, and appends it to the first stage transaction information to construct a first zero-knowledge proof, which it then sends to account 506. The zero-knowledge proof accompanies the first stage transaction information and the information that constitutes the hash h522.
[0285] In the second pass, account 506 takes its previous hash h524 generated in step 524 and appends it to the second-stage transaction information to construct a second zero-knowledge proof, which it then sends to account 502. The second zero-knowledge proof entails the second-stage transaction information and the information that constitutes hash h524.
[0286] Although accounts 502 and 506 can independently construct the shared hash, hashh528i530i, because the parties construct the shared hash after the second pass of the PAKE algorithm, there is still a third step in the transaction that must be performed.
[0287] In this example, the system simply runs through the second set of passes using the PAKE algorithm (starting with the third phase of the transaction). The second pass of the second set of passes may simply use random data. This could also be followed by repeating the last phase, similar to using a three-pass PAKE with a two-phase transaction.
[0288] In the latter case, a third pass (the first pass of the new PAKE algorithm) is performed, taking h528i530i signed by account 502, adding it to the third stage transaction information, constructing a third zero-knowledge proof, and sending it to account 506. A fourth pass (the second pass of the new PAKE algorithm) is performed, taking h528i530i signed by account 506, adding it to the third stage transaction information sent by account 502, using that information to construct a fourth zero-knowledge proof, and sending it to account 502. Accounts 502 and 506 may independently construct hash h528i2530i2, which is the second common hash generated for this transaction, and is the hash of the transaction between accounts 502 and 506 since it includes all three stages of the transaction. Both accounts 502 and 506 add this hash to their records. Account 502, in step 528, generates a hash h528 of the record for this transaction, and account 506, in step 530, generates a hash h530 of the record for this transaction.
[0289] This sequence is performed for additional transactions between accounts 502, 504, 506, and 508 to generate a hash for each transaction in exactly the same manner as described above.
[0290] Three pass PAKE The first and second passes are performed as described above. In the third pass, account 502 constructs a third zero-knowledge proof using the information that constitutes the third-stage transaction information and sends it to account 506. The zero-knowledge proof accompanies the information that constitutes the third-stage transaction information.
[0291] Accounts 502 and 506 independently construct hashes h528i-h530i. Both accounts 502 and 506 add this hash to their records. Account 502 generates a hash h528 of its record for this transaction in step 528, and account 506 generates a hash h530 of its record for this transaction in step 530.
[0292] As an example with respect to FIG. 5, the system uses zero-knowledge proofs to generate intermediate or transaction hashes, where hash h530 contains all of account 502's hashes h528i, all of account 504's hashes h526i, all of account 508's hashes up to the intermediate or transaction hash for account 508 that was generated when account 506 generated h524, and all of account 506's hashes verified by h530. However, while it verifies all hashes in the transaction network, account 506 only holds transaction records for transactions that have been entered into other accounts, systems, or servers. It knows nothing about the contents of the transaction records for transactions between accounts 502 and 504, even though that hash contains information that account 502 or account 504 can use to verify the hashes of those transactions.
[0293] What is important is that the algorithm used by all of the parties independently generates the same intermediate hash using the steps the parties exchange to affect the transaction. Thus, the transaction that creates the record becomes a component of the hash chain process, and the process of generating a hash chain entry is the same as the process that affects the transaction. Another way to look at it is that the transaction generates a hash as part of the transaction, and that hash and the information that goes with it becomes an audit of the transaction. They are one and the same. With blockchain, the initiator of the transaction completes the transaction and later submits that record to the blockchain for auditing. This adds another step to the process without being integrated into the transaction.
[0294] Once the transaction itself becomes a simultaneous component of the audit trail that the hash chain provides, it is not possible to have a transaction whose details are not captured or verified by the audit trail. Many audit trails are "after the event" in that the nearly completed transaction record is communicated to the audit system after the transaction is completed. In such cases, the record received by the audit may not be identical to the record generated by the transaction. Thus, computer records are usually considered hearsays. Integrating zero-knowledge proofs with the right PAKE or similar protocols means that the audit trail is generated by the transaction, and the transaction and its record become part of the audit trail. This has significant implications for real-time transactions, as they are reported in real-time.
[0295] The process of constructing a hash using zero-knowledge proofs may be applied to any scenario of generating a hash in a hash chain. It may be used for the system hash, license server hash, and offline hash illustrated by FIG. 8. Importantly, the hash includes transactions between two or more entities, regardless of whether the entities are parties, devices, or systems. The process does not preclude the use of standard hashes. Thus, one system may use hashes generated using zero-knowledge proofs for transactions between accounts, regardless of whether the device is online or offline, but may use standard hashes for the system hash and license hash. A second system may use zero-knowledge proofs for all hashes, while a third system only uses standard hashes.
[0296] Multiple pass PAKEs with multiple transaction stages The above example is a method for enabling both sides of a transaction to generate a shared key using a two or three-stage PAKE and a two or three-stage transaction, and the system is not limited to this example. In fact, the same method is effective for a system that supports transactions that include multiple stages using a PAKE that requires different passes. However, the system simply uses as many PAKE runs as necessary to cover all stages of the transaction. This involves repeating the final step multiple times to generate the PAKE passes required to generate the final shared key, generating a transaction hash.
[0297] System hash chain with zero knowledge proofs Returning to Figure 6, a hash chain is shown that can use all of the hashes generated using zero-knowledge proofs and classical hashes. The figure shows two accounts 602 and 604 on the same system 606, along with system hashes h606, h608, h612, etc. The system generates a new hash of the record for every action that generates the record, regardless of where the record resides. Transactions between accounts may use zero-knowledge proofs to generate intermediate or transaction hashes for each of the accounts, as described above. The system hash includes the system hash of each record as it generates that record.
[0298] In steps 614 and 616, assume that a transaction between accounts 602 and 604 involves three separate stages using the PAKE algorithm that allows the parties to construct a common hash after three passes.
[0299] In the first step of the transaction, account 602 exchanges hash h 610, which is a hash of a previous record, with system account 606 for the system hash h 608 generated in step 608. It appends this system hash and this hash h 610 to the first stage transaction information generated in step 610, constructs a first zero-knowledge proof, and sends this to account 604. The zero-knowledge proof entails the first stage transaction information, hash h 610, and the information that constitutes hash h 608.
[0300] In the second step of the transaction, account 604 exchanges hash h604 with the system account for the system hash h608 generated in step 608. It appends this system hash and hash h604, which is a hash of this previous record for the first-stage transaction information, to the first-stage transaction information to construct a second zero-knowledge proof and sends this to 602. The zero-knowledge proof entails the second-stage transaction information, hash h604, and the information that constitutes hash h608.
[0301] In the third step of the transaction, system account 606 adds h610 and h604 to its record and generates an intermediate system hash h612i. In a fourth step, account 602 constructs a third zero-knowledge proof using the information that constitutes the third-stage transaction information and sends it to account 604. The third zero-knowledge proof accompanies the information that constitutes the third-stage transaction information.
[0302] In the fifth step, accounts 602 and 604 independently construct a hash h614i616i. Both accounts 602 and 604 add this hash to their records. Hash h614i616i is the hash of the transaction.
[0303] In a sixth step, account 602 exchanges h614i616i with system account 606 for h612i, adds h612i to its record, and generates a hash h614 of the transaction record in step 613. Account 604 exchanges h614i616i with system account 606 for h612i, adds h612i to its record, and generates a hash h616 of the transaction record in step 616, and system account 606 adds two copies of h614i616i to its record, and generates a new system hash h612 in step 612.
[0304] At step 614, the account 602 record for the transaction includes hash h610, hash h604, system hash h608, transaction hash h614i616i, intermediate system hash h612i, the three levels of transaction information, the record of the transaction, the account ID, and hash h614.
[0305] At step 616, the account 604 record for the transaction includes the hash h610, the hash h604, the system hash h608, the transaction hash h614i616i, the intermediate system hash h612i, the three stages of transaction information, the record of this transaction, the account ID, and the hash h616.
[0306] (The record for the transaction for account 602 differs from the record for account 604 because the transactions began and ended in different states, and are therefore different accounts with different account details and IDs.) The system hash h612 strengthens the hash chain considerably because it includes the hashes of both sides of the entire transaction, not just the individual transactions.
[0307] When Tereon manages transactions between accounts on different systems, the process is slightly different. Here, each system exchanges system hashes and intermediate system hashes with the accounts it manages. Otherwise, the method described above in connection with FIG. 6 is the same, except instead of having accounts 602 and 604 and system 606, it shows system 606 with respect to associated account 602, and second system 605 with respect to account 604. The system hashes generated along with the transactions generated in steps 614 and 616, for a transaction made in step 612, the resulting hash system represents the system transaction in step 612 and the equivalent transaction on the second system 605 corresponding to account 604. For accounts that can transact simultaneously, the system generates a hash for each interaction that creates a record.
[0308] While Figure 6 shows sequential and intermediate hashes, the reality is different. Figure 6a illustrates three accounts 602a, 604a, and 606a, all interacting with a system account 608a as well as an account on an external server. The stages of the transaction are interleaved to illustrate what can happen when transactions are performed simultaneously on the system. For convenience, these are all shown on the same server.
[0309] In the above example, in step 612a, account 602a would exchange hash h602a with system 608a to obtain h612a. System 608a generates what the above example shows as intermediate hash h616ai. The subscript "i" is used to clarify that each transaction includes three system hashes: the original hash before the transaction, the system hash at a particular stage of the transaction (the intermediate hash), and the system hash at the end of the transaction. The subscript "i" indicates the intermediate hash. By the above reasoning, the final system hash may be h616a. If there are multiple concurrent or interleaved transactions, the labeling does not reveal any further progress. Instead, each system hash is a system hash, albeit an increment to the previous hash, whether generated during or after the transaction. If three transactions occur because account 602a starts, then account 604a starts, account 606a starts, account 602a ends, and account 606a ends before account 604a ends, and no other transactions or actions have occurred on this (or any account) or any other account on the server, then the hash order will be as follows, and as a result the diagram will be subtly different from the previous drawing.
[0310] Account 602a exchanges hash h610a with the system to obtain h612a, which the system uses to generate the next system hash h616a (this is because H628ai is the final system hash for the transaction, and therefore once account 602a's transaction is complete, h628ai will be labeled as original).
[0311] Account 604a exchanges hash h614a with the system to obtain hash h616a, which the system uses to generate the next system hash h620a.
[0312] Account 606a exchanges hash h718a with the system to obtain hash h620a, which the system uses to generate the next system hash h624a.
[0313] When an account 602a generates its intermediate or transaction hash, it exchanges that hash h622a for the system hash h624a. The system uses that hash h622a to generate the next system hash h628a.
[0314] When an account 606a generates its intermediate or transaction hash, it exchanges that hash h626a for a system hash h628a. The system uses that hash h626a to generate the next system hash h632a.
[0315] When an account 604a generates its intermediate or transaction hash, it exchanges that hash h630a for the system hash h632a. The system uses that hash h630a to generate the next system hash h636a (not shown).
[0316] The hash chain allows the system to process transactions, audit those transactions, and simultaneously authenticate the data sent or generated by those transactions. These steps occur simultaneously; there is no need to assume that devices will honestly report their transactions to the auditing system. Transactions generate audits and audits generate transactions.
[0317] This changes the nature of all transactions performed by the programmed device. Any programmed device, including IoT devices, can validate and trust transactions and data between other devices because the transactions, as well as their auditing and authentication, are performed simultaneously.
[0318] Because the transactions and audits are generated as part of the same process, there is no need to assume that devices will send accurate records of transactions to the audit system. This concurrency property changes the quality of the evidential value of the audit trail. Each device can rely on information sent by other devices, but makes no assumptions regarding the trustworthiness of the other devices. The data sent and received is the data that is processed and the data that is authenticated and audited.
[0319] When combined with a lookup service, devices that have not previously interacted can authenticate each other, determine the services or functions that each performs, and then communicate between each other and rely on that communication to perform operations as programmed without the need for any human intervention.
[0320] Hash chains allow programmed devices, including IoT devices, to work both online and offline. When a device is offline, if it includes a timestamp, information about the device's clock screw, a device-specific transaction ID (generated by an internal monotonic counter, for example), and other synchronization information in the transaction information, then when those servers eventually receive the records of the offline transactions from the device or from a third-party server, they will reconstruct an accurate timeline that stores the causal relationships for each transaction. Hash chains allow servers to rely on the contents of the transaction records in both online and offline modes.
[0321] Combined with a communications security model that protects communications between devices, devices and servers can communicate in a manner that is not susceptible to man-in-the-middle attacks. Tereon enables IoT and other programmed devices to communicate securely and rely on the data transmitted between those devices.
[0322] One example could be a network of IoT and other programmed devices operating with a set of industrial sensors and controls. The security model uses a lookup directory service to securely communicate between such devices and allow them to interact with new devices as they are added to the original collection. Tereon does not need to be reconfigured to recognize new devices and to be able to trust the new devices. The hash chain allows devices to trust the content and timing of the communication between them, allowing operators to rely on the data generated and transmitted without requiring human evaluation of the veracity of the transmitted data. No third parties can interface with the data. The audit and authentication chain occurs simultaneously with its transmission.
[0323] The lookup service, when combined with the security model and the lookup service, allows devices to create ad-hoc interconnections that can be trusted and authenticated without the need for human intervention. Once a device is authenticated and its details are added to the lookup service, other devices can connect to it as needed. If the device is compromised in any way, all access to it is disabled by the same lookup service.
[0324] The system provides additional benefits that arise from the hash chain and lookup service. Because every device is individually authenticated and audited, the system can direct specific devices to download updates to their device software, if necessary, and the devices do so only from secure, trusted sources. The lookup service details, for example, the services, interfaces, and data formats that a specific device provides and uses. Thus, when a device attempts to connect to another device to access a specific device (survive), if it does not have the necessary software to support the required interface or format, it can communicate with the system server to download the necessary software or configuration that allows the devices to communicate with each other, either one of the devices that is connecting, or both of the devices, if necessary. After device-to-device communication is complete, whether the device retains the software is determined by the device or the services it performs, and the capacity of the device in question. The hash chain means that even if they remove the software (it may install it again when it dash communicates), the two devices retain a complete audit and record of device-to-device communication that can be uploaded to the other device or server later, if necessary. This functionality extends to all types of devices, from fully automated IoT devices to other programmed devices such as payment devices.
[0325] Distributed records of the hash chain To provide a distributed copy of the entire hash chain, the Tereon system uploads the hash chain for every transaction that occurred between the server's current connection and the last connection to a central set of servers, such as a license server, lookup server, or other set of servers. The same Tereon system may download corresponding hash chains for different Tereon systems. This provides a distributed ledger of hash chains for every transaction across all Tereon systems, but does not require recomputing each hash chain for every transaction. However, it places additional storage burden on the Tereon system. The central server may be limited to industry, geography, or other constraints that make it a global server, such as a license and lookup server. Limiting the reach of copies of the hash chain may reduce the computation and storage burden of this variant.
[0326] Instead of limiting the scope of the central server, we can limit which systems can download hash chains uploaded by other systems. Thus, a bank's hash chain can be downloaded by other banks, subject to restrictions depending on whether the bank is in the same region as the uploading bank or has done business with other banks. Similarly, a hospital system can only download hash chains uploaded by hospitals in the same region. There is no restriction on flexibility.
[0327] The hash chain used by Tereon has extremely useful attributes: it provides a local ledger, but with distributed authentication. It keeps transaction information private to the users and services involved in the transaction, but distributes the authentication provided by the hash to all servers, services and devices. The hashes generated by the zero-knowledge proofs demonstrate this: only the system involved in a particular transaction has the transaction information. However, all systems and devices that interact with the system generate hashes that contain information about that system's initial hash.
[0328] Distributed authentication is important because it provides an incalculable barrier against potential fraudsters attempting to hide tampered records. With blockchain, a fraudster only needs to control 25-33% of the servers to alter the blockchain, hiding the corrupted records and recording the false records as valid records. Once done, the process is impossible to reverse.
[0329] Using the Tereon hash chain, an impostor would have to control every Tereon server, every Tereon service, and every Tereon device and recalculate every hash of the chain on every applicable server and device, which is computationally infeasible.
[0330] Hash chains offer at least the same level of economic savings and economic efficiencies that blockchain proponents predict for the latter. The difference is that Tereon hash chains can actually do so. Blockchains cannot, due to their design and limitations inherent in that design.
[0331] The advantage of this system is that an impostor cannot delete or modify a record in the database without recalculating all hashes and hashes connected with that record. This is theoretically possible if Tereon runs on a single server with no system hashes or connections to the license server, but if one of the linked chains contains transactions with parties on other servers or devices, the impostor would need to recalculate all the hashes on the other servers or devices. The difficulty of doing so increases exponentially for each additional server or device that interacts with the hash chain after the date and time of the original record.
[0332] Hash chains allow organizations to ensure the accuracy of data collected, generated or managed by any device, ensure the original content and integrity of records, and ensure the content and integrity of transactions based on previous records. This applies to any device or transaction, from payment devices to medical devices, traffic sensors, weather sensors, water flow detectors, etc.
[0333] This has distinct governance benefits, as each regional ledger is the responsibility of the individual organization, but they can learn from and rely on other organizations' ledgers in a way that provides clear responsibility and accountability while sharing strengths. Hash chains create a technical tool that enforces and assists in information and transaction management.
[0334] Additionally, when the hash chain is used as a component of a payment system, Tereon processes payment amounts, and the architecture is consistent with the way payments are made today, offering advantages similar to or greater than those of cryptocurrencies like Bitcoin: it provides a "Bitcoin beater" to established payment service providers and central banks.
[0335] The hash chain is a particularly attractive part of the Tereon system because it enables extremely stable and fast authentication. One of Tereon's unique features is its ability to create comprehensive real-time logs and audit trails. A Tereon transaction record contains all keystrokes required for a transaction (excluding the actual authentication credentials (e.g. PIN or password)), along with all data and metadata about that transaction required to meet regulatory and business requirements. When stored across multiple service providers as required, it is important that the record is not susceptible to tampering, and that the chain of transactions following the transaction in question cannot be tampered with.
[0336] Blockchains cannot do this. They can only approve a transaction record after its creation and before any authority is granted. Blockchains are connected to various records and generate blocks, which are then added to the blockchain. It relies on the fact that the blockchain contains blocks that contain information about all previous transactions. As the blockchain adds additional blocks, it checks the validity of the record and all previous records in the blockchain depending on the presence or absence of such blocks. This creates scaling issues as the size of the file increases, and if a mismatch occurs, the entire branch loses validation.
[0337] Rather than using a blockchain or its derivatives, Tereon's hash chain uses a hashing strategy that isolates suspicious records for investigation without compromising the authenticity of subsequent transactions. It is designed for any record type, whether static records or real-time transactions, thus avoiding scaling issues.
[0338] A hash that includes intermediate hashes allows an administrator to quickly search the hash chain to identify the hash and the corresponding record, and provides the information necessary to verify the record itself.
[0339] When a transaction or action occurs, the previous hash is adjusted, meaning that users and systems may trust the output of the new transaction. Thus, Tereon may trust the running totals of each account before making a transaction. The validity of the hash chain ensures that the running totals are correct.
[0340] This feature isolates the effects of amended, deleted, or altered records that separate the hash chain from the blockchain and its derivatives. By definition, any modified or altered record that is reliably hidden from the blockchain will affect the entire recalculation of that blockchain. Since all blockchains must be modified, there is no way to find and correct forged or false records other than by democratic decision of the entire blockchain community. It is this feature that security researchers have identified as the main flaw in the blockchain design; the design cannot be changed.
[0341] In a hash chain, a tampered record cannot affect the rest of the hash chain unless an attacker can recompute all of the subsequent hashes: the untampered hashes are and remain valid, so transactions based on those hashes and values related to those hashes remain valid.
[0342] The dendritic hash chain for offline transactions means that offline transactions performed by an offline device can be registered even if the offline device is lost or compromised before it can reconnect to the server.
[0343] Hash chains perfectly support offline transaction validation, which cannot be achieved by the blockchain and its derivatives alone. Nodes running a copy of the blockchain must be online to validate blocks. A Bitcoin wallet can generate a transaction offline, but the validity of the transaction cannot be checked until it comes online and pushes the record of the transaction to a node. The validity of the transaction cannot be checked until one of the nodes wins the race to generate the next block on the blockchain and adds the record to the block.
[0344] Directory Service Existing systems such as transport systems, payment networks like EMV (Europay, MasterCard, Visa), and other legacy systems use a hub and spoke architecture, where all transactions pass through a central utility that presents a potential single point of failure or vulnerability and is expensive to scale.
[0345] Because the Tereon system is peer-to-peer, with one server communicating directly with another, the hash chain is extremely important for security, as validation of the hash chain occurs at every element of the peer-to-peer network.
[0346] As explained, the Tereon system has a directory service 216 that is a directory of system credentials and information. The directory service 216 stores multiple types of credentials for a particular user, thus identifying which server a user or device 218 is registered with or which server provides a particular service or function, allowing multiple authentication methods for a user 218 to occur. For example, a user 218 can be authenticated using their mobile number, email address, geographic location, PAN (primary account number), etc., and caches everything so they don't have to authenticate every time.
[0347] The directory service 216 provides an abstraction layer that separates the authenticated identity of a user from the underlying services, servers, and actual user accounts. It provides an abstraction between the credentials that can be used to access a user 218 or merchant service and the information Tereon needs to perform the service itself. For example, as a payment service, the directory service 216 might link an authenticated identity such as a mobile number and perhaps a currency code with a server address. There is no way to determine whether a user 218 has a bank account or which bank the user 218 has.
[0348] The directory service 216 acts as an intermediary between the various services so that service providers cannot see each other and security of user data is provided. Each service defines fields (variables) and values specific to that service. However, each service contains specific fields and values that identify the service.
[0349] If a transaction is completed with an unknown party, the Tereon server for the user 218 sends a uniform resource name (URN) to the directory service 216, which returns the IP address for the Tereon server of the payment service provider for the service requested by the user 218. This allows the transaction to be completed directly between the user 218 and the service provider on a peer-to-peer basis. The Tereon server also keeps the IP address in a cache so that all subsequent transactions do not need to use the directory service 216.
[0350] Such abstraction provides security and privacy for user and service details, provides the flexibility to add and modify underlying services without affecting public user credentials, and provides the ability to partition and support various services that are distinct and isolated from each other as needed. No field in the data service contains data necessary to initiate a transaction, and no user data other than the user's authenticated ID is stored in the directory service 216.
[0351] But Tereon directory service 216 goes beyond this. It supports multiple credentials. Thus, a user 218 may use any number of credentials as a payment ID. Examples include mobile numbers, PANs, email addresses, etc. As long as the credentials are unique, Tereon will support them.
[0352] Directory service 216 supports multiple services. This is where the concept of multi-faceted credentials (or "psychic paper") comes from. When a service provider checks a credential on directory service 216, it can only see if the credential is registered for its service and the Tereon server that services that credential. The service provider cannot see the details of the different services for which user 218 can be qualified or registered.
[0353] For example, a mobile or card can be a library card credential at a library, a bus or train transport ticket, a security key to access a room or facility, an in-house payment device at a company cafeteria, a theatre ticket, and a standard payment device at a supermarket. It can be a driver's license, a health care card or an ID card to prove entitlement to a service. A photo ID may be displayed on the merchant's device if the service requires it. There are few limitations on the types of credentials a device can create.
[0354] While it is difficult to disguise the card's original appearance (possible if the card incorporates an OLED cover or color e-paper cover - for example, a service can instruct the card to display specific credentials or information required for the service), the appearance of the phone application is changed by Tereon to reflect the nature of the credentials and service.
[0355] A reverse lookup function may be implemented for each server. This function can verify whether the server it communicates with is authorized and authenticated. This function is not necessary because all communication between Tereon devices (card, terminal, mobile or server) must be signed. However, there may be situations where an operator needs or desires additional security via reverse lookup. Here, the directory service 216 includes multiple fields such as service, Tereon server domain address, Tereon server number, Tereon server operator, TTL (Time To Live), terminal authentication ID, etc. Here, the service tag indicates a server reverse lookup that is not a transaction service.
[0356] Figure 9 shows an example with two servers: server 202a and server 202b. A user 218 is registered with server 202b and accesses services via a terminal connected to server 202a.
[0357] In step 902, the user 218 uses his device to identify himself to the terminal, which automatically identifies itself to the terminal. If he uses a smart device, the terminal also passes its identity to the user's device. If the user 218 uses a card, the device only needs to pass its identity to the user's device if the device is a microprocessor card. In this case, the card communicates with the server 202b where it is registered. It passes the device's identity to the server 202b through an encrypted tunnel through the terminal.
[0358] At step 904, server 202a receives the ID provided by the user's device and checks it against a list it maintains. Since it does not have the ID, it has not served user 218 before. Server 202a contacts directory service 216, which checks the signature on server 202a's communication and considers it valid. Directory service 216 looks up the ID against the service tag for the requested service (server 202a's signature verifies that the server is authorized to make requests for that service) and responds with information identifying server 202c along with a cache time for the live information.
[0359] In step 906, the server 202a connects to the server 202b to check whether the user's device is registered with the server 202b. The server 202a communicates the terminal ID to the server 202b.
[0360] In step 908, server 202b makes a similar request to directory service 216 to search for servers where the terminal is registered, if it has not already done so, and it can check with server 202a to see if the terminal is registered for the requested service. Directory service 216 responds with information identifying server 202a along with a cache time for the live information.
[0361] At step 910, server 202a and server 202b communicate directly with each other to carry out the necessary transaction, which could be anything from making a payment to opening a door.
[0362] The Tereon server itself contains the necessary information to initiate transactions and will only communicate with other servers or devices that are licensed and authenticated. First, when servers communicate with the directory service 216 and with each other, they cache the data until it expires in their own mini-directory service.
[0363] In this case, the communication to establish a connection between Tereon Server 202a and Tereon Server 202b is obviously straightforward, as shown in FIG. In step 1002, the user 218 uses his / her device to identify himself / herself to a terminal connected to the server 202a, which automatically identifies itself to the device. If using a smart device, the terminal also communicates its ID to the user's device.
[0364] In step 1004, server 202a receives the ID provided by the user's device and checks it against a list it holds. Since the data it holds is valid, server 202a connects to server 202b to verify if the device is registered for the requested service. Server 202a also communicates the terminal's ID to server 202b. Server 202b verifies that the device is registered.
[0365] Since server 202a's cache contains valid data for the terminal's ID, it contacts server 202b to see if the terminal is registered with it. Server 202b verifies this.
[0366] At step 1006, server 202a and server 202b communicate directly with each other to carry out the necessary transactions. When the cached data expires at a server, that server contacts the directory service 216 as before. If the user 218 moves to another server, the communication is slightly different, as shown in Figure 11. The difference is that the first communication with server 202b, based on the currently uncached information, causes server 202a to search the directory service 216 for new data.
[0367] In step 1102, the user 218 uses his device to identify himself to a terminal connected to the server 202a, which automatically identifies himself to the terminal. If using a smart device, the terminal also communicates its ID to the user's device. The server 202a receives the identification provided by the user device and checks it against a list it maintains. It retains the ID and sees that cached data indicates that the ID is registered with the server 202b.
[0368] In step 1104, the server 202a connects to the server 202b to check whether the user device is registered with the server 202b. The server 202a communicates the terminal's ID to the server 202b. The server 202b responds that the ID is no longer registered.
[0369] In step 1106, server 202a contacts directory service 216. Directory service 216 checks the signature on server 202a's communication to ensure it is valid. Directory service 216 looks up the ID for the service tag for the requested service and responds with information identifying server 202c along with a cache time for the live information.
[0370] At step 1108, server 202a contacts server 202c to check if the user's device is registered with server 202c for the same service, and server 202a communicates the terminal's ID to server 202c and updates its cache with the new details for the ID from the user's device.
[0371] In step 1110, server 202c makes a similar request to directory service 216 to search for servers with which this terminal is registered, if it has not already done so, and can also verify that the terminal is registered with server 202a for the requested service. Directory service 216 responds with information identifying server 202a along with a cache time for the live information.
[0372] At step 1112, server 202a and server 202c communicate directly with each other to carry out the necessary transactions. The directory service 216 always keeps a complete trail of the user IDs, both old and new, that the user 218 has registered, along with the dates that they were assigned to the user 218 .
[0373] Server 202c only holds information about the registered ID from the date the ID was registered with it. Server 202b holds data about the period during which it has serviced that ID.
[0374] The layer of abstraction provided by the directory service 216 goes even further as services are partitioned. Thus, in a suspicious example, the server 202a may request only information identifying the server that registered the user's device for the requested service.
[0375] The server 202a must sign each communication with a device, and the signature identifies the service to which the communication relates. If the server can provide more than one service, it has a private key for each such service and signs the relevant communication with that key.
[0376] The Tereon server itself contains lookup information that identifies the user's account data from the tags or information provided, in this case servers 202a and 202b. Thus, only server 202b contains the data that maps the user's device ID to the user's account. The information in directory service 216 is simply a pointer to server 202b. The user's device can easily be registered with other servers for various services. It is the combination of the user's device ID and the credentials that define the service that allows the Tereon server to find the correct server.
[0377] First, server 202a communicates with server 202b, conveying the service tag, user ID, and any other relevant transaction data (e.g., age, currency, amount, etc.), and server 202b retrieves the relevant user's data and performs its side of the transaction. Server 202a never sees the user data; it only sees the user's authenticated ID and the transaction data conveyed by server 202b.
[0378] Similarly, server 202b never sees any information identifying the account to which the terminal is connected - it merely sees the terminal ID and transaction data communicated by server 202a.
[0379] Psychic paper - the multifaceted credential One of the more interesting effects of directory services is the ability to create ad-hoc multi-faceted credentials customized to a particular service at the time that credentials are needed. The service does not have to have been envisioned at the time the directory service was created so that the directory service can provide such credentials. This is known as "psychic paper".
[0380] Ad-hoc multi-faceted credentials mean that a user's device becomes the credential needed for a particular service, providing exactly the information needed to authenticate, authorize, or obtain other benefits from the service, and that is all that the service provider represents.
[0381] As an example, user 218 is signed up for several different services, such as a payment service from his bank and a library borrowing service at his local library, and because he must provide his date of birth when signing up for Tereon, he automatically has access to the age verification service.
[0382] Figure 12 shows how the directory service 216 directs a requesting server (server 202a) to two other servers (servers 202b and 202c) depending on the service requested by the user 218. If desired, two or more separate directory services for separate services may be used. What is important is that the transaction data is part of the abstraction and is separate from the underlying account data.
[0383] User 218 needs to verify his age, for example, to purchase an alcoholic drink at a bar (service 2). Steps 1202 to 1210 are performed as steps 902 to 910 in FIG. 9. In this case, it is between servers 202a and 202c, not between servers 202a and 202b. Thus, in step 1210, servers 202a and 202c communicate directly with each other. In this case, server 202a wants to verify that user 218 is over 21 years old. Server 202c simply verifies that he is over 21 years old.
[0384] If the operator requires additional verification due to legal or regulatory requirements, the server 202c can send a passport-type image of the user 218 to display on the terminal so the operator can see that he or she is actually speaking with the user 218. The server may send questions for the user 218 to answer to further verify that it is the correct user, although there is little need to do so since the user 218 has already identified himself to the server 202a. The operator cannot see the user's actual age or any unnecessary personal information. All the operator needs to verify is that the user 218 is old enough to buy an alcoholic drink. When the user 218 uses the device to pay for his or her drink, the terminal connected to the server 202a connects again to the server 202c, but this time for the payment service (service 1).
[0385] A user 218 wants to go and borrow a book at his local library (service 3). In step 1212, the user 218 uses his device to identify himself to a terminal in the library, which automatically identifies itself to the terminal. The terminal in the library is connected to server 202b. If using a smart device, the terminal communicates its ID to the user's device.
[0386] In step 1214, server 202b receives the ID provided by the user's device and checks it against a list it maintains. It has the ID, but its cache is out of date. Server 202b contacts directory service 216, which checks the signature on server 202b's communication to ensure it is valid. Directory service 216 looks up the ID against the service tag for the requested service and responds with information identifying server 202c, along with a cache time for the live information.
[0387] At step 1216, server 202b contacts server 202c to check if the user's device is registered with server 202c, and server 202b communicates the terminal's ID to server 202c and updates its cache with the new details for that ID from the user's device.
[0388] In step 1218, if it has not already done so, server 202c may make a similar request to directory service 216 to search for servers with which the terminal is registered. It may also check whether the terminal is registered for the requested service with server 202b. Directory service 216 responds with credentials that identify server 202b.
[0389] In step 1220, server 202b and server 202c communicate directly with each other to carry out the necessary transactions: server 202b wants to know if user 218 can borrow a book (service 3), and server 202c verifies that user 218 is registered with a library service that allows him to borrow books (a service that the Tereon operator offers to libraries). If user 218 needs to use his device to pay for borrowing a book, the terminal again contacts server 202c, but this time for the payment service (service 1).
[0390] Server 202c does not need to provide any services to the library. User 218 can easily register with another server, such as server 202d (not shown), which in this case confirms to server 202b that user 218 may borrow books. The important thing is that in the first case, server 202a only confirms that user 218 is over 21 years old. It does not know that he can borrow books, and does not know that user 218 pays by Tereon. Similarly, server 202b knows that user 218 can borrow books, but does not know that he is over a certain age or can pay by Tereon.
[0391] The request server may also make various requests to separate servers as necessary to assemble a set of credentials for a particular transaction. For example, assume that a user 218 wants to rent a movie that has an age restriction. In this case, the request server makes one request to verify the user's age and two separate requests to verify that the user is registered to rent movies from the library. Tereon collects the verified individual credentials to compose the set of credentials to request at the library.
[0392] The structure of the directory service 216 allows for the servers conveying the individual credentials to be separated, so that a requesting server can query any number of servers to obtain the individual credentials necessary to compose the set of credentials necessary to determine whether a particular service can be conveyed to a user 218.
[0393] 13 illustrates a case where server 202a needs to obtain credentials from three servers 202c, 202d, and 202e to construct a multi-faceted credential for providing a service to user 218. For example, service 2 on server 202d is a service for renting films, which requires age verification as a first credential from server 202c, a membership credential from server 202d, and a sufficient funds credential from server 202e.
[0394] The relationship is not necessarily one-to-one, and each of the three servers holds only one credential. Any of the three servers may communicate one or more credentials to server 202a. It may communicate only one credential to server 202a. The number of credentials does not matter. What is important is that server 202a contacts one or more external servers to obtain the necessary credentials to enable user 218 to access services.
[0395] The server 202a, through which the user 218 accesses the terminal, may already possess the necessary credentials to deliver some services to the user 218. However, for data protection purposes, the user 218 does not want to provide certain details (such as age) to the server 202a. If all the servers 202a need to verify that the user 218 is over a certain age or authorized to order a certain product, they can simply connect to a server that confirms or denies the inquiry. This is extremely useful for e-commerce websites. They can verify certain facts or parameters without knowing the exact details. Essentially, the directory service 216 acts as a zero-knowledge proof provider or a confidential notary. Tereon can prove or disprove facts or parameters to the server 202a without disclosing what those facts are.
[0396] Thus, the credentials for a particular service may include credentials from servers 202a, 202c, 202d, 202e, and others. The credentials may be on one server or distributed across various servers.
[0397] This is extremely powerful because it allows individuals and organizations to prove that they are entitled to a service without having to disclose information that they don't need to disclose. Again, using the example of an e-commerce website, a user 218 may register his name and address with the website, but his bank holds his payment credentials, a government server registers the fact that he is authorized to purchase restricted items, his local railroad company holds his travel authorization, and his health authority's server can verify his age.
[0398] The method of assembling an ad-hoc set of credentials for a service does not only apply to users and their devices, but also to autonomous sensors, devices and services, such as IoT devices, that need to connect to different services at different times. When such a set of credentials is required, the credentials required for those services can be easily combined.
[0399] Account switching A major problem slowing the adoption of new systems is the perceived difficulty of transferring data from the legacy system to the new system without loss or interruption of service. The same problems affect system upgrades, and operators often stick with the original hardware and software configurations rather than upgrade and update due to the perception of the risk of losing data during an upgrade or update.
[0400] Directory service 216 solves these problems by providing a mechanism to smoothly move data, account and configuration information from one server or data store to another. One of the building blocks in supporting real-time credit transfers between institutions is the question of how to capture and process in-the-air payments. The industry currently has credit transfer systems that take a total of 18 months (7 days after initial switchover, 18 months to receive payment or credit). This can also be applied to switching a collection of data from one data store to another.
[0401] The directory service 216 provides an abstraction layer that separates a user's authenticated identity from the underlying services, servers, and actual user accounts, thus allowing users 218 to maintain their authenticated identity while changing the services and underlying servers with which their devices are registered.
[0402] The account switching process is best explained with an example. In this example, user 218 banks with Bank A. Figure 14 shows the user relationship with Bank A and Tereon server 202a. Bank B sponsors Tereon on server 202b, even though user 218 is not yet a customer. User 218 decides to move his account from Bank A to Bank B.
[0403] Figure 15 shows a process in which a user 218 initiates a transfer of his account from Bank A to Bank B. In this example, the user 218 is not overdrawn from Bank A and has no loans.
[0404] In step 1502, user 218 opens an account with Bank B and registers their card and mobile with that bank and the Tereon server 202b. At step 1504, Bank B's Tereon Server 202b searches the user's mobile and card PANs on the Tereon Directory Service 216 to find if they are all registered with Bank A.
[0405] In step 1506, Bank B's Tereon server 202b contacts user 218 to confirm that he or she wishes to transfer his or her registration to Bank B, and user 218 confirms this by, among other things, entering an additional authentication code sent to user 218 for this purpose.
[0406] At step 1508, Bank B's Tereon server 202b connects to Bank A's server 202a and notifies Bank A's server 202a that User 218 has requested and confirmed a transfer to Bank B for his or her account and ID.
[0407] In step 1510, Bank A's Tereon server 202a sends a request to the user 218 to confirm that he or she wishes to transfer to the account, and the user 218 confirms his or her transfer.
[0408] In step 1512, Bank A's Tereon server 202a validates this with Bank B's Tereon server 202b and notifies User B's server 202b of the user's account registration, balance, configuration, payment instructions, etc. Bank B's server 202b sets up such an account in the same manner as Bank A, or as close as possible to providing the services it is authorized to provide.
[0409] For example, user 218 has three separate currency accounts with Bank A that allow him to hold GBP, USD, and EUR. Unfortunately, Bank B only offers GBP and USD accounts, but it can receive EUR payments to or from any of the accounts. Bank B's server 202b notifies user 218 once the user has opened an account, and the user decides to convert EUR to GBP. Bank B then instructs Bank A to send EUR as GBP.
[0410] In step 1514, Bank B's Tereon server 202b notifies the directory service 216 that the user's ID is registered with server 202b. In step 1516, Bank B's Tereon server 202b notifies Bank A's server 202a that it has registered the user's ID in the directory service 216, and instructs Bank A to transfer the balance.
[0411] At step 1518, Bank A confirms with the directory service 216 that it no longer manages the user's identity. The directory service 216 sets the start date and time for the new identity registration with Bank B and the end date and time field for the old registration with Bank A. Bank A configures the directory service to notify any servers attempting to make a payment to User 218 who no longer has a user account, instructing them to look up the user's details in the directory service 216. It does this by entering a date and time in the end date field. Bank B receives all payments made to User 218 who was originally connected to Bank A.
[0412] The directory service 216 can catch in-the-air payments, which are payments made to a user's old account after the user 218 switches to a new account. In the same manner, Tereon can also receive deferred payments due from the old account. The balances transferred to these accounts are debited from the new account, a task that takes minutes rather than days, weeks or months.
[0413] In step 1520, Bank A transfers the balance to Bank B. Bank B notifies Bank A that it has received the funds. At step 1522, Bank A notifies User 218 that it has closed the user's account and has so transferred the balance at the new bank.
[0414] At step 1524, Bank B notifies User 218 that it has received his balance from Bank A. If user 218 is overdrafted on one or more of his accounts at Bank A and Bank B agrees to take on his business, Bank B will transfer the balance to Bank A and the user's corresponding account at Bank B will be debited in steps 516 and 520. User 218 may decide to transfer funds between his accounts at Bank A to clear the overdraft before crediting his account at Bank B.
[0415] For payments, the Tereon numbering system distinguishes between users, organizations, accounts, types of services, and transactions; they all have separate numbering systems. This feature allows the directory server to manage the process of users 218 moving their accounts to new service providers in real time. The structure of the directory service 216, along with its ability to process transactions in real time, allows users to change accounts in minutes instead of days.
[0416] The directory service 216, as described above, eliminates the problem of in-the-air transactions, such as in-the-air payments, along with real-time processing of all transactions. In Tereon, transactions cannot simply enter a pending state; they are either completed or cancelled.
[0417] Tereon supports the concept of account portability, a feature that increases competition in the marketplace and that banks and regulators believe cannot be realized. Tereon inserts an abstraction between the user 218 and the user's bank account details because it does not use account details directly but uses separate credentials to identify each payer and payee. The abstraction provided by the directory service 216 facilitates account switching and mobility.
[0418] Changing credentials Directory service 216 allows operators and users to change existing identity credentials to new credentials and reuse past credentials without disrupting transactions with previous users of the identity. The abstraction layer provided by directory service 216 allows Tereon to do this.
[0419] When a user 218 transfers their account to another server, the user 218 may retain the particular credential, such as the PAN, or the server may issue new credentials to the user 218. In the latter case, the original server may reuse the credential almost immediately. Because each credential has a date / time stamp that reflects when it is issued to the user 218, a new user 218 of a particular credential may use that credential almost immediately.
[0420] Each credential has a date and time stamp that was issued to a particular user on a particular server. Tereon uses this component to route transactions to the correct destination because each transaction also has a date and time stamp, and each Tereon server also has the credentials used for each transaction. For example, user 218 buys something from a merchant with credential A (e.g., a mobile number), and moves to another bank a few days later when he needs to use another credential B (e.g., a new mobile number). If the item is defective, user 218 later sends the item back to the merchant. The merchant can look up the transaction and refund it. Although the original transaction used credential A, the server for credential A reports a date and time stamp that indicates the credential has changed. The merchant's server looks up credential A and discovers that user 218, who used credential A at the time of the transaction, is now using credential B. The server contacts the server for credential B (which verifies that user 218 for credential B used credential A at the time of the transaction) and the server begins the refund process.
[0421] User A can be sure that User B is not fraudulent because Tereon's security model requires that all communications be signed. Server 202b signs its communications only if it has a valid license from the license server, and User B's device signs its communications if Server 202b is valid because Server 202b issues and validates licenses for the device. User B cannot complete a transaction unless User B knows the exact credentials needed to approve the transaction or access applications on the device.
[0422] As a further example, a user may enter a mobile number for a contact in their phone book and wish to make a surprise P2P transfer to that contact. Tereon will search the record for that number and detect that the contact has changed to a mobile number as described above (if the contact is a Tereon user). It will verify with the correct server that the user using the new server number used the old number registered with the previous server. Tereon also helps contacts configure their accounts so that when a particular authorized contact attempts a transaction via the old credentials, the directory server can update the user's mobile number or different Tereon credentials. In this example, the aunt's niece has set up her account to update the entire family, so the next time the aunt accesses her contact list, she will see her niece's new mobile number.
[0423] 16 shows an example for server 202a, server 202b, and directory service 216. Here, an old user has moved his account from server 202a to server 202b. 202a is Bank A's server, and 202b is Bank B's server.
[0424] The old user initially uses mobile number 1 as his ID. After transferring his account, he continues to use mobile number 1 for some time. The communication between user 218, directory service 216, and servers 202a and 202b is as illustrated in FIG. 15 and described above. The directory service entries show that user 218 used server 202a from date-time 1 to date-time 3, and from date-time 2 he used server 202b. The slight overlap is to ensure that all pending payments are caught and that there are no gaps in time where a user does not have a server with his ID registered (the server to which the account is being migrated can control all the date-time and ID entries for that migration so that date-time entries do not overlap; this is how system migration works).
[0425] At some point, user 218 decides to change mobile numbers. He registers new mobile number 2 as his identity with server 202b and deregisters mobile number 1. Server 202b notifies directory service 216 of the change, indicating that the user started using mobile number 2 as his identity at date / time 4, and that mobile number 1 was discontinued as an identity to server 202b at date / time 5.
[0426] Later, the new user creates an account on server 202a and registers mobile number 1 as his identity at date / time 6. The new user may have been provided with the old user's previous mobile number, which may have been released for reuse by the mobile operator. Server 202a notifies directory service 216 that it has registered the identity (after verifying that the identity is available), and the directory service indicates that mobile number 1 is registered on server 202a as of date / time 6.
[0427] As shown in FIG. 16, if an old user uses a card issued by Bank A 202a, the user 218 first sends his account to Bank B 202b, which issues a new card to the user 218 with credentials such as a PAN. When the user 218 receives the card, he activates it and Bank B's server 202b informs Bank A's server 202a that the user's original credentials will not be used any more. Bank B registers the new credentials with the Tereon directory service 216. The user 218 may request to keep the original credentials, and if Bank A agrees to the request, he is allocated a small amount by Bank A to do so. Thus, Tereon supports card number or PAN portability.
[0428] At some point in the future, the user may discontinue use of the card originally issued by Bank A and release the credential. Bank A cannot reuse the credential for that PAN for six months after Bank B releases it or after the user transfers the account to Bank B. The exact time depends on what the bank regulator allows. Now, after the time has elapsed, the directory service 216 may use the credential because it does not contain the mobile number, PAN, or other credentials. It also contains a list of the credential's registered date, the date it expired as a user criteria, or the date it was released per user.
[0429] The account switching method allows the system to capture pending payments. It also provides an extremely flexible and powerful way to send subsequent transactions from previous transactions based on the credentials used in the previous transaction. Refunding a previous transaction is one real-world use case. A merchant refunding against an old ID can refund the correct account because the directory service 216 will instruct the server to pay the correct ID even if the original ID is later used again. EMV and current mobile lookup technology assume that numbers are never reused. Unfortunately, they sometimes are.
[0430] This is illustrated in Figure 16. Assume that some time between DateTime1 and DateTime2, an old user purchases an item from a merchant using a device with Mobile Number 1 as its ID. Later, the item turns out to be incorrect and the user wants a refund.
[0431] If user 218 goes to the merchant between date / time 1 and date / time 2 for a refund, the Tereon system will instruct the merchant system to pay the refund to the user's account on system 202a (because the user has not yet closed the account).
[0432] If user 218 goes to the merchant between date / time 2 and date / time 4 for a refund, the Tereon system will instruct the merchant system to refund the user's account on system 202b, even though the payment for the item came from the original server 202a.
[0433] The account switching method would also take into account the user's new identity: if user 218 goes to the merchant after time / date 4 for a refund and uses their mobile number 2 as their identity, the Tereon system will instruct the merchant system to refund to the user's account on system 202b, even though the payment for the item came from the original server 202a, and the user originally used mobile number 1 with their payment identity.
[0434] Records of PANs, email addresses, and other reusable credentials are also kept the same (biometric credentials cannot be reused, for obvious reasons).
[0435] The system can break down credentials to any level, one example of which includes currency or currency code, where users may use different IDs for the same currency or different currencies on separate servers.
[0436] Figure 17 shows an example for server 202b, server 202c, and directory service 216. In the figure, user 218 has already moved his account from server 202b to server 202c in the same manner as shown in Figure 16 via communications between the servers managed as shown in Figure 15.
[0437] User 218 initially uses Mobile Number 1 as his ID. After transferring his account, he continues to use Mobile Number 1 for transactions in Currency 1 and Currency 2 for a while. The entry in directory service 216 shows that user 218 used server 202b from date / time 1 to date / time 3, and from date / time 2 he used server 202c. The slight overlap is to ensure that all pending payments are caught and there is no time lag in case the user does not have a server registered for his ID.
[0438] At some point, user 218 decides to use a new mobile number for transactions in currency 2. He registers his new mobile number 2 with server 202b as his identity for transactions in currency 2. Server 202b notifies directory service 216 of the change, indicating that the user started using mobile number 2 as his identity for all transactions in currency 2 at date / time 4, and mobile number 1 was discontinued as an identity for all transactions up to date / time 5.
[0439] Figure 17a shows a different example for server 202b, server 202c, and directory service 216. In the figure, user 218 has already moved his currency 1 account from server 202b to server 202c in the same manner as shown in Figure 16 via communications between the servers managed as shown in Figure 15.
[0440] After transferring accounts, the user continues to make transactions between Currency 1 and Currency 2 during the time period using Mobile Number 1. An entry in directory service 216 indicates that user 218 used server 202b from DateTime 1 to DateTime 3, and from DateTime 2 onwards he used Mobile Number 1 as his identity with server 202c for transactions in Currency 1. The directory service entry also indicates that the user continued to use Mobile Number 1 as his identity with server 202b for transactions in Currency 2.
[0441] At some point, user 218 decides to use a new mobile number for transactions in currency 2. He registers his new mobile number 2 as his identity for transactions in currency 2 with server 202b. Server 202b notifies directory service 216 of the change, which indicates that the user started using mobile number 2 as his identity for all transactions in currency 2 at date / time 4, and mobile number 1 was discontinued as an identity for all transactions until date / time 5.
[0442] Prior to date / time 4, user 218 used his mobile number 1 as an identity for all transactions. Directory service 216 simply directed the transaction to server 202b if the transaction was in currency 2, and directed the transaction to server 202c if the transaction was in currency 1. The fact that the user registered the same identity with two servers is irrelevant, since it is the complete set of credentials that controls which server the transaction is directed to. A merchant's system that transacts with the user in currency 1 for the first time after date / time 2 will not know that the user previously used server 202b for a transaction in that currency. Similarly, unless the merchant's system begins transacting with the user in currency 2, the merchant's system will not know that the user used the same identity with server 202b for a transaction in currency 2.
[0443] Tereon does more than simply switch a user 218 from one network to another. As already mentioned above, the common methods of switching users cannot handle pending payments. As argued by the originators and others, the most advanced account switching systems currently available require an 18-month manual process for a user to receive their payment before it is due. During the 18 months, the bank and the user must work to transfer all existing payment instructions from the old account to the new account. Tereon completely eliminates this requirement.
[0444] Currently, banks cannot reuse payment credentials. Tereon's account switching mechanism removes this restriction and allows banks to re-issue PANs and account numbers after a specified period, if permitted by regulators.
[0445] This method is called account switching functionality, but in fact it has many applications in addition to basic account switching, for example, providing a backup service provider with failover if a bank's core system fails, and providing a way to migrate data from one system to another by converting it from one data format to another without information loss.
[0446] A further example is in simplifying number portability in mobile systems. Currently, when a user switches his mobile number from one provider to another, the first provider has to re-route all calls to the new provider. If the user switches to a third provider, the first provider has to route the calls to the second provider, which has to route the calls to the third provider. This is inefficient and costs a lot, but operators have to support number portability. Tereon eliminates the need to route calls multiple times.
[0447] When operators use Tereon to support number portability, they do not need to support multiple hops. When a user decides to port their number from a first operator to a second operator, the second operator simply notifies the directory server that it will support the current mobile number. The first operator then sends a call to the number to the directory server, which routes the call to the second operator. Each time the user ports their number again, the new operator notifies the directory server of the change, and the directory server routes the call to the operator serving the number. (If the user has a bank account with a globally unique IBAN, Tereon supports bank account portability in the same way it supports mobile number portability.)
[0448] A similar example would be when an operator migrates IoT services and devices from one server to another in order to upgrade a Tereon system where a simple migration of physical machines, logical machines, virtual machines, containers, or other commonly used mechanisms involving executable code is not sufficient.
[0449] Another example is that the system acts as a migration tool. For example, this is the case when an operator wants to migrate services with registered accounts of devices from one version of the Tereon system to a version upgraded in John. The operator configures the old server to send device registrations, accounts, and system configurations to the new server, and the system does the sending. Each account is sent along with data and audit logs, and the server updates the directory service 216 as the sending progresses. Now, when devices in the field want to communicate with the server, such as payment devices, traffic sensors, IoT devices, etc., the directory service 216 simply redirects them to the old or new server. Before or after the accounts are sent, they connect to the server.
[0450] The above examples show how Tereon can facilitate credential mobility and support ad-hoc multi-faceted credentials. This has a wide range of applications, making Tereon applicable to all network domains where credentials must be managed in the network.
[0451] Extensible Framework The workflows of existing transaction processing systems are static in nature: once implemented, they are difficult to change and the services or operations that the systems support are inflexible.
[0452] Until now, when a payment provider launched a service, the payment patterns for that service were static. The provider could only modify the service by launching a replacement or modified service and issuing new cards or applications to support the service. This is one of the reasons why, despite universal knowledge of the serious weaknesses of EMV, it is not possible to fix the system, which would mean recalling all existing EMV cards, reprogramming and running the EMV payment infrastructure, and issuing new cards. This would require thousands of issuers and acquirers to cooperate.
[0453] Tereon uses SDASF to place all functions on the back-end, which can guide merchant devices through processes in real time, allowing service providers to create new services with detailed functionality for individual users.
[0454] The extensible framework is a framework that resides within the Tereon system that allows new services to be added without having to reconfigure the Tereon system. The extensible framework works in conjunction with the directory service 216 to provide various benefits to the Tereon system.
[0455] Flexible message structure The extensible framework is provided in part by a flexible message structure (any data or record type can be provided with variable length fields, allowing the field lengths to be modified so that the Tereon system can work with legacy or incompatible systems).
[0456] The extensible framework can add additional layers of security to communication infrastructures by modifying the order of standard processes. In many industrial sectors, payments are just one example, communications use a fixed message structure. Even if the communications are encrypted, this creates vulnerabilities that criminals can exploit. Structured messages are vulnerable to exhaustive attacks. Organizations and others can protect the integrity of messages using a hash message authentication code (HMAC), but HMAC does not preserve the absolute confidentiality that messages should derive.
[0457] An extensible framework solves the static system problem for all transaction processing systems: it provides the flexibility to work with existing systems and services, and allows providers to update existing services and build new services without having to re-run the infrastructure or issue new end-point devices such as cards, as described below.
[0458] Obfuscation One theoretical risk faced by any system with structured message formats is that repeated use of the message formats provides hackers with ample material to use in brute-force attacks. This is the case for any system that does not properly implement its encryption algorithms using any form of random seeding.
[0459] The extensible framework allows operators and users to eliminate the need to send structured messages between devices and servers. Instead, messages are randomized. Each Tereon transaction communication contains two or more fields along with a label for that field. Instead of following a fixed order of the fields for each communication, the order can be changed randomly. Each field is always tagged with an identifying tag, requiring devices on both ends of the communication to first decode and then order the fields before processing them.
[0460] For example, using an excerpt from an example provided in the JSON (JavaScript Object Notation) documentation (though of course other formats exist and are used in the system), the following three representations are identical: ·{“version”: 1, "firstName": "John", "lastName": "Smith", "isAlive": true, "age": 25} ·{“version”: 1, "firstName": "John", "isAlive": true, "lastName": "Smith", "age": 25} ·{"age": 25, "firstName": "John", "isAlive": true, "lastName": "Smith", “version”: 1} An attacker cannot know whether cypher texts in his possession contain information similar to the existing sequence. The exact mode of randomization varies depending on the format and serialization protocol used, but the principle remains the same.
[0461] The randomization mode has an additional advantage: the predefined content of the communication is expanded without breaking the communication protocol. If a device receives a field that it cannot process, it simply discards that field and its value. Thus, one or more random field-value pairs are included in the system's discards, adding additional uncertainty to the communication.
[0462] Therefore, the following three messages are identical: ·{“version”: 1, "firstName": "John", “nonce”: 5780534, "lastName": "Smith", "isAlive": true, "age": 25}·{“whoknows”: “698gtHGF”, “version”: 1, "firstName": "John", "isAlive": true, "lastName": "Smith", "age": 25}·{"age": 25, "firstName": "John", "isAlive": true, "lastName": "Smith", “whatis this”: “Jor90%hr,” “version”: 1} In the above communication, the devices discard unknown field and value pairs.
[0463] Field names can be further obfuscated by randomly mixing case in each communication, and devices process these fields into a standard format. Therefore, the following three messages are identical: ·{“veRsioN”: 1, "firstName": "John", "nOnce": 5780534, "laStnAMe": "Smith", "isAlive": true, "Age": 25}·{“whoknows”: "698gtHGF”, "vErsion”: 1, "fiRStname": "John", "iSaLive": true, "lastName": "Smith", "age": 25}·{"aGE": 25, "firstname": "John", "isAlive": true, "lasTName": "Smith", "whatis this": "Jor90%hr," "versIOn": 1} When a version 2 message is sent, possibly containing additional fields, devices that only understand version 1 can reject the message, or, in cases where backwards compatibility is ensured, process the fields they understand and discard the rest. These could be improved by providing a field to indicate which versions are backwards compatible with some fields.
[0464] This thoroughly removes vulnerability to attacks. The structure of the message can also be preserved, but using variable length fields, which also achieves the same result. Also, the use of HMAC protects both the integrity and confidentiality of the message. If an end organization's core system requires messages in a structured format, Tereon will reconstruct the message once it reaches the server and reformat the message into the format required by the organization's core system. The extensible framework makes it possible to overcome the security issues of legacy systems and still be able to work with such systems.
[0465] The extensible framework supports any data or record type with the same levels of security and flexibility as above. Abstracted workflow components In existing solutions, the payment process is defined, implemented, tested, and released in software: the payment transaction structure is fixed and cannot be changed without significant efforts to recall and replace or reprogram devices, terminals, and servers.
[0466] Tereon does not do this. Instead, it composes the payment process from separate components, each of which interacts with connected components. Such components essentially arrange the workflow of the process. Each component can be updated and have additional functionality added without affecting the payment process itself. It abstracts the process components from the devices, so a transaction defined once may be applied to multiple devices such as cards, card terminals, mobile, or web portals.
[0467] Each component communicates commands and information to the next component depending on the result of the command it received. The commands can be transactional or can include controls such as how the next component operates (e.g., requesting a PIN if a choice is made, providing a set of choices, displaying a particular message, and expected or permitted responses).
[0468] This allows existing payment services to be modified and new services to be built without the need to reprogram or replace existing endpoints. Currently, once a payment service provider implements a payment system, the payment service provider cannot easily modify the system without replacing the endpoints. Existing systems are essentially static. This replaces them with a dynamic system.
[0469] The extensible framework allows an operator to use such components to plan the workflow for a particular transaction. It implements workflows including decision trees etc. The operator modifies the existing workflow by rearranging existing components, adding new components that provide new functionality, or removing components. To do this in existing systems requires reprogramming the servers and terminals and replacing the cards themselves.
[0470] Examples of this are shown in Figures 18 through 20. To make it easier to visualize what each component does, the components themselves are represented as blocks by the terminal screen; however, these components apply equally to mobile transactions, web portal transactions, and card terminal transactions. To modify an existing workflow, the order and connections of the components are easily changed. To create a new workflow, simply connect the required components in the desired order.
[0471] The normal payment process creates separate payment processes for contactless, contact, and mobile payments. Component 1804 is generally shown on the left side of the chain immediately after the "complete transaction in time" component 1802 as shown in FIG.
[0472] However, by moving this component further along the right side, as shown in FIG. 19, and inserting two different decision components 1902 and 1904 into the chain, an operator can create a single payment process that can manage contact, contactless and mobile payments in a single payment process.
[0473] The operator can go further. After the system identifies the customer, it wants to add a special seasonal offer to the process. As shown in FIG. 20, it can always move the component 1804 further to the right and insert a new component 2002 in its place that automatically offers the offer to the customer before the merchant has to enter the amount and PIN. The operator can, for example, set the component to work for 24 days until Christmas and offer a different component from then until the New Year. This can dynamically change the payment process for the Christmas and New Year season without the operator having to recall, reprogram, and reprogram the device. The component just needs to instruct the display device, be it a mobile or card terminal, to display the offer to the customer. The operator can easily deactivate the PIN requirement by configuring the component 1804 to deactivate the PIN requirement. Similarly, if a component does not have the functionality to require a PIN, the operator can update the component to include the functionality.
[0474] The operator may go further and build an entire decision tree to allow the customer to choose between different proposals as needed. Once the proposal season is over, the operator simply removes the new components and the process starts again with the original structure.
[0475] Importantly, operators do not have the luxury of recalling devices to change processes at any time - they simply reconfigure the process in the back end and then implement the changes at a date and time of their choosing.
[0476] The framework that provides the internal management and administration of the Tereon server can be constructed in exactly the same manner, where framework components interact with access contexts that govern how users and administrators can access and what information they can access and what tasks they can perform.
[0477] Dynamic services The extensible framework enables organizations to quickly activate and realize new services. Operators simply define such services by linking the necessary blocks together and defining the associated messages. Rather than needing to hire programmers to create the service code, the framework allows marketing and IT departments to create definition files that define the workflow, use a graphical system to "draw the workflow", or realize the service with different workflows that define the process. After validating the workflow, operators simply realize the workflow by linking the defined steps or blocks together, and Tereon makes the service available to all eligible users.
[0478] For example, an operator may use a block to accept payments of any value, and then require a PIN in a subsequent block. However, if the operator wishes to provide an access control system, the same operator may generate blocks that allow access without a PIN to one set of rooms, while using blocks to require a PIN to access another set of rooms.
[0479] This means that, unlike existing systems, an organization can design and implement new services, or modify or remove existing services, without having to replace devices issued to users even after the organization has launched the transaction processing system. If a device understands and can operate a defined step, it can provide any service defined by the organization using that step. Once an organization defines a service, the system makes that service immediately available to the target user or users.
[0480] Abstracted devices An extensible framework embraces the principle of abstraction and abstracts the devices themselves. The framework defines process components for each class of devices in terms of the capabilities of those devices. The process components interact with the corresponding functional components. Depending on the available capabilities, the process components instruct the functional components to perform tasks such as what to output and what to input.
[0481] Granularity Tereon can uniquely identify each device, user, and account, and access the context in which a user uses a device to access a service. Operators can then configure components, and options within those components, to trigger actions based on the context in which an individual user accesses a service. Tereon effectively allows operators to tailor services to each user, each user's device, and the context in which the user uses that device to access a service.
[0482] For example, one user may be able to select one of three offers for a transaction, another user may choose to receive only one offer automatically, and a third user may not see any offers at all.
[0483] If the process involves accessing a record (e.g., a patient record), the user accesses their own records, and if the user accesses records in the clinical facility or home domain, the user can manage the access privileges. However, if the user (or other users) accesses records outside of that domain, the user may only see a subset of those records or may not have access to those records (depending on the context settings for that service).
[0484] If a user uses a card terminal to access a service, the component instructs the card terminal to display relevant information. If a user uses a mobile or other screen device to access the same service, the component instructs the screen to display relevant information. In this manner, the abstraction layer of the extensible framework is device independent. Appropriate displays and access points can be used to control the interaction between the user and the system.
[0485] The same applies to the services provided. Each user's account has a provider default level of services. When an operator adds a new service or modifies an existing service for one or more users, that service exists in the user's account. The core of a service is a combination of the provider tag, the user's account number, and the user's device registration tag. This creates a dendritic path for the service definitions and rules for that user.
[0486] For example, the sender may use a mobile with rules set to allow interactive or automatic transfer. The recipient may set their device to allow automatic transfer. In this case, the sender's device only performs the steps to make the automatic transfer. The service tag does not include information on whether the transfer is interactive or not. This remains information about the service stored on the sender's and recipient's servers.
[0487] If the recipient has configured their device to allow two-way or automatic transfers, the originator's device will request from the originator which mode to use. The recipient may configure their device to allow automatic transfers during certain times, and two-way transfers at other times. The recipient's Tereon server then simply informs the originator's server which transfer mode to use depending on the recipient's time.
[0488] If the originator or recipient's device only accepts two-way transfers, then when the recipient and originator are online at the same time, they perform the steps to execute the transfer. If the recipient only has a card, he must go to a merchant terminal to execute his side of the transaction. If the recipient is offline, the originator performs the steps, but the recipient must perform steps in the transaction, such as accepting the transfer and entering a PIN, before Tereon can complete the transfer. Until then, Tereon holds the transfer in an escrow facility in the same manner it handles transfers to non-Tereon users.
[0489] Dynamic interfaces The extensible framework drives context-sensitive services (e.g., offers, helping users get seated at an event, merchant-specific processes, etc.) This allows organizations to specify the services and experience each user has when they interact with Tereon, the degree to which services are available depending on the context, buttons displayed, options available, etc.
[0490] The number of services with which each user and each merchant can interact depends entirely on the overlap between the services that each individual user can access and the services that the merchant can offer.
[0491] For example, if a merchant offers payments, deposits, and withdrawals, and a user visits the merchant and the user only has access to payments for the merchant, the user and merchant will only see the functionality related to payments, i.e., payments and refunds. If the user visits the same merchant, the user will have access to payments, deposits, and withdrawals, and the user will see all the functionality. If the merchant does not have enough funds to support deposits and withdrawals, when a full-service user visits the merchant, the user will only see the payment functionality on his or her device or the merchant's terminal. The merchant will also no longer appear in searches for merchants offering to deposit or withdraw to the merchant. A user may not have access to certain services of some merchants, but may have access to services of other merchants. The framework handles such cases.
[0492] Dynamic interfaces complement the use of multi-faceted credentials and allow devices and associated applications to resemble "psychic paper" as has been mentioned, where the device only offers the services available and regardless of the multiple services to which the user is registered, the interface is tailored to such services. It can appear as a payment device for some services, a transport ticket for other services, a door key for other services, etc. Service providers can reduce the complexity and cost of service provision and upgrades since they do not need to issue separate devices to access the services.
[0493] The extensible framework allows a device to change its appearance and provide the credentials and services required depending on the context the device is used in. For example, when a user accesses a standalone ATM, such as one at a grocery store, the ATM's screen can adjust to take on the look and feel of the user's operator and provide only the services to which the user has subscribed.
[0494] Interaction with other layers The ability of the extensible framework to interact with other components in the Tereon system is a fundamental feature of the extensible framework. Apart from contextual security, which includes a broader security model, extensible framework instructions can be embedded within transaction information transmitted over hash chains (as started with hash chains with zero-knowledge proofs).
[0495] Off-line mode Tereon provides three offline modes: User offline, Merchant offline, and Both offline.
[0496] In the first two cases, Tereon travels in the opposite direction of the square to complete the real-time transaction: the user communicates with his Tereon server through the merchant terminal and the merchant's Tereon server. No merchant or user experiences any degradation of service. Tereon uses the PAKE protocol, or a protocol with similar functionality, to create a secure path through three sides of the square to the relevant devices.
[0497] In the third case, where two devices are offline, an immediate withdrawal would create a credit risk exposure that Tereon is designed to overcome, since Tereon would not be able to verify in real time whether a user or merchant has sufficient funds to support a transaction.
[0498] Using an extensible framework feature and a version of the hash chain, Tereon allows the system to continuously verify funds. Both users and merchants can perform all of their functions. The user must use a mobile or microprocessor card, but neither the user nor the merchant sees any degradation in service they experience. Both the merchant device and the user device store encrypted details of the transactions between them, as well as a random sample of previous offline transactions made by the merchant. The merchant device sets the maximum number of copies of each transaction that are transmitted to the user's card or phone.
[0499] Tereon uses a combination of business logic, security model and hash chain to ensure that a user does not use a combination of offline and online devices to withdraw more money than exists in the account. If the account provides credit functionality, the account only supports offline devices. Offline logic does not require credit, but permission to provide credit may be required by the service provider's regulator.
[0500] If a device is not authorized to operate offline, it cannot transact with other devices when offline - the security and authentication model prevents it from doing so, as the device's signature identifies it as supporting online transactions, and the device cannot process any transactions that would affect the value of any registered accounts.
[0501] If the device can support offline transactions, the service provider limits this to a certain amount of the offline allowance (a credit limit or a portion of the account balance that is updated whenever the device is online). The device only accepts transfers or payments of funds from the account in the total amount or the relevant offline allowance. Of course, the service provider can authorize the device to accept transfers or funds and may limit such accepted value (offline acceptance allowance). When the first device accesses the account while offline, either directly through the portal or to another online device, the user only accepts account transfers or payments up to the account balance minus the offline allowance.
[0502] Tereon reconciles all offline transactions when one of the devices containing the relevant records comes online, and of course it receives copies of some transactions, which it can use to check previous reconciliations.
[0503] Thus, when a server receives records from third-party servers of offline transactions for transfers or payments to an offline device, it processes the transactions and adds the funds to the account balance if it receives sufficient copies of the transactions. Similarly, when a server receives records from third-party servers of offline transactions for payments or transfers from an offline device, it processes the transactions and adds the funds to the account balance if it receives sufficient copies of the transactions.
[0504] The diagrams above are shown for payments, but because they are easy to visualize, the same operation modes may be applied to all types of transaction systems. One example is the interaction between IoT devices or other industrial components. By creating workflows that include rearrangeable, insertable, or removable modules, operators can reconfigure devices to work in new ways without the need to reprogram and reinstall them.
[0505] Operators can change the purpose of devices in the field, change the way they operate, or have devices control different devices and modify workflows based on changes detected in the environment in which the device operates.
[0506] IoT devices may also modify each other's workflows as needed by modifying the assembly of modules that make up the workflow. The security model governing inter-device communication insulates the communication against man-in-the-middle attacks, while the lookup service allows devices to identify and authenticate each other.
[0507] The offline mode allows such devices to operate autonomously or semi-automatically and interoperate with each other, verifying and validating all transactions between them and interacting with the operator's system as necessary.
[0508] The contextual security model described below extends to all types of devices, such as IOT devices. As long as the device is authorized to operate and the device's services are listed in the relevant lookup service, it can communicate with any device or other devices, each using hash chains to trust and validate transactions and data communications between devices, each containing instructions to modify the device's workflow, upgrade the device's systems, or simply transfer or collate data between the systems. Each device maintains a complete audit of transactions.
[0509] Security The Tereon system uses several unique security models that overcome the deficiencies and limitations present in current security models and protocols used in legacy transaction processing systems. For example, the security models eliminate the need to store data on the device, which is a major issue with existing systems.
[0510] Securing USSD USSD (unstructured supplementary service data) is commonly used as a communication channel for various transaction types, including payments, to and from feature phones, and Tereon enables USSD securely.
[0511] Many implementations require users to enter a USSD code or select an action from a pre-numbered menu, with a string of unencrypted messages moving back and forth. This creates costs, reduced security, and issues with poor user experience.
[0512] Instead of sending messages in 7-bit or 8-bit text, which creates security issues, Tereon uses USSD and similar communication channels in a new way: Tereon simply sees it as a session-based short-burst communications channel.
[0513] Tereon does not tailor messages for USSD, which is how existing systems work. Instead, for each encrypted communication in a transaction session, Tereon encrypts the communication as it would over TCP / IP (GPRS, 3G, 4G, WiFi, etc.) to generate a ciphertext, and encodes the ciphertext into a base 64-bit string. Tereon then checks the length of the ciphertext. If it is longer than the allowed space in a USSD message, it splits the ciphertext into two or more parts and sends these separately using USSD. At the other end, Tereon recomposes the parts into a whole string, converts this into ciphertext, and decrypts it.
[0514] With this method, Tereon first uses transport layer security (TLS) to identify and authenticate the parties, generating a first session key, which Tereon may then use to encrypt the PAKE protocol negotiation that generates a second session key that the parties use to encrypt all subsequent communications in the session.
[0515] Some feature phones support WAP (wireless application protocol). If such an implementation uses WAP over USSD, Tereon uses the WAP protocol stack as a way to communicate over USSD. This provides a WTLS (wireless transport layer security) layer that simply acts as an additional authentication level (this is weaker than the TLS and Advanced Encryption Standard 256 (AES256) that Tereon uses as a base, so Tereon uses AES256 to encrypt communications in all events).
[0516] This is also how Tereon secures other communication channels that lack security (e.g. NFC, Bluetooth, etc.) By carefully configuring messaging sessions, the nature of USSD and other "insecure" channels can be completely changed.
[0517] Security model for active devices (and the Internet of Things) The security model for active devices such as mobiles, card terminals etc. works in the same way as the security model for cards (see below). SIMs are not used as their security algorithms have previously been cracked. Instead, a registration key stored encrypted on the device is used along with a unique key generated by the network. On the mobile device, Tereon can use this key to look up and verify that the international mobile subscriber identity (IMSI) reported by the mobile is genuine.
[0518] The first time a user runs an application (a user may have multiple applications if desired), the application requests a one-time authentication code that the Tereon server generates for the user's account along with the device's mobile number or serial number (if the application is unable to verify that number initially). A user may register his or her application with multiple Tereon servers, where each server generates a unique one-time activation code for each account or service that server runs for the user.
[0519] When the user enters the one-time activation code, the application uses that code as a shared secret between it and the server (optionally after the application and the Tereon server validate each other using TLS or a similar protocol) to create a first PAKE session. Once it has established the first PAKE session, the Tereon server sends a cryptographically signed registration key to the application along with the new shared secret. Both the server and the application use the one-time activation code, registration key, and shared secret to generate a new shared secret by generating a hash of the one-time activation code, registration key, and shared secret.
[0520] Every time a server and an application communicate, they generate a shared secret by hashing the previous shared secret with the hash of the previous message communicated between them in the online communication. Every time an application and a server communicate with each other, they generate a hash of the previous exchange and the contents of the transaction they exchanged (a transaction hash). They both use this transaction hash to generate a new shared secret.
[0521] If a user loses their device, needs to re-register the application, or needs to change devices, the Tereon server generates a new one-time authentication code and registration key. The new shared secret that the server communicates to the application is generated from a hash of the previous messages exchanged between the server and the application.
[0522] This key propagation ensures that the application and the Tereon server have a new shared secret for each PAKE session. Thus, if an attacker can break the TLS session (very difficult when the server and application sign messages), the attacker still needs to break the PAKE session key. If the parties managed the feat, it would give them the keys for the session. The process of generating a new key for each communication would mean that the parties would have to repeat the feat for each communication, which is practically incomputable.
[0523] The application is authenticated to a specific service for every session, so the user's application only interacts with that service. The server does not know about other services for which the user's application is registered. In effect, the application becomes something akin to "psychic paper," an identification device that provides only the credentials required for a service, regardless of the multiple services for which the user may be registered. It can appear as a payment device for some services, a transport ticket for other services, a door key for other services, etc. Service providers do not need to issue separate devices to access the service, reducing the complexity and cost of service provision and upgrades.
[0524] The security model has an added benefit: if a user loses their device, they can get a new device with the exact same number. The old device with the application will not work, but the new device, once registered, will work because it has a valid private key and registration code. It will take time to report the lost device, but no one will be able to make transactions because they do not have the necessary password and PIN or other authentication token.
[0525] Before a user can access an application, the user or a Tereon system administrator may configure the application to require a password. This password is checked with the Tereon server. If valid, the Tereon server instructs the application to operate (always with signed and encrypted communications). If the password is invalid, the Tereon server instructs the application to request a new password after a limited number of attempts. The Tereon server then locks out the user's application and the user must contact an administrator to unlock the application and re-register the device.
[0526] Each credential is timed, meaning that a user is assigned a particular credential for a defined period of time, and all transactions that occur with that credential during that period are linked to that user. If that user changes the credential, the original credential is assigned to another user. However, the lookup server continues to link the transactions to the credential based on the combination of the credential and the period registered with that credential.
[0527] The same model can be adopted to secure communication between devices in the "IoT", where each device can be identified using a certificate or a serial number built into the hardware. When this is hashed with the transaction date or previous message sent between the devices, it becomes the first shared secret that each device swaps on first contact. Two numbers may be used: a public serial number that can identify the device, acting as a substitute for a PKI (public key infrastructure) certificate, and a cryptographically protected serial number that acts as the shared secret. Alternatively, a single serial number may be used as the ID and first shared secret, and a new private key may be uploaded over a secure communication channel (see discussion of the communication layers in the system architecture).
[0528] Tereon's mobile security model has other advantages: operators set access privileges for individual services and use it to configure the level of access according to the device and network a particular user is attempting to use that service on. For example, a provider may specify that administrators can only access system administration functions over the Internet network, view system logs over a shared security network via fixed devices and not mobile devices.
[0529] While this functionality has some applications in payments (ensuring access to system administration functions for defined networks and devices), it is also provided for other services that require restricted access to sensitive or privileged content, allowing users to control exactly what specific data can be viewed, who can see it, what data such third parties can view, and where they can view it.
[0530] The security model allows organizations to ensure the privacy and security of all data collected, generated or transmitted by any device, from all devices, transactions and payments to medical devices, traffic sensors, weather sensors, water flow detectors and more.
[0531] Cardsecurity model EMV cards and mobiles that use host card emulation store the PIN on the chip or mobile security element. Contactless cards and mobiles that emulate these cards also store most of the card details in a clear and easily readable format. The card terminal checks the PIN entered by the user against the PIN stored on the card. This exposes many weaknesses in the EMV system and leaves the EMV process open to well-documented attacks.
[0532] Tereon stores only an authentication key on the card and verifies the entered value against a value stored in the Tereon service (a security area of a database closed to administrators who only verify that the value does not match the actual value), which authenticates the service and the specific function, resource, facility, or transaction type or other type of service provided by the service. Tereon uses two security models, one of which is a subset of the other.
[0533] Many cards display a PAN (a long number). Tereon does not use this number to identify an account. Rather, it uses the PAN in a manner similar to a mobile number. It is simply an access credential. Each card has an encrypted PAN. The card has an encrypted registration key that identifies it as valid for each service it is registered with, in the same way that a registration key for a mobile authenticates the device. The encrypted code has a prefix that indicates the country look-up directory service that the merchant's Tereon service should request if it does not already have address details for the encrypted PAN string registered with the Tereon service.
[0534] When the user presents the card to a terminal, the terminal reads the encrypted PAN and validates the card at the card's registered terminal using the encrypted registration key. Once the user's Tereon service has verified and authenticated the card and the merchant's Tereon service, the user service transmits the PAN in unencrypted form to the merchant's Tereon service, where it may cache it in encrypted form. Thus, when the user later enters the PAN in the clear via an e-commerce portal or a merchant's terminal, the service will know which other services to contact.
[0535] If the card-reading device cannot read the card for any reason, the user or merchant enters a PAN and the merchant's Tereon service uses this PAN to obtain the address of the user's Tereon service. The card's PAN is only one of many credentials a user can have.
[0536] Once the merchant's Tereon service authenticates the card, the merchant's terminal sets up TLS with the hashed key, then sets up a PAKE session with the Tereon service using the hashed key (each time the terminal communicates with the service it generates a new shared secret for the PAKE session by hashing the previous key as the registration key). The merchant process continues until the merchant's terminal requests a PIN (if the user requires a PIN for the transaction, as determined by the payment service provider and specified in the Tereon service's business rules engine). The user's Tereon service creates a PAKE session with the merchant's service, then sends the nonce key to the merchant's service and sends the message encrypted over another PAKE session, first created using TLS, to the terminal.
[0537] The merchant terminal receives the key and decrypts the message to display text selected by the user (indicating that the terminal is authorized by the merchant's service). The user enters their PIN, which is communicated to the user's service via the terminal's PAKE session. This process only occurs when the user has to enter their PIN into the merchant terminal. The merchant terminal does not see the PIN in the clear because it is entered into a security app (which the merchant terminal accesses from the user's Tereon service and is encrypted to a second one-time key that the user's service sends to the terminal in a secure signed key exchange). All communication is typically done by the merchant's service, and direct communication between the terminal and the user's Tereon service is established where the terminal can assist in its functions.
[0538] If the card is a micro-processor card (Chip&PIN, contactless, or both), the card may have a shared secret that is initially generated at the time of issuance. The micro-processor card uses PAKE to establish a session with a registered Tereon service (or service for a service) along with a session established by the card terminal with the Tereon service (which could be a mobile tablet or a PoS card terminal). This immediately eliminates the main vulnerability that existing terminals and Chip&PIN cards present - the vulnerability of existing infrastructure to disrupt and subvert the PIN verification process via multiple "man-in-the-middle" or "wedge" attacks.
[0539] The card uses this channel to generate a key that it sends to the service, which the service sends to the merchant terminal to encrypt the PIN. It uses this channel to facilitate offline transactions, when the card stores the balance from the last online transaction, a key to use as a seed to generate a set of keys to use for offline transactions, and a record of third-party offline transactions.
[0540] If a card is lost or stolen, Tereon's security model means that issuers do not need to issue a new PAN. Context based security Many security protocols use some credentials and are based on fundamental assumptions that are open to errors and security compromises. The Tereon system does not rely on any fundamental assumptions other than that without it the communications network is insecure and unreliable, and that the environment in which the device operates is also insecure.
[0541] The Tereon system goes through various stages to validate every set of credentials and the context they are presented in. This provides additional security and ensures that organizations have one way to allow employees or constituents to use their own devices (also known as BYOD) in some or all situations.
[0542] Tereon uses information such as the user's password, PIN, or other direct authentication credentials, as well as details of the device, the application on the device, the network through which the device accesses Tereon, the geographic location of the device at the time of the session, and the services or information from which the user is accessing the device.
[0543] Tereon receives the credentials and controls access to information granting the appropriate access level for the credentials based on the credentials and the established context.
[0544] For example, an administrator attempting to access a deep management service on a personal device that is not authorized by Tereon will be blocked from that service, regardless of whether the administrator is on a work or corporate network, yet that same administrator has permission to view parts of the system log of the same device.
[0545] A second example is where the context security model governs what services a secondary user can see. The user has a mobile or card that offers various features like deposits, withdrawals and payments with no set limits (up to a credit limit or maximum available amount). The user has visited a café many times and always bought a coffee and an almond croissant. Now the user has given his card to his son and set a total limit of 40 GBP for the card. The user has set a second PIN for the son's use who will take the card to the same café to buy coffee. Since he has already bought 6 in the past, the Tereon system would typically offer the user a free almond croissant and the café uses Tereon to communicate that offer to its customers. However, when the user's son enters his PIN, the Tereon system detects that it is the user's son who is paying (who does not know his father's PIN) and as he has a peanut allergy, the offer for today is blocked since the father has connected his son's PIN with his son's profile. The merchant can't see the notification for the free croissant offer, and Tereon knows the user's son can't eat nuts, what the merchant can see is the payment for the coffee.
[0546] The user has allowed his son to withdraw cash up to £10 but has not allowed him to deposit funds. So when the user's son goes into a merchant that can offer withdrawals of up to £10, he will be able to see the merchant options.
[0547] Context-based security goes beyond access control. Depending on the context in which a user presents or uses a device, the device provides only the credentials required for that context. This is the "psychic paper." In this manner, the directory service 216 provides functionality that can support context-based security.
[0548] Context-based security removes the need for separate credentials and devices for specific contexts - now a single device can be your library card credential at the library, your transport ticket for a bus or train, your security key to access a room or facility, your in-house payment device in the office canteen, your theatre ticket, your standard payment device in the supermarket, your driving licence, your NHS card, your ID card to prove entitlement to a service (you can present your photo ID to the merchant's device if the service is required), etc.
[0549] Tereon allows administrators or users to modify, add, or revoke authorized contexts and credentials in real time to provide dynamic, real-time transaction processing and payments. Modifications are immediately reflected in the Tereon server providing the service, or in the lookup directory service 216, or both. Lost devices do not pose any further financial or identity exposure risk until the current system deactivates the device. When a user or administrator revokes or modifies a credential or context, the changes are immediately activated.
[0550] One touch transaction Tereon enables a one-button transaction authorisation and access method that removes security gaps in existing systems. For example, current no PIN or NPC payments are extremely risky as they provide no authentication for payments. The user is responsible for all payments until the card issuer revokes the mobile or card credential in the contactless EMV system. If the device is revoked by the issuer, the consumer still has to prove that they have not activated the payment. How can payments be done if they do not require a PIN for authentication? This leaves a big hole that allows someone to pick up a contactless card or mobile and simply tap to pay. The device will continue to be valid until it is revoked.
[0551] Tereon supports tap-and-go in one of three modes, each of which depends on the context for operation. One of these provides a one-touch transaction using a personally identifying access method. Once the user and service provider agree that the level of authentication provided is satisfactory, the system offers a one-touch authentication method, where the device displays a large button or configures a large area on the screen for the user to touch. The other modes are a traditional contactless transaction where the user does not enter any credentials, and a fully contactless mode where the user enters standard payment credentials after the devices have identified each other.
[0552] The button or area itself provides authentication via the touch screen. Every individual presses the screen in a unique way, in terms of where they press and the pressure pattern they use. When an individual attempts to use this feature, Tereon asks the individual to press the button or area multiple times until it sees their signature press. The screen is logically divided into several individual cells, and Tereon looks at the proximity and pattern of cells the user touches during a training period, and if possible, verifies the pressure patterns and device movements that occur as the user presses. This data is then used to monitor to create a profile that is used to authenticate the user.
[0553] FIG. 21 illustrates a block diagram of one implementation of a computing device 2100 on which a set of instructions for performing any one or more of the methods described above can be executed. In an alternative implementation, the computing device is connected (e.g., networked) to other machines in a local area network (LAN), an intranet, an extranet, or the Internet. The computing device may operate in the capacity of a server or a client machine in a client-server network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The computing device may be a PC, a tablet computer, a set-top box (STB), a personal digital assistant (PDA), a cellular telephone, a web appliance, a server, a network router, a switch or bridge, a processor, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by the machine. Also, although one computing device is illustrated, the term "computing device" shall be used to include any collection of machines (e.g., computers) that individually or in common execute a set (or sets) of instructions for performing any one of the described methods.
[0554] The exemplary computing device 2100 includes a processing device 2102, a main memory 2104 (e.g., read-only memory (ROM), flash memory, DRAM such as synchronous DRAM (SDRAM) or Rambus DRAM (RDRAM)), a static memory 2106 (e.g., flash memory, static random access memory (SRAM)), and a secondary memory (e.g., data storage device) 2118, which communicate via a bus 2130.
[0555] The processing device 2102 may represent one or more general-purpose processors, such as a microprocessor, a central processing device, or the like. In particular, the processing device 2102 may be a complex instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction word (VLIW) microprocessor, a processor implementing other instruction sets, or a processor implementing a combination of instruction sets. The processing device 2102 may also be one or more special-purpose processing devices, such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), a network processor, or the like. The processing device 2102 is configured to execute processing logic (instructions 2122) for performing the operations and steps described herein.
[0556] The computing device 2100 may further include a network interface device 2108. The computing device 2100 may also include a video display unit 2110 (e.g., a liquid crystal display (LCD), a cathode ray tube (CRT)), an alphanumeric input device 2112 (e.g., a keyboard or touch screen), a cursor control device 2114 (e.g., a mouse or touch screen), and an audio device 2116 (e.g., speakers).
[0557] The data storage device 2118 may include one or more machine) readable storage media 2128, or, more specifically, one or more non-transitory computer) readable storage media, on which is stored one or more sets of instructions 2122 that implement any one or more of the methods or functions described above. The instructions 2122 may reside completely or at least partially within the main memory 2104 and / or the processing device 2102 while being executed by the computer system 2100, the main memory 2104, and the processing device 2102 constituting the computer readable storage media.
[0558] The various methods described above may be implemented by a computer program. The computer program may include computer code configured to instruct to perform the functions of one or more of the various methods described above. The computer program and / or code for performing such methods may be provided on a device such as a computer, on one or more computer readable recording media, or, more generally, on a computer program product. The computer readable recording media may be transitory or non-transitory. For example, the one or more computer readable recording media may be electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, or a radio wave medium for data transmission (e.g., downloading code via the Internet). Alternatively, the one or more computer readable recording media may be semiconductor or solid state memory, magnetic tape, removable computer diskettes, RAM (random access memory), or the like. A computer-readable medium may take the form of one or more physical computer-readable recording media, such as a hard disk, a hard disk drive, a hard disk drive (HDD), a hard disk drive (HDS ...
[0559] In one embodiment, the modules, components and other features described herein may be embodied as individual components or integrated into the functionality of a hardware component such as an ASICS, FPGA, DSP or similar device as part of a personalized server.
[0560] A "hardware component" is a type of (e.g., non-transitory) physical component (e.g., a set of one or more processors) that can perform specific operations and may be configured or arranged in a specific physical manner. A hardware component may include dedicated circuitry or logic that is permanently configured to perform specific operations. A hardware component may also include special purpose processors such as field programmable gate arrays (FPGAs) or ASICs. A hardware component may also include programmable logic or circuitry that is temporarily configured by software to perform specific operations.
[0561] Thus, the phrase "hardware component" should be understood to include any type of entity that is physically configured, permanently configured (e.g., built into hardware), or temporarily configured (e.g., programmed) to operate in a particular manner or perform particular described operations.
[0562] A machine may be, for example, a physical machine, a logical machine, a virtual machine, a container, or any mechanism commonly used to contain executable code. A machine may be a single machine, or may refer to multiple connected or distributed machines, whether the machines are of the same type or multiple types.
[0563] The modules and components may be implemented in firmware or functional circuitry within a hardware device, or they may be implemented in any combination of hardware devices and software components, or solely in software (e.g., code stored or embodied on a machine-readable medium or transmission medium).
[0564] Unless otherwise stated, and as will be apparent from the following description, terms such as "sending," "receiving," "determining," "comparing," "enabling," "maintaining," "identifying," and the like refer to operations and processes of a computer system or similar electronic computing device (manipulating and transforming data represented as physical (electronic) quantities in the computer system's registers and memory into other data similarly represented as physical quantities in the computer system's memory or registers or other information storage), transmission or display device.
[0565] It should be understood that the above description is illustrative and not restrictive. Many different implementations will become apparent to those skilled in the art upon reading and understanding the above description. Although the present invention has been described with reference to certain exemplary implementations, it should be understood that the present invention is not limited to the described embodiments, but can be practiced with modification and alteration within the spirit and scope of the appended claims. Accordingly, the specification and drawings are to be regarded in an illustrative rather than restrictive sense. The scope of the present invention should therefore be determined with reference to the appended claims, along with the full scope of equivalents to which such claims are entitled.
[0566] All optional features of the various aspects relate to all other aspects. Variations of the described embodiments are contemplated, for example features of all the embodiments disclosed may be combined in any manner.
Claims
1. 1. A method for recording data transactions in a device associated with a first entity, comprising: determining first seed data; creating a record of a first data transaction between the first entity and a second entity; combining at least the first seed data and records of the first data transactions to determine second seed data; hashing the second seed data to generate a first hash, the first hash including a history of data transactions associated with the first entity; storing the first hash for the record of the first data transaction in a memory; A data transaction recording method including:
2. The method of claim 1 , wherein the first seed data includes a starting hash.
3. 3. The method of claim 2, wherein the starting hash is a result of hashing a record of a previous data transaction associated with the first entity.
4. The method of claim 2 , wherein the starting hash comprises a random hash.
5. 5. The method of claim 4, wherein the random hash includes at least one of a signature from the device, a date the random hash was generated, and a time the random hash was generated.
6. providing second seed data further comprises combining the first seed data and the record of the first data transaction with a first zero-knowledge proof and a second zero-knowledge proof; the first zero-knowledge proof includes a proof that the initiation hash includes a true hash of the previous data transaction associated with the first entity; 6. The method of claim 1, wherein the second zero-knowledge proof includes a proof that a second hash contains the true hash of a previous data transaction associated with the second entity.
7. 7. The method of claim 6, wherein providing second seed data further comprises combining the first seed data, the record of the first data transaction, the first zero-knowledge proof, and the second zero-knowledge proof with a third zero-knowledge proof.
8. The method of claim 7 , wherein the third zero-knowledge proof is generated from random data.
9. The data transaction recording method according to claim 7 , wherein the third zero-knowledge proof is a repetition of the first zero-knowledge proof or the second zero-knowledge proof.
10. 8. The method of claim 7, wherein the third zero-knowledge proof is constructed using a second record of the first data transaction corresponding to the second zero-knowledge proof.
11. the first data transaction includes at least two stages; The step of providing second seed data includes: combining the first stage record of the first data transaction with the first zero-knowledge proof; combining the second stage record of the first data transaction with the second zero-knowledge proof; 7. The data transaction recording method of claim 6, comprising:
12. The step of providing second seed data includes: constructing a third zero-knowledge proof from records of the second stage of the first data transaction; combining the second stage record of the first data transaction with the second zero-knowledge proof and the third zero-knowledge proof; 12. The data transaction recording method of claim 11, comprising:
13. the first data transaction includes at least three stages; The step of providing second seed data includes: combining the third stage record of the first data transaction with the first zero-knowledge proof; combining the third stage record of the first data transaction with the third zero-knowledge proof; The data transaction recording method of claim 11 , further comprising:
14. the first data transaction includes at least three stages; The step of providing second seed data includes: combining the third stage record of the first data transaction with the first zero-knowledge proof; combining random data with the third zero-knowledge proof; The data transaction recording method of claim 11 , further comprising:
15. the first data transaction includes at least three stages; The step of providing second seed data includes: combining the third stage record of the first data transaction with the first zero-knowledge proof; combining a fourth stage record of the first data transaction with the second zero-knowledge proof; Including, 12. The method of claim 11, wherein the fourth stage of the first data transaction is a repeat of the third stage of the first data transaction.
16. the first data transaction includes at least three stages; 12. The method of claim 11, wherein providing second seed data further comprises combining a record of the third stage of the first data transaction with a third zero-knowledge proof.
17. the first zero-knowledge proof is constructed by the device associated with the first entity; 17. The method of claim 6, wherein the second zero-knowledge proof is constructed by a device associated with the second entity.
18. 20. The method of claim 17, wherein constructing the first zero-knowledge proof and the second zero-knowledge proof comprises using a key exchange algorithm.
19. 20. The method of claim 18, wherein the key exchange algorithm comprises a PAKE algorithm.
20. transmitting the first hash to a device associated with the second entity; receiving a second hash from a device associated with the second entity, the second hash including a hash of a previous data transaction associated with the second entity; creating a record of a second data transaction between the first party and the second party; combining the first hash and the second hash with the record of the second data transaction to determine third seed data; hashing the third seed data to generate a third hash, the third hash including a history of data transactions associated with the first entity and a history of data transactions associated with the second entity; storing the third hash for the record of the second data transaction in the memory; 20. The method of claim 1, further comprising:
21. The step of providing the third seed data includes: combining the record, the first hash, and the second hash of the second data transaction with a third zero-knowledge proof and a fourth zero-knowledge proof; the third zero-knowledge proof includes a proof that the first hash includes a true hash of the first data transaction; 21. The method of claim 20, wherein the fourth zero-knowledge proof includes a proof that the second hash includes the true hash of the previous data transaction associated with the second entity.
22. 22. A method according to claim 20 or claim 21, wherein the previous data transaction relating to the second entity is the first data transaction.
23. 23. A method according to any preceding claim, further comprising the step of associating each of the hashes with an identifier of at least one of the first entity and the second entity.
24. recalculating the first hash; comparing the generated first hash to the recomputed second hash to determine a match; 24. The method of claim 1, further comprising:
25. 25. The method of claim 24, further comprising the step of cancelling the additional data transaction if the comparison is unsuccessful.
26. 26. The method of claim 1, further comprising the step of generating a system hash in a system device corresponding to the first data transaction.
27. 27. The method of claim 26, wherein providing second seed data further comprises combining the system hash with the first seed data and the record of the first data transaction.
28. 28. A method according to claim 26 or claim 27, wherein the system hash is the result of hashing a record of previous data transactions on the system device.
29. The step of providing second seed data includes: receiving a license hash from a licensed device; combining the first seed data and the record and the license hash of the first data transaction to provide the second seed data; 29. The method of claim 1, further comprising:
30. In the licensed device, receiving the first hash; combining the license hash and the first hash to provide a license input; hashing the license input to generate a second license hash; 30. The data transaction recording method of claim 29, further comprising:
31. The step of providing second seed data includes: receiving a directory hash from a directory device; combining the first seed data and the record and the directory hash of the first data transaction to provide the second seed data; 31. The method of claim 1, further comprising:
32. In the directory server, receiving the first hash; combining the directory hash and the first hash to provide a directory entry; hashing the directory entry to generate a second directory hash; 32. The method of claim 31 further comprising:
33. The step of providing second seed data includes: generating a key hash from an encryption key for the first data transaction; combining the first seed data and the record and the key hash of the first data transaction to provide the second seed data; 33. The method of claim 1, further comprising:
34. 34. The method of claim 33, wherein the encryption key comprises a public key or a private key.
35. 35. A method according to any one of claims 1 to 34, wherein the step of combining the first seed data and the record of the first data transaction is performed as soon as the first data transaction is completed.
36. 36. A method according to any preceding claim, wherein the memory is located in a remote device.
37. 37. The method of claim 36, further comprising the step of comparing at the remote device the first hash with hashes received from other devices.
38. 38. A method of recording data transactions as claimed in claim 36 or claim 37, further comprising the step of notifying other devices connected to the device to expect to receive the first hash.
39. 39. A method according to any preceding claim, further comprising storing a chain of hashes in said memory.
40. 40. The method of claim 39, further comprising transmitting the chain of hashes to a second memory located on a device configured to restrict access to the transmitted chain of hashes.
41. modifying or deleting a hash in the chain of hashes; 2. The method of claim 1, further comprising: regenerating the target hash in the chain of hashes; checking whether the record has been modified; recording the regenerated hash; modifying or deleting said record; hashing the combination of the hashes of the objects and the modified and deleted records to generate new hashes for the records; recording the new hash; 41. The data transaction recording method according to claim 39 or 40, comprising:
42. 42. The method of claim 41, further comprising the step of generating a system hash using the new hash.
43. A device associated with a first entity, said device configured to perform a method according to any one of claims 1 to 42.
44. The device of claim 43, wherein the device comprises a server.
45. The device of claim 43 , wherein the device comprises a user device.
46. 46. The device of claim 45, wherein the user device comprises at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things (IoT) enabled device.
47. 47. The device of claim 46, wherein the user device stores the first hash in a memory on the device.
48. 48. The device of claim 47, wherein the user device stores the first hash in memory on the device only if the user device is offline from an appropriate server.
49. 49. The device of any one of claims 43 to 48, wherein the device transmits the first hash to a device associated with the second entity.
50. the device transmits a signed and encrypted copy of the record of the first data transaction to the device associated with the second entity; 50. The device of claim 49, wherein the signature includes an indication of a destination server for the record of the first data transaction.
51. 51. The device of claim 50, wherein the device signs the record with a particular offline public key.
52. 51. The device of claim 50, wherein the device signs the record with a key belonging to the device.
53. 53. A device according to any one of claims 50 to 52, wherein only the destination server can decrypt the encrypted copy of the record of the first data transaction.
54. 54. The device of any one of claims 48 to 53, wherein when the device regains connection to a corresponding server, the device transmits the associated hashes and the encrypted records of its offline data transactions to the corresponding server.
55. 55. The device of claim 54, wherein the device transmits copies of records of data transactions held by the device relating to other entities to a server corresponding to the device for transmission to the server corresponding to the other entities.
56. 56. The device of claim 55, wherein said sending comprises notifying all servers to which said record applies in expectation of receiving said record.
57. 57. A device according to any one of claims 43 to 56, wherein the device generates a unique internal transaction number to identify this part in the first data transaction.
58. A licensed device, comprising: receiving a first hash from a device associated with a first entity, the first hash including a history of data transactions associated with the first entity; combining the first hash with a license hash to provide a license input; hashing the license input to generate a second license hash; and storing the second license hash in a memory.
59. A directory device, receiving a first hash from a device associated with a first entity, the first hash including a history of data transactions associated with the first entity; combining the first hash with a directory hash to provide a directory entry; hashing the license entry to generate a second directory hash; storing the second directory hash in a memory.
60. A computer readable medium comprising a number of code portions which, when executed, cause a computing device to carry out the method of any one of claims 1 to 42.
61. 1. A method for accessing a first service from a device, comprising: providing an identifier of said device to a requesting server; authorizing the device to request access to the first service based on the identifier; causing the device to access the first service from a first host server on which the first service is located, the access being via the request server; The method includes:
62. 62. The method of claim 61, wherein the step of authorizing comprises determining whether the user device is authorized to access the first service based on the identifier.
63. 63. The method of claim 62, wherein the step of verifying includes verifying whether the user satisfies at least one criteria based on the identifier.
64. 64. The method of claim 63, wherein a first criterion is stored on the first host server or the requesting server and a second criterion is located on another server.
65. 65. A method according to any one of claims 61 to 64, wherein the authorising step comprises verifying a signature on communications between the request server and the first host server.
66. 66. A method according to any one of claims 61 to 65, wherein the step of authorising is performed at the request server.
67. 67. The method of claim 66, wherein the step of authorizing includes determining at the request server whether the device has been previously authorized to access the first service.
68. 66. A method according to any one of claims 61 to 65, wherein the authorising step is performed at a directory server.
69. 70. The method of claim 68, wherein the step of authorizing includes the request server requesting authorization for the device from the directory server.
70. 70. A method according to claim 68 or claim 69, wherein the step of accessing comprises the directory server sending an identifier for the first host server to the requesting server.
71. 71. A method according to any one of claims 68 to 70, wherein said identifier authorising data is stored in said directory server.
72. requesting access to a second service; authorizing the device to access the second service based on the identifier; causing the device to access the second service via the request server; 72. The method of any one of claims 61 to 71, further comprising:
73. 73. The method of claim 72, wherein the second service is located on the first host server.
74. 73. The method of claim 72, wherein the second service is located on a second host server.
75. The step of authorizing the device to access the first service is performed at a first directory server; 75. The method of any one of claims 72 to 74, wherein the step of authorizing the user device to access the second service is performed in a second directory server.
76. requesting access to a third service; authorizing the device to access the third service based on the identifier; causing the device to access the third service; 76. The method of any one of claims 72 to 75, further comprising:
77. 77. The method of claim 76, wherein the second service is located on the first host server, the second host server, or a third host server.
78. 78. The method of claim 76 or claim 77, wherein the step of authorizing the device to access the third service is performed in a third directory server.
79. 79. A method according to any one of claims 61 to 78, wherein providing an identifier comprises the device communicating with the request server via an encrypted tunnel.
80. 80. A method according to any one of claims 61 to 79, further comprising the step of caching the data received at each respective server.
81. 81. A method according to any one of claims 61 to 80, wherein each host server provides two or more services.
82. A device for carrying out the method of any one of claims 61 to 81.
83. 83. The device of claim 82, wherein the device comprises at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things enabled device.
84. A computer readable medium comprising a number of code portions which, when executed, cause a computing device to perform the method of any one of claims 61 to 81.
85. providing a request to switch a first data from a first datastore to a second datastore; determining an identifier for the first data store from a directory server based on an identifier included in the request; migrating the first data from the first datastore to the second datastore; A data migration method comprising:
86. The step of migrating includes, in the directory server, assigning a beginning timestamp to said data in said second data store; assigning an ending timestamp to said data in said first data store; 86. The data migration method of claim 85, comprising:
87. 87. The data migration method of claim 86, further comprising the step of instructing a requesting server attempting to access the data via the first data store after the ending timestamp to search for the user in the second data store via the directory server.
88. the data in the first data store includes a first account registration with a first account provider; 88. A method according to any one of claims 85 to 87, wherein the data in the second data store includes a second account registration with a new account provider.
89. 90. The data migration method of claim 88, wherein said migrating step includes the step of transmitting information regarding said first account registration from said current account provider to said new account provider.
90. 90. The method of claim 89, wherein the information includes at least one of registrations, balances, configurations, and payment instructions.
91. 91. The method of data migration of any one of claims 88 to 90, wherein the step of migrating comprises the step of verifying an authentication code indicating that the first registration should be switched from the current account provider to the new account provider.
92. The first account registration includes first user credentials; 92. A method according to any one of claims 88 to 91, wherein the second account registration includes second user credentials.
93. The first user credentials are registered with a first server; 93. The data migration method of claim 92, wherein the second user credentials are registered with a second server.
94. receiving a communication delivered to a user by the first account provider using the first user credential; routing the communication to the second account provider using the second user credentials; 94. The data migration method of claim 93, further comprising:
95. 95. A method of data migration according to claim 93 or claim 94, further comprising the step of reversing data transactions made with the first registered provider using the first credentials to the second registered provider using the second user credentials.
96. 96. A method of data migration as recited in claim 95, comprising determining that said user used said first user credentials during said transaction.
97. 97. A method according to any one of claims 94 to 96, wherein a server sending the communication must be authorized to have access to the second user credentials.
98. 98. A method according to any one of claims 92 to 97, wherein the first user credentials and the second user credentials are identical.
99. A device for carrying out the method of any one of claims 85 to 98.
100. 100. The device of claim 99, wherein the device comprises at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things enabled device.
101. A computer readable medium comprising a number of code portions which, when executed, cause a computing device to perform the method of any one of claims 85 to 98.
102. transmitting a first communication from a first entity to a second entity, the first communication including two or more data fields, each field including an individual label; transmitting a second communication from the first entity to the second entity, the second communication including the two or more data fields, the second communication having an order of the two or more data fields that is different from an order of the two or more data fields in the first communication; A communication method including:
103. 103. The method of communication of claim 102, further comprising adding a random field to the second communication.
104. Each field contains two or more features, 104. A method of communication according to claim 102 or claim 103, further comprising the step of mixing cases of two or more features in at least one field.
105. 105. A method of communication according to any one of claims 102 to 104, further comprising the step of decrypting and ordering the fields in the second communication by the second entity prior to processing the second communication.
106. 106. The method of claim 105, further comprising discarding fields that cannot be processed by the second entity.
107. 107. The apparatus of any one of claims 102 to 106, wherein at least one of the one entity and the second entity comprises a server.
108. 107. The apparatus of any one of claims 102 to 106, wherein at least one of the first entity and the second entity comprises a personal computer, a smart phone, a smart tablet or an Internet of Things enabled device.
109. A device for carrying out the method of any one of claims 102 to 108.
110. 110. The device of claim 109, wherein the device comprises at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things enabled device.
111. A computer readable medium comprising a number of code portions which, when executed, cause a computing device to perform the method of any one of claims 102 to 108.
112. In a communication method via USSD (unstructured supplementary service data), Releasing a USSD session between the first device and the second device; generating, at the first device, a cipher text for communication in the session; encoding the cipher text at the first device; transmitting the encoded cipher text from the first device to the second device for decryption at the second device; A communication method including:
113. 113. The method of claim 112, wherein said encoding step comprises encoding said cipher text into a 7-bit or 8-bit character string.
114. if the length of the cipher-text is longer than the allowed space in the USSD session; dividing said ciphertext into two or more parts; transmitting the two or more portions separately; 114. The communication method according to claim 112 or claim 113, further comprising:
115. 115. A method of communication as claimed in claim 114, comprising the step of reassembling the parts from the second device into the whole of the ciphertext for decryption at the second device.
116. 116. A method of communication according to any one of claims 112 to 115, further comprising the step of authenticating the first and second devices.
117. 117. The method of claim 116, wherein the authenticating step includes using an algorithm that provides privacy and data integrity between two communicating computer applications.
118. 118. The method of claim 117, wherein authenticating includes using transport layer security (TLS).
119. 119. The method of claim 118, wherein using TLS includes generating a first session key.
120. PAKE protocol negotiation (PAKE) to generate a second session key. using the first session key to encrypt a protocol negotiation; encrypting additional communications in the session between the first device and the second device using the second session key; 120. The communication method of claim 119, further comprising:
121. A device for carrying out the method of any one of claims 112 to 120.
122. A computer readable medium comprising a number of code portions which, when executed, cause a computing device to perform the method of any one of claims 112 to 120.
123. 1. A method of communication between a first device associated with a first entity and a second device associated with a second entity, comprising: creating a first PAKE session between the first device and the second device using a first shared secret; receiving a registration key and a second shared secret from the second device; hashing the first shared secret, the registration key, and the second shared secret to provide a third shared secret for generating a second PAKE session; A communication method including:
124. 124. The method of claim 123, further comprising authenticating the one entity and the second entity.
125. 125. The method of claim 124, wherein the authenticating step includes using an algorithm that provides privacy and data integrity between two communicating computer applications.
126. 126. The method of claim 125, wherein the authenticating step includes using TLS.
127. 127. The method of communications of any one of claims 123 to 126, further comprising generating a second PAKE session between the first device and a third device using a fourth shared secret.
128. 128. The method of claim 127, wherein the fourth shared secret comprises an authentication code generated by the third device for the first device.
129. 129. A method of communication according to any one of claims 123 to 128, wherein the first shared secret comprises an authentication code generated by the second device for the first device.
130. 130. The method of claim 129, wherein the authentication code is transmitted to the first device along with an identifier for the first device.
131. 131. The method of claim 130, wherein the identifier comprises a telephone number or a serial number of the first device.
132. 132. The method of any one of claims 123 to 131, wherein the first shared secret includes a personal account number (PAN) of a bank card associated with the one entity.
133. 132. A method of communication as claimed in any one of claims 123 to 131, wherein the first shared secret comprises an encoded serial number of a bank card associated with the one entity.
134. A device for carrying out the method of any one of claims 123 to 133.
135. 135. The device of claim 134, wherein the device comprises at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things enabled device.
136. A computer readable medium comprising a number of code portions which, when executed, cause a computing device to perform the method of any one of claims 123 to 133.
137. How you access the Service: providing a credential and a context for the credential; authenticating access to the service based on the credentials and the context; The method includes:
138. The step of authenticating access to the service includes:
138. The method of claim 137, comprising authenticating access to a portion of a service based on at least one of the credentials and the context.
139. 139. A method according to claim 137 or claim 138, wherein the credentials include first credentials associated with a device and a primary user of the device.
140. 140. The method of claim 139, wherein the credentials further include second credentials associated with a device and a secondary user of the device.
141. 141. The method of claim 140, wherein authenticating access to the service based on the credentials comprises authenticating access to different services for the primary user and the secondary user based on each of the first and second credentials.
142. 142. The method of claim 141, wherein the device includes different services and bank cards with different spending limits for the primary user and the secondary user.
143. 143. A method according to any one of claims 137 to 142, wherein the credentials are selected based on the context.
144. 144. A method according to any one of claims 137 to 143, wherein the services comprise a plurality of services selected based on the context.
145. A method according to any one of claims 137 to 144, wherein an administrator or user can modify, add or revoke the context or credentials.
146. 146. The method of any one of claims 137 to 145, wherein the credentials include at least one of a password, a PIN, and other direct authentication credentials.
147. 147. The method of any one of claims 137 to 146, wherein the context includes at least one of the device providing the credentials, an application on the device, a network to which the device is connected, a geographic location of the device, and the service being accessed.
148. A device for carrying out the method of any one of claims 137 to 147.
149. 149. The device of claim 148, wherein the device comprises at least one of a personal computer, a smart phone, a smart tablet, or an Internet of Things enabled device.
150. A computer readable medium comprising a number of code portions which, when executed, cause a computing device to perform the method of any one of claims 137 to 147.
151. A method for communication between a plurality of modules in a computer system, comprising: communicating a shared memory channel from the first module to the proxy; communicating the shared memory channel from the proxy to a second module, the proxy including a handoff module for transmitting data between the first module and the second module bypassing the kernel of the computer system; transmitting data from the first module to the second module; A communication method including:
152. batching a plurality of requests into a batched message in a buffer memory of the first module; queuing the batched messages to be sent to the second module; setting at least one system flag to enable system functionality; checking said at least one system flag in said second module; processing the batched messages in the second module; 152. The communication method of claim 151, further comprising:
153. 153. A method of communication according to claim 151 or claim 152, further comprising the step of establishing at least one shared memory channel between the first module and the second module.
154. 154. The method of claim 153, comprising the second module responding to the first module via the at least one shared memory channel.
155. 155. A method of communication as claimed in claim 153 or claim 154, wherein the at least one shared memory channel receives and assembles the batched messages and passes ownership of the memory to the second module.
156. 156. The method of claim 155, wherein the at least one shared memory channel receives batched messages via a network stack of the computer system.
157. 157. A method of communication according to any one of claims 153 to 156, wherein the at least one shared memory channel includes an HTTP gateway.
158. 158. A method of communication as claimed in any one of claims 151 to 157, wherein an HTTP gateway is used as a web service.
159. 159. A method of communication as claimed in any one of claims 151 to 158, wherein the communication uses a password authenticated key exchange protocol.
160. 160. The method of communications of any one of claims 151 to 159, further comprising using zero-copy networking in a network stack of the computer system.
161. 161. The method of communication of any one of claims 151 to 160, further comprising using user mode networking in a network stack of the computer system.
162. 162. A method of communication as claimed in any one of claims 151 to 161, further comprising serialising data such that the components of the data transmission from the first module are combined into a single data stream and separated into the components at the first module.
163. 163. The method of communication of claim 162, wherein the serialization is abstracted at the edge of each module.
164. 164. A method of communication as claimed in any one of claims 151 to 163, wherein the buffer memory of each module has a configurable buffering threshold.
165. 165. The method of any of claims 151 to 164, wherein the first module and the second module are located on the same computing device.
166. 165. The method of any of claims 151 to 164, wherein the first module and the second module are located on different computing devices.
167. 167. A method of communication according to any one of claims 151 to 166, wherein data sent from the first module to the second module carries a version ID.
168. 168. The method of claim 167, further comprising the step of verifying that the version ID is up to date for the data sent from the first module to the second module.
169. 169. The method of communication of claim 168, further comprising the step of revalidating the version ID to a current version if any of the data is updated.
170. 170. The method of communications of claim 169, wherein if the version ID is not verified, the data transmission fails.
171. At least one of the first module and the second module includes at least one data service module; 171. A method of communication according to any one of claims 151 to 170, wherein each data process in the computer system is performed via the at least one data service module.
172. 172. The method of communications of claim 171, wherein the at least one data service module communicates with a data store implemented by a core database store.
173. 173. The method of communications of claim 172, wherein said at least one data service module is a component of said computer system that directly accesses said data store.
174. 174. The method of claim 173, wherein the core database store includes at least one distributed database.
175. 175. The method of communications of claim 174, wherein said at least one distributed database has separate read and record access channels.
176. 176. A method of communications according to any one of claims 173 to 175, wherein the data store provides an interface to at least one disparate database.
177. 177. A method of communication according to any one of claims 173 to 176, wherein the data store provides a plurality of interface types.
178. 178. The method of claim 177, wherein the plurality of interface types include at least one of a Structured Query Language (SQL) interface, a cell and column interface, a document interface, and a graph interface on the core database store.
179. 179. A method of communications as claimed in any one of claims 176 to 178, wherein all records for said data store layer are managed by a single shared module which controls all or a portion of one or more data transactions.
180. 180. The method of communications of claim 179, further comprising the step of activating a redundant backup of at least one of said sharing modules.
181. 181. A method of communication as claimed in claim 179 or claim 180, wherein all data modifications are made through the single shared module in serial rapid sequence.
182. The single shared module uses a hot backup redundancy model that presents itself to a data transactor cluster; 182. A method of communication according to any one of claims 179 to 181, wherein the data transactor cluster is a set of modules in a hierarchy, each module controlling data transactions in the event of a master module failing.
183. 183. The method of any one of claims 171 to 182, further comprising partitioning data across multiple modules or multiple data stores based on rules configured by domain.
184. 184. The method of claim 183, further comprising the step of hashing the target data of a record of the data transaction or a record of a parent data transaction.
185. 185. The method of claim 184, wherein the hashing step has a cardinality equal to the number of data partitions.
186. 186. A method of communication as claimed in claim 184 or claim 185, further comprising hashing the target data by at least one of the listed geographic region, surname, and currency.
187. 187. The method of communications of any one of claims 171 to 186, further comprising the step of performing at least one data transmission via the at least one data service module to all of a plurality of data partitions.
188. 188. A method of communication as claimed in any one of claims 171 to 187, further comprising the step of completing at least one data transmission by a plurality of modules via the at least one data service module.
189. 189. The method of communications of any one of claims 171 to 188, further comprising the step of maintaining at least one data transmission on said at least one data service module on a plurality of data storage nodes in said data store.
190. The computer system includes a plurality of data service modules; 190. A method of communication as claimed in any one of claims 171 to 189, wherein each data service module contains a cached representation of all the hot data for that instance and hosts an in-memory or in-process database engine.
191. The computer system includes a plurality of data service modules; 190. A method of communications as claimed in any one of claims 171 to 189, wherein each data service module comprises a plurality of heterogeneous or homogeneous database engines.
192. 192. The method of claim 172, further comprising using a Multiversion Concurrency Control (MVCC) version system to manage concurrency of access to the data store so that all data reads are consistent and reflect corresponding data records.
193. 192. A method of communication as claimed in any one of claims 172 to 191, further comprising the step of using pessimistic consistency to manage concurrency of access to the data store such that a data record is ensured to be recorded in the data store before any subsequent data transaction accesses the data record.
194. The computer system further includes an application layer; 194. A method of communication as claimed in any one of claims 171 to 193, wherein the application layer cannot proceed with the data transaction until the at least one data service module has confirmed that it has recorded the record and completed the data transmission.
195. A computing device for carrying out the method of any one of claims 151 to 194.
196. 195. A computer readable medium comprising a number of code portions which, when executed, cause a computing device to perform the method of any one of claims 151 to 194.
Citation Information
Patent Citations
Data processing method using IC card and IC card for realizing the method
JP2000057271A
Event hash generation method, event history accumulation method, event information verification method and event information processing system
JP2006343790A
Method and Apparatus for Logging Based Identification
US20100088517A1
Verifiable redactable audit log
US20150188715A1
Distributed crypto currency reputation system
US20150302400A1
Cited By
Low-radioactivity alumina powder and preparation method thereof
KR1020240074685A
