DE112020002968T5 - DATABASE JOURNAL EDITORS - Google Patents

Abstract

A database management system stores an entry in a journal. After storing the entry, the journal includes a leaf node having a hash value based at least in part on the entry and a hierarchy of interior nodes based at least in part on the leaf node. In response to a request to delete the entry, the entry is deleted but the hash value is retained. Cryptographic proof of a second entry stored in the journal is based at least in part on the preserved hash value.

Description

CROSS REFERENCE TO RELATED APPLICATIONS

This application claims priority from U.S. Patent Application No. 16/446,512 , filed June 19, 2019, entitled "DIGEST PROOFS IN A JOURNALED DATABASE," U.S. Patent Application No. 16/446,543 , filed June 19, 2019, entitled "SYMMETRIC FUNCTION FOR JOURNALED DATABASE PROOF", U.S. Patent Application No. 16/446,528 , filed June 19, 2019, entitled THREADED LEAF NODES IN DATABASE JOURNAL, and U.S. Patent Application No. 16/446,556 , filed June 19, 2019, entitled DATABASE JOURNAL REDACTION, the disclosures of which are incorporated herein by reference in their entirety.

BACKGROUND

Database management systems are increasingly being asked to provide advanced security and auditing capabilities. One of these categories of functionality includes cryptographic verification of transaction history. For example, a database management system might be required to provide verifiable evidence that a record stored in the database has not been modified. However, techniques for providing such evidence may conflict with requirements to support high transaction throughput rates.

character list

• 1 ein Ledger-basiertes Datenbanksystem gemäß einer Ausführungsform veranschaulicht;
• 2 ein Beispiel eines Journal-Baums gemäß einer Ausführungsform veranschaulicht;
• 3 ein Beispiel eines symmetrischen Hash-Operators gemäß einer Ausführungsform veranschaulicht;
• 4 Aspekte einer Journal-Struktur gemäß einer Ausführungsform veranschaulicht;
• 5 weitere Aspekte einer Journal-Struktur gemäß einer Ausführungsform veranschaulicht;
• 6 eine Journal-Redaktion gemäß einer Ausführungsform veranschaulicht;
• 7 Aspekte der Durchführung eines Journal-Nachweises gemäß einer Ausführungsform veranschaulicht;
• 8 Aspekte eines Nachweises gemäß einer Ausführungsform veranschaulicht;
• 9 einen beispielhaften Prozess der Verwendung eines symmetrischen Hash-Operators zum Bereitstellen von Journal-Nachweisen gemäß einer Ausführungsform veranschaulicht;
• 10 einen beispielhaften Prozess der Verwendung von gethreadeten Blattknoten zum Bereitstellen von Journal-Nachweisen gemäß einer Ausführungsform veranschaulicht;
• 11 einen beispielhaften Prozess zum Durchführen eines Digest-Nachweises gemäß einer Ausführungsform veranschaulicht;
• 12 einen beispielhaften Prozess einer Journal-Redaktion gemäß einer Ausführungsform veranschaulicht; und
• 13 ein System veranschaulicht, in dem verschiedene Ausführungsformen implementiert sein können.

Various techniques are described with reference to the drawings, where:

• 1 Figure 12 illustrates a ledger-based database system according to one embodiment;
• 2 Figure 12 illustrates an example of a journal tree according to one embodiment;
• 3 12 illustrates an example of a symmetric hash operator according to one embodiment;
• 4 illustrates aspects of a journal structure according to one embodiment;
• 5 illustrates further aspects of a journal structure according to an embodiment;
• 6 illustrates a journal editorial board according to one embodiment;
• 7 illustrates aspects of performing journal attestation according to one embodiment;
• 8th illustrates aspects of verification according to an embodiment;
• 9 12 illustrates an exemplary process of using a symmetric hash operator to provide journal evidence, according to one embodiment;
• 10 illustrates an exemplary process of using threaded leaf nodes to provide journal evidence, according to one embodiment;
• 11 12 illustrates an example process for performing digest attestation according to one embodiment;
• 12 12 illustrates an exemplary process of journal editing, according to one embodiment; and
• 13 1 illustrates a system in which various embodiments may be implemented.

DETAILED DESCRIPTION

Systems and techniques related to the operation of a journalized database management system are described here. A journalized database management system described herein maintains a journal structure maintained by the system that stores an immutable history of transactions performed on a data collection maintained by the system. The journaled database also offers various cryptographic verification functions using a cryptographic hash tree structure that has been adapted to sustain high throughput and large transaction volumes.

In an example embodiment, the journaled database management system responds to the commitment of a transaction by storing an entry associated with a leaf node of a hash tree. The leaf nodes of the tree are threaded, so the hash stored in the newest leaf node is computed based on the hash of the previous node and based on the hash of the entry. Threading the leaf nodes in this way provides support for various cryptographic verification functions. In at least one embodiment, the threading of the leaf nodes supports range verifications.

In an exemplary embodiment, the journaled database management system calculates hashes using a symmetric hash operator. The symmetric hash operator calculates a cryptographic hash in such a way that it is independent of a large number of operands produces an equivalent output depending on the order of the operands. In at least one embodiment, the symmetric hash operator sorts the operands, concatenates the sorted operands, and outputs a cryptographic hash of the concatenation.

In an example embodiment, the journaled database management system provides evidence that entries covered or cryptographically verified by a first digest of a journal are also covered by a second digest from a subsequent version of the journal.

In an exemplary embodiment, the journaled database management system supports editing of entries. In response to a request to delete an entry from the journal, the database management system deletes the entry but retains the entry hash calculated based on the entry. Furthermore, all hashes that depend on the preserved entry hash are also preserved.

A hash tree, as used herein, refers to a structure that stores cryptographic hashes. A hash tree can sometimes be referred to as a signature tree, cryptographic verification tree, hash signature tree, and so on. A cryptographic hash can be described as a cryptographic signature and can also be described here as a hash.

Various techniques are described in the foregoing and following description. Concrete configurations and details are presented for explanation in order to provide a thorough understanding of the possibilities for implementing the techniques. However, it will also be apparent that the techniques described below can be implemented in various configurations without the specific details. Furthermore, well-known features may be omitted or simplified to avoid obscuring the techniques described.

As one skilled in the art will appreciate in light of this disclosure, certain embodiments may be able to achieve certain advantages, including the embodiments disclosed herein providing high transaction commit rates coupled with the ability to perform cryptographic verification of the integrity of the committed provide transactions.

1 12 illustrates a journaled database management system according to one embodiment. The example journaled database management system 100 includes a query processor 102, a transaction coordinator 104, and a storage system 106.

A client device 110 can send queries to the database system 100 . In one embodiment, a query processor 102 includes a module operable on a computing device that includes at least a processor and memory. As used herein, a module or submodule refers to a portion of memory in which processor-executable instructions are stored, which instructions, when executed by the processor, cause the computing device to perform the functions associated with the module. Query processor 102 performs functions related to processing of queries received from client device 110 . The query processor 102 may include a parser 120, a query scheduler 122, and an execution engine 124. The database system 100 can use a fleet of query processors similar to that in 1 query processor 102 illustrated to facilitate scaling.

In one embodiment, the parser 120 performs lexical and semantic analysis of a received query. Query planner 122 determines a plan for executing the received query, and execution engine 124 receives and executes the plan.

In one embodiment, a transaction coordinator 104 includes a module operable on a computing device that includes at least a processor and memory. Transaction coordinator 104 may reside on a computing device, such as query processor 102, along with other modules, or it may reside on a separate computing device. The database system 100 can have a fleet of transaction coordinators similar to that in 1 transaction coordinator 104 shown to facilitate scaling. The transaction coordinator, in one embodiment, serves to facilitate the performance of operations initiated by execution engine 124 and may also serve as an interface to memory system 106.

In one embodiment, a memory system 106 includes a module operable on a computing device that includes at least a processor and memory. Storage system 106 may reside on a computing device along with other modules or reside on a separate computing device. The database system 100 can use a fleet of storage systems similar to that in 1 include storage system 106 shown to scale to facilitate. The storage system 106 may include various sub-modules, including a journal manager 140 that maintains the journal 144. In general, the storage system 106 is responsible for performing storage and retrieval operations on the ledger, and the journal manager 140 maintains the journal 144. Examples of a journal are provided herein, such as with respect to 2 .

2 Figure 12 illustrates an example of a journal tree according to one embodiment. The exemplary journal of 2 comprises a plurality of leaf nodes 210, 212 and interior nodes 208 organized in a hierarchy. For illustrative and descriptive purposes, the nodes of the hierarchy may be labeled according to their level in the hierarchy and their position within a level. For example, leaf nodes 210 may be denoted as {0,0}, {0,1}, {0,2}, and so on. Above the leaf level, the first level of interior nodes 208 may be denoted as {1,0}, {1,1}, {1,2}, and so on.

Leaf nodes 210 may individually include a hash value based at least in part on a respective entry hash 214 . Each entry hash 214 is calculated by applying a hash value to each entry 216 . In at least one embodiment, a cryptographically secure hash function is applied to entries 216 to generate a hash value that could not be readily generated without access to entries 216 . Examples of hash functions that may be used include, but are not limited to, Secure Hash Algorithm ("SHA"), Message Digest ("MD") algorithms, and so on.

In at least one embodiment, the leaf nodes 210 are arranged as an ordered list, and the hash value of a leaf node is based not only on the value of a respective entry hash 214, but also on the hash value of a previous leaf node. For example, the value of leaf node {0,2} may be based on a combination of node {0,1} hash and entry hash of {0,2}. In at least one embodiment, a symmetric hash operator, such as the in 3 symmetric hash operator shown.

Each of the interior nodes 208 individually includes a hash value based on the hash values of the respective node's children. For example, the node at {1,0} is based on the hash values of the nodes at {0,0} and {0,1}. Similarly, the node at {2,0} is based on the hash values of the nodes at {1,0} and {1,1}.

Nodes are added at the rightmost available position in the leaf level of a hash tree. In the example 200 from 2 the first such available position is the empty leaf node 212 at position {0,5}. A new transaction, represented as new entries 218, is added to the journal by computing a new entry hash 220 and a hash to be stored in the empty leaf node 212 at {0,5}. As previously mentioned, this value can be a combination of the hash of {0,4} and the new entry hash 220 generated by applying a symmetric hash operator.

Note that the nodes 208, 210, 212 of the journal can be classified as belonging to one of two regions. In the stable region 204, all nodes are complete in the sense that their respective hash values do not change as new nodes are added and the tree is expanded. In the unstable region 206, nodes may be fully or partially incomplete. For example, prior to adding the new entries 218, node {1,2} is based on a finalized hash of {0,4} and a null hash of {0,5}. Similarly, the node at {1,3} is null because its children at {0,6} and {0,7} are null.

Nodes that are partially complete, that is based on at least one stable hash value and at least one incomplete value such as zero, occupy a position in the unstable region 206 that can be referred to as the boundary of the hierarchy. In the example of 2 the boundary corresponds to nodes at {0,4}, {1,2}, {2,1} and {3,0}. In at least one embodiment, nodes along the boundary are updated as new entries are added to the journal.

In at least one embodiment, the in 2 The null node shown is not instantiated until a hash value needs to be stored. For example, the instantiation of the node at {0,5} may be deferred until the new entries 218 are to be journaled.

In at least one embodiment, the in 2 represented journal is considered to be of unlimited size and spanning an unlimited number of ancestors above the represented digest node {3,0}. For example, node {3,0} can be viewed as having a parent node {4,0} whose children are {3,0} and {3,1}. These additional nodes, e.g. B. {4,0}, {3,1}, may be instantiated as new entries and their corresponding leaf nodes are added to the journal.

In at least one embodiment, the top instantiated node may be treated as the digest node 202 of the journal. It is noted that the hash value of the digest node 202 is based on the hash values of all of its dependent elements, which in turn are based on hashes calculated from the entries 216 . Therefore, it is difficult, if not impossible, to recreate the digest node 202 without access to the original entries 216 or their respective entry hashes 214.

In at least one embodiment, the hash values for the journal 200 nodes are computed using a symmetric hash operator. 3 Figure 3 illustrates examples 300, 302 of a symmetric hash operator according to at least one embodiment. In at least one embodiment, the symmetric hash operator is a module or other software-implemented function for performing the operations described. In at least one embodiment, the symmetric hash operator comprises processor-executable instructions. For example, in at least one embodiment, a journal manager module includes instructions for performing a symmetric hash. 1 Figure 1 shows an example of a journal manager module 114.

In the first example 300 of 3 two operands 304, 306 for a symmetric hash operator 320 are provided. The symmetric hash operator 320 produces the output 330. For a given set of values X and Y, the symmetric hash operator 320 always produces a value Z. This is true regardless of the order of the operands. For example, X ■ Y = Z and Y ■ X = Z, where "■" indicates the symmetric hash operator 320 .

$$6625\cdot 3245\Rightarrow 32456625\Rightarrow \text{h}\left(32456625\right)\Rightarrow 62434993$$

In at least one embodiment, the symmetric hash operator 320 computes the output 330 by sorting, concatenating, and hashing the operands 304, 306. For example: $$3245\cdot 6625\Rightarrow 32456625\Rightarrow \text{H}\left(32456625\right)\Rightarrow 62434993$$

$$6625\cdot 3245\Rightarrow 32456625\Rightarrow \text{H}\left(32456625\right)\Rightarrow 62434993$$

As can be seen here, the output of the symmetric hash operator 320 is the same regardless of the order of the operands 304, 306.

In at least one embodiment, the symmetric hash operator 320 includes a sort sub-operator 322 that sorts and concatenates the operands with the symmetric hash operator 320, and a hash sub-operator 324 that generates a hash value based on the sorted and concatenated input calculated.

With reference to 2 is a corollary of the symmetric hash operator that the hash value of node {1,0} can be computed if the hash values of {0,0} and {0,1} are known, even if is not known , which hash value corresponds to {0,0} and which hash value corresponds to {0,1}. Thus, the lists [3245, 6625] and [6625, 3245] can both be used as evidence for the value 62434993.

$$Null\cdot X=X$$

In the second example 302 of 3 the operands 308, 310 contain a "zero" value. For this case, the output 332 is defined to be equal to the non-zero input. Therefore: $$X\cdot N\mathrm{and}ll=X$$

$$N\mathrm{and}ll\cdot X=X$$

Again referring to 2 applying the symmetric hash operator 320 to a node like {1,2} that has as children the full node {0,4} and the null node at {0,5} results in the value of {1,2} is equivalent to the value of the complete node {0,4}.

In at least one embodiment, using the symmetric hash operator to calculate hash values for interior nodes and/or leaf nodes of the journal provides one or more advantages. Benefits can include increased efficiency of updating the boundary nodes of the hierarchy as new entries and corresponding nodes are added to the journal. Benefits can also include reducing the complexity of evidence by minimizing the volume of knowledge required to verify the evidence. In particular, if a symmetric hash operator is used to compute hashes for the interior nodes and/or leaf nodes of the journal, a client verifying the evidence may need less information regarding the structure of the journal.

4 illustrates aspects of a journal structure according to one embodiment. The example journal 400 is similar to the example journal 200 of FIG 2 . Just like the corresponding elements of the in 2 journals illustrated includes the example journal 400 of 4 entries 410, entry hashes 408, leaf nodes 406, and interior nodes 404.

Leaf nodes 406 can be described as threaded. This refers to the hash value of each leaf node based on the hash value of a previous node. For example, in at least one embodiment, the node at {0,1} is computed as a symmetric hash of a corresponding entry hash and the hash value from the previous node {0,0}. The leaf nodes 406 can be further described as ordered. In 4 for example, the leaf node at {0,0} precedes the leaf node at {0,1}, and the leaf node at {0,1} precedes the leaf node at {0,2}. The order results from using the previous hash value. Because the hash of {0,1} is based in part on the hash of the leaf node at {0,0}, leaf node {0,1} is assumed to follow leaf node {0,0}. Likewise, {0,2} follows {0,1} and so on.

The node at the root of the hierarchy can be described as digest node 402 . The hash value of digest node 402 is based on the hash values of all other nodes in the tree. Similarly, the rightmost leaf node can be described as leaf node digest 412 . The hash of the leaf node digest 412 is based on the hash of all previous leaf nodes and the entry hash for its associated entries. Both the digest node 402 and the leaf node digest 412 can be used to prove the integrity of the journal. Although their respective values will be different, in at least one embodiment, the digest node 402 and the leaf node digest 412 include equivalent information regarding the integrity of the entries stored in the journal.

$$\left\{\mathrm{0,7}\right\}\cdot E_{\left\{\mathrm{0,8}\right\}}=\left\{\mathrm{0,8}\right\}$$

$$\left\{\mathrm{0,8}\right\}\cdot E_{\left\{\mathrm{0,9}\right\}}=\left\{\mathrm{0,9}\right\}$$

In at least one embodiment, leaf nodes 406 are used to provide area verification. The area attestation confirms that a particular set of records is represented in the journal. For illustration, consider a request to provide a range proof for the entries corresponding to {0,7}, {0,8} and {0,9}. A proof of domain for these nodes could include a list of hash values. For example, in at least one embodiment, the evidence includes the hash values at {0,6} and {0,9}. The recipient of the evidence could then confirm that: $$\left\{0.6\right\}\cdot E_{\left\{0.7\right\}}=\left\{0.7\right\}$$

$$\left\{0.7\right\}\cdot E_{\left\{0.8\right\}}=\left\{0.8\right\}$$

$$\left\{0.8\right\}\cdot E_{\left\{0.9\right\}}=\left\{0.9\right\}$$

It is therefore verified that the journal includes the range of entries corresponding to {0,7}, {0,8} and {0,9} by showing that the hash value is based on {0,9} can be recomputed on the starting entry {0,6} and the entries corresponding to {0,7}, {0,8} and {0,9}.

In at least one embodiment, the range verification further includes additional nodes required to validate one or both digests. Continuing the previous example, the recipient could validate the leaf node digest 412 if the proof included the hash of {0,9} and the entry hash of {4,10}.

$$\left\{\mathrm{0,8}\right\}\cdot \left\{\mathrm{0,9}\right\}\Rightarrow \left\{\mathrm{1,4}\right\}$$

$$\left\{\mathrm{1,10}\right\}\cdot Null\Rightarrow \left\{\mathrm{1,5}\right\}$$

$$\left\{\mathrm{1,2}\right\}\cdot \left\{\mathrm{1,3}\right\}\Rightarrow \left\{\mathrm{2,1}\right\}$$

$$\left\{\mathrm{1,4}\right\}\cdot \left\{\mathrm{1,5}\right\}\Rightarrow \left\{\mathrm{2,2}\right\}$$

$$\left\{\mathrm{2,2}\right\}\cdot Null\Rightarrow \left\{\mathrm{3,1}\right\}$$

$$\left\{\mathrm{2,0}\right\}\cdot \left\{\mathrm{2,1}\right\}\Rightarrow \left\{\mathrm{3,0}\right\}$$

$$\left\{\mathrm{3,0}\right\}\cdot \left\{\mathrm{3,1}\right\}\Rightarrow Digest$$

Similarly, in at least one embodiment, the recipient could validate the digest node 402 if the evidence included additional hashes necessary to recalculate the digest node's hash. For example, the evidence could include hash values of {2,0}, {1,2}, and {1,5}. A series of steps to validate the evidence can then be specified by the recipient: $$\left\{0.6\right\}\cdot \left\{0.7\right\}\Rightarrow \left\{1.3\right\}$$

$$\left\{0.8\right\}\cdot \left\{0.9\right\}\Rightarrow \left\{1.4\right\}$$

$$\left\{1.10\right\}\cdot N\mathrm{and}ll\Rightarrow \left\{1.5\right\}$$

$$\left\{1.2\right\}\cdot \left\{1.3\right\}\Rightarrow \left\{2.1\right\}$$

$$\left\{1.4\right\}\cdot \left\{1.5\right\}\Rightarrow \left\{2.2\right\}$$

$$\left\{2.2\right\}\cdot N\mathrm{and}ll\Rightarrow \left\{3.1\right\}$$

$$\left\{2.0\right\}\cdot \left\{2.1\right\}\Rightarrow \left\{3.0\right\}$$

$$\left\{3.0\right\}\cdot \left\{3.1\right\}\Rightarrow DiGest$$

Note the effect of the symmetric hash operator's handling of incomplete nodes, as described in reference to example 302 of 3 described. Hence:{1,4} . {1,5} ⇒ {2,2} ⇒ {3,1}.

5 illustrates further aspects of a journal structure according to one embodiment. Specifically illustrated 5 an example 500 in which a journal 502 includes a nested journal 506 to store data corresponding to an entry 504 associated with a leaf-level node of the journal 502.

In embodiments, a journal entry may be any of a variety of data structures. For example, in one embodiment, an entry could be an array of bytes, and another entry in the same journal could be a nested journal, such as nested journal 506, which is found in 5 is shown.

In at least one embodiment, the entry hash for entry 504 in journal 502 corresponds to the digest node of nested journal 506.

In at least one embodiment, the in 5 shown nesting over a variety of levels. For example, one or more of the entries associated with the leaf-level nodes of the nested journal 506 may themselves be represented by additional nested journals.

In at least one embodiment, evidence of an entry is provided for an entry stored in a nested journal, such as nested journal 506 in 5 . However, in at least one embodiment, a client verifying the evidence need not be made aware of the nested structure. For example, the proof can be based on the use of the symmetric hash operator related to 3 may comprise a list of hash values to which the symmetric hash operator can be sequentially applied.

6 12 illustrates a journal editorial board according to one embodiment. Journal editing includes removing entries from the journal. In the example of 6 a journal 600 comprises entries 604 to be removed from the journal and a corresponding entry hash 606.

In at least one embodiment, entries 604 are removed from journal 600 to form redacted journal 602 . The entries 604 are no longer in the edited journal 602, but the corresponding entry 606 is preserved. By preserving the entry hash 606, the other hash values in the edited journal can remain constant. For example, the hash values of {0,2}, {0,3}, {1,1} and {2,0} do not need to be recomputed after editing the entry at {0,2}.

In at least one embodiment, an attestation includes an entry hash and an indication that the entry hash corresponds to a redacted entry.

In one embodiment, an entry stored in a nested journal, such as nested journal 506 in 5 , edited. Similar to that through 6 In the example shown, an entry in the nested journal 506 may be deleted but its corresponding entry retained. Because this entry hash is preserved, none of the other hash values in the nested journal 506 need to be recomputed. Likewise, the leaf and root node digests of the journal are preserved. If either of these two is used as the hash value for the corresponding entry in the parent journal, it can also be kept.

7 10 illustrates aspects of performing a digest attestation according to one embodiment. In the illustrated example 700, a digest attestation is provided to confirm that records covered by a previous version of a digest are unchanged and are covered by a new version.

If a digest is provided, it can be used to confirm that the records covered by the digest are unchanged since the digest was created. However, if that version of the digest is discarded and a new version of the digest is provided, the new version cannot be used to demonstrate that the records have not been modified in the period prior to the creation of the new digest. In other words, the guarantee provided by the old digest is not necessarily carried over to the new digest. However, a digest attestation can be used to confirm that all records covered by the old digest are unchanged and are covered by the new version of the digest.

In the example 700 from 7 the nodes at the rightmost edge of the journal 702 are sufficient to prove the digest 706. These nodes are {0,3} and {1,1} as well as the digest node itself at position {2,0}.

In the updated journal 704, the rightmost nodes of the updated journal 704 are sufficient to prove the digest 708. These nodes are {0,5}, {1,2}, {2,1} and the updated digest node at {3.0}.

In at least one embodiment, the digest token consists of hash values showing that the hashes of the original token are replaced by the hashes of the new token from {0,5}, {1,2}, {2,1} and {3 ,0} are subsumed. For example, the digest evidence may consist of hash values showing that the hashes from {0,3}, {1,1} and {2,0} are replaced by the hashes from {0,5}, {1,2 }, {2,1} and {3,0} are subsumed.

$$\left\{\mathrm{0,4}\right\}\cdot E_{\left\{\mathrm{0,5}\right\}}\Rightarrow \left\{\mathrm{0,5}\right\}$$

$$\left\{\mathrm{0,4}\right\}\cdot E_{\left\{\mathrm{0,5}\right\}}\Rightarrow \left\{\mathrm{1,2}\right\}$$

$$\left\{\mathrm{1,2}\right\}\cdot Null\Rightarrow \left\{\mathrm{2,1}\right\}$$

$$\left\{\mathrm{2,0}\right\}\cdot \left\{\mathrm{2,1}\right\}\Rightarrow \left\{\mathrm{3,0}\right\}$$

To further illustrate, in at least one embodiment, a digest attestation could proceed as follows: $$\left\{0.3\right\}\cdot E_{\left\{0.4\right\}}\Rightarrow \left\{0.4\right\}$$

$$\left\{0.4\right\}\cdot E_{\left\{0.5\right\}}\Rightarrow \left\{0.5\right\}$$

$$\left\{0.4\right\}\cdot E_{\left\{0.5\right\}}\Rightarrow \left\{1.2\right\}$$

$$\left\{1.2\right\}\cdot N\mathrm{and}ll\Rightarrow \left\{2.1\right\}$$

$$\left\{2.0\right\}\cdot \left\{2.1\right\}\Rightarrow \left\{3.0\right\}$$

8th illustrates aspects of verification according to one embodiment. In the example 800 from 8th the updated journal 804 corresponds to the updated journal 704 generated with respect to the example 700 of FIG 7 is described. Furthermore, in the example 800 of 8th assume for purposes of the example that a request has been made for proof that the entry {0,2} is both unchanged and included in the updated digest 808 . Note that the entry corresponding to node {0,2} was also included in the original digest 806. Accordingly, evidence is sufficient if the original digest has been verified and it can be demonstrated that the original digest 806 is subsumed by the updated digest 808 .

8th illustrates one such attestation 802 comprising nodes {0,1}, {0,3}, {2,1} and the updated digest at {3,0}. Using these nodes, the correctness of the original digest 806 can be verified by using the evidence along with preserved information, such as an entry hash for the original entry, to recompute the original digest 806 and the updated digest 808 . This confirms that the original digest 806 is subsumed by the updated digest 808.

9 12 illustrates an example process of using a symmetric hash operator to provide journal evidence, according to one embodiment. Although the example 900 from 9 is presented as a sequence of steps, the presented sequence should not be construed as limiting the scope of the present disclosure to only those embodiments that conform to the presented order. Unless otherwise noted or apparent from the context (e.g., where the output of one step is used as input to another), at least some of the steps illustrated may be reordered or performed in parallel.

Aspects of Example 900 include the use of a symmetric hash operator, such as the in 3 illustrated symmetric hash operator.

At 902, a journaled database management system receives requests to journal entries. Examples of adding entries to a journal are illustrated here, including for example relating to 2 and 7 . The entries may include information indicative of a database transaction, such as an insert, update, or delete operation, performed on a data item stored in a data collection.

At 904, the journaled database management system stores leaf nodes to represent the entries and also stores interior nodes in a hierarchical arrangement as described in FIGS 2 and 4-7 arrangements shown. As represented by step 906, hashes are computed for the nodes using a symmetric hash operator.

At 908, the journaled database management system receives a request from a client device to provide evidence that the entries have been stored in the journal. As described here, using the symmetric hash operator simplifies the proof.

At 910, the journaled database management system generates a list of hash values sufficient for verification. The list of hash values is then provided to the client device, wherein at 912, in at least one embodiment, a client device provides the attestation with no data indicative of the structure of the journal's hierarchy by sequentially applying the symmetric hash operator to the provided List of hash values can confirm.

At 914, the client device asserts the attestation based on successive applications of the symmetric hash operator to the hash values in the list, resulting in a hash value that can be compared to a hash value maintained by the client will verify the evidence. For example, the resulting hash value can be compared to a digest value maintained by the client. If they are the same, the evidence is verified.

Example 900 may be implemented by any of a variety of suitable systems, including, for example, database server 1310, which is 13 is shown.

In an exemplary embodiment, a journalized database management system implements a method that includes storing a one trags in a journal. The journal includes a hierarchy of nodes after the entry is saved. Non-limiting examples of a hierarchy of nodes are with respect to 2 and 4-7 illustrated. As described, an interior node of the hierarchy includes a hash value that is computed by applying a symmetric hash operator to a first operand that corresponds to the first hash value of a first child node and a second operand that corresponds to a second hash value of a second child node is applied. The example method further includes providing a list of hash values sufficient to perform cryptographic proof that the entry was stored in the journal.

In another embodiment of the example method, the list of hash values is sufficient if a digest value can be computed by further applying the symmetric hash operator to hash values of the list. Here, the digest value can refer to the hash value at the root of the hierarchy or to a hash value at the end of a thread of leaf nodes.

In another embodiment of the example method, the output of the symmetric hash operator when applied to the first and second operands is equivalent regardless of an order of the first and second operands.

In another embodiment of the example method, the output of the symmetric hash operator is based at least in part on a sorting and concatenation of the first and second operands.

In another embodiment of the example method, the symmetric hash operator calculates its output hash value from the concatenation of the first and second operands.

In another embodiment of the example method, if the second operand is zero, the output of the symmetric hash operator is equal to the first operand. Thus, calling the symmetric hash operator with a hash value of X and a null value will result in the symmetric hash operator returning a value of X, regardless of the order of the operands.

In another embodiment of the example method, the hierarchy of nodes includes a leaf node. The leaf node includes a reference to the entry and further includes a hash value based on applying the symmetric hash operator to an entry hash and a hash value of a second leaf node.

10 12 illustrates an exemplary process of using threaded leaf nodes to provide journal evidence, according to one embodiment. Although the example 1000 of 10 is presented as a sequence of steps, the presented sequence should not be construed as limiting the scope of the present disclosure to only those embodiments that conform to the presented order. Unless otherwise noted or apparent from the context (e.g., where the output of one step is used as input to another), at least some of the steps illustrated may be reordered or performed in parallel.

At 1002, a journaled database management system receives requests to store an entry in a journal. Examples of adding entries to a journal are illustrated here, including for example relating to 2 and 7 . The entries may include information indicative of a database transaction, such as an insert, update, or delete operation, performed on a data item stored in a data collection.

In example 1000, entries are stored in a journal comprising a tree with threaded leaf nodes. Thus, at 1004, one or more records are saved indicative of the entry. At 1006, an entry hash is calculated. The entry hash serves as the entry's cryptographic signature and cannot be easily reproduced without access to the entry. At 1008, a threaded hash value is computed. The threaded hash value is calculated based on the entry hash and the hash value of the previous leaf node. This leads to an ordered set of leaf nodes, such as those in 4 variety shown. The leaf nodes are threaded to each other based on using the previous leaf node's hash value in calculating the subsequent leaf node's threaded hash value.

At 1010, the leaf node is saved. The stored leaf node includes the threaded hash value just described, and may also include a copy of the entry hash and a reference to the entry itself.

At 1012, the journaled database management system receives a request to prove that the entry was saved in the journal. It should be noted that the request may be part of a domain attestation related to the validation of a large number of entries. Hierarchical node structures may be less suitable for such proofs than those related to 10 described threaded structure.

At 1014, the journaled database management system provides evidence. In at least one embodiment, the attestation includes a list of hashes from the threaded leaf nodes. By successively applying a symmetric hash operator to the hashes of the list, it can be reduced to a single hash value that can be compared to a corresponding value held by the client. For example, the hash value calculated from the list can be compared to a digest value kept by the client.

Example 1000 may be implemented by any of a variety of suitable systems, including, for example, database server 1310, which is 13 is shown.

In an example embodiment, a journaled database management system implements a method that includes storing an entry in a journal. The journal includes a hierarchy of interior nodes and multiple leaf nodes. Examples of this structure are through 2 and 4-7 illustrated. The leaf nodes are ordered such that a given leaf node includes a threaded hash value based at least in part on the entry hash and the threaded hash value of the previous leaf node.

Based on this structure, according to the example method, the journaled database management system provides a set of hash values from the leaf nodes, the set of hash values being sufficient to prove that the entry was stored in the journal.

In another embodiment of the example method, the example method includes providing the list of hash values in response to a request to prove that the entry was stored in the journal.

In another embodiment of the example method, the entry indicates a database transaction.

In another embodiment of the example method, the list of hash values is provided to a client to prove that the entry and a plurality of additional entries were stored in the journal.

In another embodiment of the example method, the example method includes calculating a hash value for an interior node based at least in part on the first and second leaf nodes, the first and second leaf nodes being children of the interior node.

In another embodiment of the example method, the example method includes calculating the hash value of the second leaf node based at least in part on a symmetric hash operator.

In another embodiment of the example method, the list of hash values includes a hash value for a leaf node before the first and second leaf nodes.

In another embodiment of the example method, the list of hash values is sufficient if a digest value can be computed by further applying a symmetric hash operator to hash values of the list.

In another embodiment of the example method, the plurality of leaf nodes includes a digest leaf node, the digest leaf node including a hash value based at least in part on hash values of the first and second leaf nodes.

11 12 illustrates an example process for performing digest attestation, according to one embodiment. Although the example 1100 from 11 is presented as a sequence of steps, the presented sequence should not be construed as limiting the scope of the present disclosure to only those embodiments that conform to the presented order. Unless otherwise noted or apparent from the context (e.g., where the output of one step is used as input to another), at least some of the steps illustrated may be reordered or performed in parallel.

At 1102, a journaled database management system stores a first entry in a journal. An entry for which examples are in 7 may include information indicative of a database transaction. For example, an entry may include information indicating an insertion, update, or deletion of a data item stored in a data collection.

At 1104, the journaled database management system journals a leaf node and computes hashes for the interior nodes at the edge of the hierarchy. With reference to 7 For example, the system can add a new leaf node at position {0,3} and update nodes along the edge of the interior node hierarchy. For example, the nodes at {0,3}, {1,2} and {2,0} could be computed. Note that here the "edge" of the hierarchy refers to nodes that represent at least one non-zero value.

At 1106, the journaled database management system provides a first digest. The first digest can be retained by a client and then used to confirm that a version of the journal corresponding to the first digest contains an unmodified version of the first entry.

At 1108, the journaled database management system adds additional entries to the journal. As in 7 shown, additional leaf nodes and inner nodes are added to the hierarchy, including the journal's digest. For example, the nodes at {0,5}, {1,2}, {2,1} and {3,0} can be updated. The system can then provide a digest covering the current version of the journal.

At 1110, the journaled database management system receives a request to provide evidence that the first entry is unchanged and stored in the current version of the journal. It should be noted that providing the digest of the current version of the journal alone may not be sufficient to demonstrate that the entry has not been modified since it was originally added. Rather, the proof involves showing that the previous version of the digest covers the entry in question and is subsumed in the new version.

At 1112, the journaled database management system provides the requested evidence. In at least one embodiment, the evidence includes a list of hash values sufficient to show that the previous version of the digest is subsumed by the new version. In at least one embodiment, the hash values include those needed to compute the digest of the new version of the journal using one or more preserved hashes in combination with the list provided.

Note that threading the leaf nodes contributes to the operation of the attestation. The newer leaf nodes, i. H. those added after the first entry are based at least in part on an entry hash of the first node. Consequently, reconstruction of the digest covering the new version can prove that the first entry is unchanged if the reconstruction of the digest involves the use of a leaf node that was based at least in part on the first entry.

Example 1100 may be implemented by any of a variety of suitable systems, including, for example, database server 1310 described in 13 is shown.

In an example embodiment, a journaled database management system implements a method that includes storing an entry in a first version of the journal. The first version of the journal includes a large number of leaf nodes after the entry is saved. The leaf nodes may individually include a hash value obtained by applying a symmetric hash operator to a first operand corresponding to a previous leaf node's hash value and a second operand corresponding to an entry hash obtained based on the entry or the entries corresponding to the leaf node is calculated. The journal may further include a hierarchy of interior nodes after the entry is stored. An interior node of the interior node hierarchy may include a hash value based at least in part on application of the symmetric hash operator to one or more children of the interior node.

The example method further includes providing a first digest of the first version of the journal and then, after adding new entries, providing a second digest of a second version of the journal.

The example method further includes providing hash values sufficient to demonstrate that the second digest is based at least in part on information contained in the first digest and that the entry is unmodified and stored in the second version of the journal . The information contained in the first digest relates to the fact that the first digest is partially based on a different hash. Therefore, verifying that the second digest includes information included in the first digest may include determining that a hash used to compute the first digest was also used to compute the second digest.

In another embodiment of the exemplary method, the hash values are sufficient appropriate if they can be used to compute the second digest along with a preserved hash value based at least in part on the entry. In this context, "preserved" refers to a client or other actor that keeps a copy of the value for later use.

In another embodiment of the example method, the preserved hash value corresponds to a leaf node of the journal. For example, a client device may maintain an entry hash and, using the provided attestation, confirm that the entry hash was included in the set of hashes that make up the attestation.

In another embodiment of the example method, proving that the second digest is based at least in part on the first digest includes sequentially applying a symmetric hash operator to the list of hash values.

In another embodiment of the example method, proving that the one or more entries are unchanged includes determining that a leaf node of the journal is based at least in part on a hash value calculated based at least in part on the one or more entries became.

In another embodiment of the exemplary method, the second digest includes one or more recalculated nodes that were border nodes in the first version of the journal and non-border nodes of the first version of the journal were not recalculated in the formation of the second version of the journal .

In another embodiment of the example method, the method further comprises receiving a request to provide information proving that the entry is unmodified and stored in the second version of the journal, the request including at least one of information identifying a location of the entry display, or information displaying the first version of the journal.

12 12 illustrates an exemplary process of journal editing, according to one embodiment. Although the example 1200 from 12 is presented as a sequence of steps, the presented sequence should not be construed as limiting the scope of the present disclosure to only those embodiments that conform to the presented order. Unless otherwise noted or apparent from the context (e.g., where the output of one step is used as input to another), at least some of the steps illustrated may be reordered or performed in parallel.

At 1202, a journaled database management system receives requests to store entries in a journal. At 1204 the entries are saved and at 1206 leaf nodes are added to the journal structure. The leaf nodes each contain a reference to the entry and a reference to the entry hash or a copy thereof.

At 1208, the journaled database management system receives a request to remove one of the entries from the journal. This can be described as editing the entry.

At 1210, the journaled database management system deletes the entry and removes the reference to the entry from the corresponding leaf node. However, the journaled database management system maintains the reference to the entry hash, or copy thereof, computed based on the deleted entry. The system also maintains any hashes calculated based on this entry hash. In other words, the system avoids recalculating hashes that might depend on the preserved entry hash by preserving the entry hash for the deleted entries.

At 1212, the journaled database management system receives a request to verify that another of the added entries was journaled. The system responds to the request by providing at 1214 a list of values sufficient for verification. In cases and embodiments, this list includes one or more of the preserved hashes - either the preserved entry hash or a hash value calculated directly or indirectly from the preserved entry hash.

Example 1200 may be implemented by any of a variety of suitable systems, including, for example, database server 1310 described in 13 is shown.

In an exemplary embodiment, a journaled database management system implements a method that includes storing a first entry and a second entry in a journal. After storing the first entry and the second entry, the journal includes a plurality of leaf nodes. Each of the leaf nodes includes a reference to a corresponding entry and a hash value that includes at least wisely based on the corresponding entry. The example method further includes receiving a request to delete the first entry from the journal and responding to the request by removing the reference to the first entry from the leaf node. However, the hash value is retained after the reference is removed. The example method further includes providing a list of hash values sufficient to prove that the second entry is stored in the journal. These hashes, in instances and embodiments, include hashes preserved after deletion.

In another embodiment of the example method, the list of hash values is sufficient if a digest of the journal can be computed by further applying a symmetric hash operator to hash values of the list of hash values.

In another embodiment of the example method, the example method further comprises, in response to the request, providing an indication that the first entry has been deleted from the journal.

In another embodiment of the example method, the hash value of the leaf node is based at least in part on a hash value of another leaf node of the plurality of leaf nodes.

In another embodiment of the example method, the example method further comprises providing an additional list of hash values sufficient to prove that the first entry was stored in the journal.

In another embodiment of the example method, the list of hash values includes one or more of the preserved hash values or a hash value calculated based on the preserved hash value.

In another embodiment of the example method, the journal includes a digest hash value based at least in part on hash values of the plurality of leaf nodes. The digest hash is not recalculated in response to the entry being deleted.

In another embodiment of the example method, a second hash value of a second leaf node associated with the second entry is based at least in part on the first entry.

In another embodiment of the example method, the edited entry is an entry in a nested journal. As described herein, the entry hash for an entry that includes a nested journal may be the digest of the nested journal. By keeping the hash of the edited entry, the value of this digest is allowed to remain constant.

13 13 illustrates aspects of an example system 1300 for implementing aspects according to one embodiment. As will be appreciated, although a web-based system is used for explanation purposes, different systems can be used to implement different embodiments as appropriate. In one embodiment, the system includes an electronic client device 1302, which includes any suitable device capable of sending and/or receiving requests, messages, or information over a suitable network 1304 and transmitting information back to a user of the device. Examples of such client devices include personal computers, cellular or other cellular phones, portable messaging devices, laptop computers, tablet computers, set top boxes, personal data assistants, embedded computer systems, electronic book readers, and the like. In one embodiment, the network includes any suitable network, including an intranet, the Internet, a cellular network, a local area network, a satellite network, or other such network and/or a combination thereof, and components used for such a system. depend at least in part on the type of network and/or system selected. Many protocols and components for communicating over such a network are well known and will not be discussed in detail here. In one embodiment, communication over the network is enabled by wired and/or wireless connections and combinations thereof. In one embodiment, the network includes the Internet and/or other publicly addressable communications network, as the system includes a web server 1306 for receiving requests and delivering content in response thereto, although for other networks an alternative device could be used that includes a serves a similar purpose as would be apparent to one of ordinary skill in the art.

In one embodiment, the illustrative system includes at least one application server 1308 and one or more databases 1310, and it is understood that multiple application servers, tiers, or other ele There may be devices, processes, or components, chained or otherwise configured, that can interact to perform tasks such as retrieving data from an appropriate database. The application server(s) 1308 and database(s) may be operable on one or more servers. The servers, in one embodiment, are implemented as hardware devices, virtual computer systems, programming modules executing on a computer system, and/or other devices configured with hardware and/or software to provide communications (e.g., web service Receive and respond to application programming interface (API) requests over a network. As used herein, unless otherwise specified or apparent from the context, the term "data storage" refers to any device or combination of devices capable of storing, accessing, and retrieving data, which may be a any combination and number of data servers, databases, data storage devices, and data storage media in any standard, distributed, virtual, or clustered system. Data stores, in one embodiment, communicate with block-level and/or object-level interfaces. The application server may include any suitable hardware, software and firmware for integration with the data store required for the execution of aspects of one or more applications for the client device, providing partial or full data access and business logic for an application be taken over.

In one embodiment, the application server, in cooperation with the data store, provides access control services and generates content, including but not limited to text, graphics, audio, video and/or other content, which a user associated with the client device can access through the web server in the form of HyperText Markup Language ("HTML"), Extensible Markup Language ("XML"), JavaScript, Cascading Style Sheets ("CSS"), JavaScript Object Notation (JSON), and/or any other suitable client-side or other structured language. Content transmitted to a client device, in one embodiment, is processed by the client device to provide the content in one or more forms, including but not limited to forms that are audible, visual, and/or user-definable can be perceived by other senses. The handling of all queries and responses as well as the delivery of content between the client device 1302 and the application server 1308 is performed in one embodiment by the web server using PHP: Hypertext Preprocessor ("PHP"), Python, Ruby, Perl, Java, HTML , XML, JSON and/or any other suitable server-side structured language is handled in this example. In one embodiment, operations described herein as being performed by a single device are performed collectively by multiple devices forming a distributed and/or virtual system.

The database(s) 1310, in one embodiment, includes multiple separate data tables, databases, data documents, dynamic data storage schemes, and/or other data storage mechanisms and media for storing data related to a particular aspect of the present disclosure. In one embodiment, the illustrated data store includes mechanisms for storing production data and user information used to deliver content for the production site. The data store is also shown to include a mechanism for storing log data used in one embodiment for reporting, computing resource management, analysis, or other such purposes. In one embodiment, other aspects such as page image information and access rights information (e.g., access control policies or other encodings of permissions) are stored in the data store in one of the mechanisms listed above, where appropriate, or in additional mechanisms in the data store 1310.

Database(s) 1310, in one embodiment, is operable through associated logic to receive instructions from application server 1308 and obtain, update, or otherwise process data in response thereto, and application server 1308 provides in response to the received instructions provide static, dynamic or a combination of static and dynamic data. In one embodiment, dynamic data, such as data used in web logs (blogs), shopping applications, news services, and other such applications, is generated by server-side structured languages as described herein or provided by a content management system ("CMS") running on or under the control of the application server. In one embodiment, a user sends a search query for a particular type of item via a user-operated device. In this example, the data store accesses the user information to verify the user's identity, accesses the catalog detail information to verify information information about items of that type and returns the information to the user, such as in a list of results on a web page that the user accesses through a browser on user device 1302 . To continue with this example, information for a particular item of interest is displayed on a separate page or window of the browser. However, it should be noted that embodiments of the present disclosure are not necessarily limited to the context of web pages, but are more generally applicable to the processing of requests in general, where the requests are not necessarily requests for content. Example requests include requests to manage and/or interact with computing resources hosted by system 1300 and/or another system, such as starting, stopping, deleting, modifying, reading, and/or otherwise accessing such computing resources.

The database(s) 1310, in one embodiment, includes one or more journaled database management systems, such as that in 1 illustrated journalized database management system. A journaled database management system, in at least some embodiments, may be a distributed system operable on a plurality of servers. In other embodiments, a journaled database management system is operable on a server.

In one embodiment, each server typically includes an operating system that provides executable program instructions for the general administration and operation of that server, and includes a computer-readable storage medium (e.g., a hard disk, random access memory, read-only memory, etc.) that stores instructions which, when executed by a processor of the server, cause or otherwise permit the server to perform its intended functions (e.g., the functions are performed as a result of one or more processors of the server executing instructions stored on a computer-readable storage medium are).

In one embodiment, the system 1300 is a distributed and/or virtual computing system that utilizes multiple computing systems and components that communicate via communication links (e.g., Transmission Control Protocol (TCP) connections and/or Transport Layer Security (TLS) or other cryptographically protected communication sessions) are interconnected using one or more computer networks or direct connections. However, those of ordinary skill in the art will recognize that such a system can also be used in a system with fewer or more components than in 13 illustrated can be operated. Therefore, the representation of the system 1300 in 13 should be understood as illustrative and not as limiting the scope of the disclosure.

1. 1. System, Folgendes umfassend:
   • mindestens einen Prozessor; und
   • einen Speicher, der Anweisungen umfasst, die als Reaktion auf die Ausführung durch den mindestens einen Prozessor das System zu mindestens Folgendem veranlassen:
     • Speichern eines oder mehrerer Einträge in einer ersten Version eines Journals, wobei die erste Version des Journals nach Speichern des einen oder der mehreren Einträge Folgendes umfasst:
       • eine geordnete Vielzahl von Blattknoten, wobei ein Blattknoten der geordneten Vielzahl von Blattknoten einen Hash-Wert umfasst, der mindestens teilweise auf einem Hash-Wert eines vorherigen Knotens in der geordneten Vielzahl von Blattknoten basiert;
       • eine Hierarchie von inneren Knoten, wobei ein innerer Knoten einen Hash-Wert umfasst, der mindestens teilweise auf Hash-Werten eines oder mehrerer untergeordneter Elemente des inneren Knotens basiert; und
   • Bereitstellen eines ersten Digests der ersten Version des Journals, wobei der erste Digest als Nachweis dafür verwendbar ist, dass der eine oder die mehreren Einträge unverändert und in der ersten Version des Journals gespeichert sind;
   • Bereitstellen eines zweiten Digests einer zweiten Version des Journals, nachdem ein oder mehrere zusätzliche Einträge dem Journal hinzugefügt wurden; und
   • Bereitstellen von Hash-Werten, die ausreichen, um nachzuweisen, dass der zweite Digest mindestens teilweise auf Informationen basiert, die im ersten Digest beinhaltet sind, und dass der eine oder die mehrere Einträge unverändert und in der zweiten Version des Journals gespeichert sind.
2. 2. System nach Klausel 1, wobei die bereitgestellten Hash-Werte ausreichend sind, wenn die Hash-Werte verwendet werden können, wobei ein aufbewahrter Hash-Wert mindestens teilweise auf dem einen oder den mehreren Einträgen basiert, um den zweiten Digest zu berechnen.
3. 3. System nach Klausel 2, wobei der aufbewahrte Hash-Wert einem Blattknoten des Journals entspricht.
4. 4. System nach einer der Klauseln 1-3, wobei der Nachweis, dass der zweite Digest mindestens teilweise auf dem ersten Digest basiert, die sukzessive Anwendung eines symmetrischen Hash-Operators auf die bereitgestellten Hash-Werte umfasst.
5. 5. System nach einer der Klauseln 1-4, wobei ein Nachweis, dass der eine oder die mehreren Einträge unverändert sind, das Bestimmen umfasst, dass ein Blattknoten des Journals mindestens teilweise auf einem Hash-Wert basiert, der mindestens teilweise auf dem einen oder den mehreren Einträgen basierend berechnet wurde.
6. 6. System nach einer der Klauseln 1-5, wobei der Speicher weitere Anweisungen umfasst, die als Reaktion auf die Ausführung durch den mindestens einen Prozessor das System veranlassen, mindestens eine Anfrage zu empfangen, um zu verifizieren, dass der eine oder die mehrere Einträge unverändert und in der zweiten Version des Journals gespeichert sind, wobei die Anfrage mindestens eine von Informationen, die einen Ort des einen oder der mehreren Einträge anzeigen, oder Informationen, die die erste Version des Journals anzeigen, umfasst.
7. 7. Computerimplementiertes Verfahren, Folgendes umfassend:
   • Speichern eines Eintrags in einer ersten Version eines Journals, wobei die erste Version des Journals nach Speichern des Eintrags Folgendes umfasst:
     • eine Vielzahl von Blattknoten, wobei ein Blattknoten der Vielzahl von Blattknoten einen Hash-Wert umfasst, der mindestens teilweise auf einem Hash-Wert eines vorherigen Knotens in der Vielzahl von Blattknoten basiert;
     • eine Hierarchie von inneren Knoten, wobei ein innerer Knoten der Hierarchie von inneren Knoten einen Hash-Wert umfasst, der mindestens teilweise auf Hash-Werten eines oder mehrerer untergeordneter Elemente des inneren Knotens basiert;
   • Bereitstellen eines ersten Digests der ersten Version des Journals, wobei der erste Digest zum Nachweis verwendbar ist, dass der Eintrag unverändert und in der ersten Version des Journals gespeichert ist;
   • Bereitstellen eines zweiten Digests einer zweiten Version des Journals; und
   • Bereitstellen von Hash-Werten, die ausreichen, um nachzuweisen, dass der zweite Digest mindestens teilweise auf Informationen basiert, die im ersten Digest beinhaltet sind, und dass der Eintrag unverändert und in der zweiten Version des Journals gespeichert ist.
8. 8. Computerimplementiertes Verfahren nach Klausel 7, wobei die Liste der Hash-Werte ausreichend ist, wenn die bereitgestellten Hash-Werte mit einem zusätzlichen Hash-Wert, der mindestens teilweise auf dem Eintrag basiert, verwendet werden können, um den zweiten Digest zu berechnen.
9. 9. Computerimplementiertes Verfahren nach Klausel 7 oder 8, wobei der zusätzliche Hash-Wert einem Blattknoten des Journals entspricht.
10. 10. Computerimplementiertes Verfahren nach einer der Klauseln 7-9, wobei der Nachweis, dass der zweite Hash-Wert mindestens teilweise auf dem ersten Hash-Wert basiert, die aufeinanderfolgende Anwendung eines Hash-Operators auf die bereitgestellten Hash-Werte umfasst.
11. 11. Computerimplementiertes Verfahren nach Klausel 9, wobei der Hash-Operator ein symmetrischer Hash-Operator ist.
12. 12. Computerimplementiertes Verfahren nach einer der Klauseln 7-11, wobei der zweite Digest einen oder mehrere neu berechnete Knoten umfasst, die Grenzknoten in der ersten Version des Journals waren, und wobei Nicht-Grenzknoten der ersten Version des Journals bei der Bildung der zweiten Version des Journals nicht neu berechnet wurden.
13. 13. Computerimplementiertes Verfahren nach einer der Klauseln 7-12, ferner Folgendes umfassend:
    • Empfangen einer Anfrage zum Bereitstellen von Informationen zum Nachweis, dass der Eintrag unverändert ist und in der zweiten Version des Journals gespeichert ist, wobei die Anfrage mindestens eine von Informationen, die einen Ort des Eintrags anzeigen, oder Informationen, die die erste Version des Journals anzeigen, umfasst.
14. 14. Nichttransitorisches computerlesbares Speichermedium, auf dem ausführbare Anweisungen gespeichert sind, die bei Ausführung durch einen oder mehrere Prozessoren eines Computersystems das Computersystem zu mindestens Folgendem veranlassen:
    • Speichern eines Eintrags in einer ersten Version eines Journals, wobei die erste Version des Journals nach Speichern des Eintrags Folgendes umfasst:
      • eine Vielzahl von Blattknoten, wobei ein Blattknoten der Vielzahl von Blattknoten einen Hash-Wert umfasst, der mindestens teilweise auf einem Hash-Wert eines vorherigen Knotens in der Vielzahl von Blattknoten basiert;
      • eine Hierarchie von inneren Knoten, wobei ein innerer Knoten der Hierarchie von inneren Knoten einen Hash-Wert umfasst, der mindestens teilweise auf Hash-Werten eines oder mehrerer untergeordneter Elemente des inneren Knotens basiert;
    • Bereitstellen eines ersten Digests der ersten Version des Journals, wobei der erste Digest zum Nachweis verwendbar ist, dass der Eintrag unverändert und in der ersten Version des Journals gespeichert ist;
    • Bereitstellen eines zweiten Digests einer zweiten Version des Journals; und
    • Bereitstellen von Hash-Werten, die ausreichen, um nachzuweisen, dass der zweite Digest mindestens teilweise auf Informationen basiert, die im ersten Digest beinhaltet sind, und dass der Eintrag unverändert und in der zweiten Version des Journals gespeichert ist.
15. 15. Nichttransitorisches computerlesbares Speichermedium nach Klausel 14, wobei die bereitgestellten Hash-Werte ausreichend sind, wenn die bereitgestellten Hash-Werte mit einem zusätzlichen Hash-Wert verwendet werden können, um den zweiten Digest zu berechnen.
16. 16. Nichttransitorisches computerlesbares Speichermedium nach Klausel 15, wobei der zusätzliche Hash-Wert von einem Blattknoten des Journals stammt.
17. 17. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 14-16, wobei der Nachweis, dass der eine oder die mehreren Einträge unverändert sind, die Bestimmung umfasst, dass ein Blattknoten des Journals mindestens teilweise auf einem Hash-Wert basiert, der mindestens teilweise auf dem Eintrag basierend berechnet wurde.
18. 18. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 14-17, wobei der Nachweis, dass der zweite Hash-Wert mindestens teilweise auf dem ersten Hash-Wert basiert, die aufeinanderfolgende Anwendung eines symmetrischen Hash-Operators auf die bereitgestellten Hash-Werte umfasst.
19. 19. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 14-18, wobei der zweite Digest einen oder mehrere Knoten umfasst, die in der ersten Version des Journals Grenzknoten waren, und wobei Nicht-Grenzknoten der ersten Version des Journals nicht neu berechnet werden.
20. 20. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 14-19, wobei das nichttransitorische computerlesbare Speichermedium darauf weitere ausführbare Anweisungen speichert, die als Ergebnis dessen, dass sie durch einen oder mehrere Prozessoren des Computersystems ausgeführt werden, das Computersystem zu mindestens Folgendem veranlassen:
    • Empfangen einer Anfrage zum Bereitstellen von Informationen zum Nachweis, dass der Eintrag unverändert ist und in der zweiten Version des Journals gespeichert ist, wobei die Anfrage mindestens eine von Informationen, die einen Ort des Eintrags anzeigen, oder Informationen, die die erste Version des Journals anzeigen, umfasst.
21. 21. System, Folgendes umfassend:
    • mindestens einen Prozessor; und
    • einen Speicher, der Anweisungen umfasst, die als Reaktion auf die Ausführung durch den mindestens einen Prozessor das System zu mindestens Folgendem veranlassen:
      • Speichern eines Eintrags in einem Journal, wobei das Journal nach Speichern des Eintrags eine Hierarchie von Knoten umfasst, wobei ein Knoten der Hierarchie von Knoten einen Hash-Wert umfasst, der durch einen symmetrischen Hash-Operator berechnet wird, der auf einen ersten Hash-Wert eines ersten untergeordneten Knotens und einen zweiten Hash-Wert eines zweiten untergeordneten Knotens angewendet wird; und
      • Bereitstellen einer Liste von Hash-Werten von Knoten der Hierarchie, wobei die Liste von Hash-Werten für einen kryptografischen Nachweis ausreicht, dass der Eintrag in dem Journal gespeichert wurde.
22. 22. System nach Klausel 21, wobei die Liste der Hash-Werte ausreichend ist, wenn ein Digest-Wert durch eine weitere Anwendung des symmetrischen Hash-Operators auf Hash-Werte der Liste berechnet werden kann.
23. 23. System nach Klausel 21 oder 22, wobei die Ausgabe des symmetrischen Hash-Operators, wenn er auf den ersten und zweiten Operanden angewendet wird, unabhängig von einer Reihenfolge des ersten und zweiten Operanden äquivalent ist.
24. 24. System nach Klausel 23, wobei die Ausgabe des symmetrischen Hash-Operators mindestens teilweise auf einer Sortierung und Verkettung des ersten und des zweiten Operanden basiert.
25. 25. System nach Klausel 23 oder 24, wobei die Ausgabe des symmetrischen Hash-Operators äquivalent zum ersten Operanden ist, wenn der zweite Operand Null ist.
26. 26. Computerimplementiertes Verfahren, Folgendes umfassend:
    • Speichern eines Eintrags in einem Journal, wobei das Journal nach Speichern des Eintrags eine Hierarchie von Knoten umfasst, wobei ein Knoten der Hierarchie von Knoten einen Hash-Wert umfasst, der durch einen symmetrischen Hash-Operator berechnet wird, der auf einen ersten Hash-Wert eines ersten untergeordneten Knotens und einen zweiten Hash-Wert eines zweiten untergeordneten Knotens angewendet wird; und
    • Bereitstellen einer Liste von Hash-Werten von Knoten der Hierarchie, wobei die Liste von Hash-Werten für einen kryptografischen Nachweis ausreicht, dass der Eintrag in dem Journal gespeichert wurde.
27. 27. Computerimplementiertes Verfahren nach Klausel 26, wobei die Liste der Hash-Werte ausreichend ist, wenn ein Digest-Wert durch eine weitere Anwendung des symmetrischen Hash-Operators auf Hash-Werte der Liste berechnet werden kann.
28. 28. Computerimplementiertes Verfahren nach Klausel 26 oder 27, wobei die Ausgabe des symmetrischen Hash-Operators, wenn er auf den ersten und zweiten Operanden angewendet wird, unabhängig von einer Reihenfolge des ersten und zweiten Operanden äquivalent ist.
29. 29. Computerimplementiertes Verfahren nach Klausel 28, wobei die Ausgabe des symmetrischen Hash-Operators mindestens teilweise auf einer Sortierung und Verkettung des ersten und des zweiten Operanden basiert.
30. 30. Computerimplementiertes Verfahren nach Klausel 29, wobei ein Hash aus der Verkettung des ersten und des zweiten Operanden berechnet wird.
31. 31. Computerimplementiertes Verfahren nach einer der Klauseln 28, wobei die Ausgabe des symmetrischen Hash-Operators äquivalent zum ersten Operanden ist, wenn der zweite Operand Null ist.
32. 32. Computerimplementiertes Verfahren nach einer der Klauseln 26-31, wobei die Hierarchie der Knoten einen Blattknoten umfasst, wobei der Blattknoten einen Verweis auf den Eintrag und einen Hash-Wert umfasst, der mindestens teilweise auf der Anwendung des symmetrischen Hash-Operators auf einen Eintrags-Hash und einen Hash-Wert eines zweiten Blattknoten basiert.
33. 33. Computerimplementiertes Verfahren nach einer der Klauseln 26-32, wobei der kryptografische Nachweis mindestens teilweise auf der Anwendung des symmetrischen Hash-Operators auf einen oder mehrere Hash-Werte der Liste der Hash-Werte basiert.
34. 34. Nichttransitorisches computerlesbares Speichermedium, auf dem ausführbare Anweisungen gespeichert sind, die bei Ausführung durch einen oder mehrere Prozessoren eines Computersystems das Computersystem zu mindestens Folgendem veranlassen:
    • Speichern eines Eintrags in einem Journal, wobei das Journal nach Speichern des Eintrags eine Hierarchie von Knoten umfasst, wobei ein Knoten der Hierarchie von Knoten einen Hash-Wert umfasst, der durch einen symmetrischen Hash-Operator berechnet wird, der auf einen ersten Hash-Wert eines ersten untergeordneten Knotens und einen zweiten Hash-Wert eines zweiten untergeordneten Knotens angewendet wird; und
    • Bereitstellen einer Liste von Hash-Werten von Knoten der Hierarchie, wobei die Liste von Hash-Werten für einen kryptografischen Nachweis ausreicht, dass der Eintrag in dem Journal gespeichert wurde.
35. 35. Nichttransitorisches computerlesbares Speichermedium nach Klausel 34, wobei die Liste der Hash-Werte ausreichend ist, wenn ein Digest-Wert durch eine weitere Anwendung des symmetrischen Hash-Operators auf Hash-Werte der Liste berechnet werden kann.
36. 36. Nichttransitorisches computerlesbares Speichermedium nach Klausel 34 oder 35, wobei die Ausgabe des symmetrischen Hash-Operators, wenn er auf den ersten und zweiten Operanden angewendet wird, unabhängig von einer Reihenfolge des ersten und zweiten Operanden äquivalent ist.
37. 37. Nichttransitorisches computerlesbares Speichermedium nach Klausel 36, wobei die Ausgabe des symmetrischen Hash-Operators mindestens teilweise auf einer Sortierung und Verkettung des ersten und des zweiten Operanden basiert.
38. 38. Nichttransitorisches computerlesbares Speichermedium nach Klausel 37, wobei ein Hash aus der Verkettung des ersten und des zweiten Operanden berechnet wird.
39. 39. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 36, wobei die Ausgabe des symmetrischen Hash-Operators äquivalent zum ersten Operanden ist, wenn der zweite Operand Null ist.
40. 40. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 34-39, wobei die Hierarchie von Knoten einen Blattknoten umfasst, wobei der Blattknoten einen Verweis auf den Eintrag und einen Hash-Wert umfasst.
41. 41. System, Folgendes umfassend:
    • mindestens einen Prozessor; und
    • einen Speicher, der Anweisungen umfasst, die als Reaktion auf die Ausführung durch den mindestens einen Prozessor das System zu mindestens Folgendem veranlassen:
      • Speichern eines Eintrags in einem Journal, wobei das Journal nach Speichern des Eintrags eine Hierarchie von inneren Knoten und eine geordnete Vielzahl von Blattknoten umfasst, wobei ein Blattknoten der geordneten Vielzahl von Blattknoten einen mindestens teilweise auf dem Eintrag basierenden Hash-Wert und einen Hash-Wert eines vorherigen Blattknotens der geordneten Vielzahl von Blattknoten umfasst; und
      • Bereitstellen einer Liste von Hash-Werten von der geordneten Vielzahl von Blattknoten, wobei die Liste von Hash-Werten für einen kryptografischen Nachweis ausreicht, dass der Eintrag in dem Journal gespeichert wurde.
42. 42. System nach Klausel 41, wobei die Liste der Hash-Werte für einen kryptografischen Nachweis ausreicht, dass der Eintrag und eine Vielzahl von zusätzlichen Einträgen in dem Journal gespeichert wurden.
43. 43. System nach Klausel 41 oder 42, wobei ein innerer Knoten einen Hash-Wert umfasst, der mindestens teilweise auf dem ersten und zweiten Blattknoten der geordneten Vielzahl von Blattknoten basiert.
44. 44. System nach einer der Klauseln 41-43, wobei der Hash-Wert unter Verwendung eines symmetrischen Hash-Operators berechnet wird.
45. 45. Computerimplementiertes Verfahren, Folgendes umfassend:
    • Speichern eines Eintrags in einem Journal, das eine Hierarchie von inneren Knoten und eine Vielzahl von Blattknoten umfasst, wobei ein zweiter Blattknoten der Vielzahl von Blattknoten einen Hash-Wert umfasst, der mindestens teilweise auf dem Eintrag und einem Hash-Wert eines ersten Blattknotens der Vielzahl von Blattknoten basiert; und
    • Bereitstellen einer Liste von Hash-Werten von der Vielzahl von Blattknoten, wobei die Liste von Hash-Werten für den Nachweis ausreicht, dass der Eintrag in dem Journal gespeichert wurde.
46. 46. Computerimplementiertes Verfahren nach Klausel 45, ferner Folgendes umfassend:
    • Bereitstellen der Liste von Hash-Werten als Reaktion auf eine Anfrage nachzuweisen, dass der Eintrag im Journal gespeichert wurde.
47. 47. Computerimplementiertes Verfahren nach Klausel 45 oder 46, wobei der Eintrag eine Datenbanktransaktion anzeigt.
48. 48. Computerimplementiertes Verfahren nach einer der Klauseln 45-47, wobei die Liste von Hash-Werten einem Client zum Nachweis bereitgestellt wird, dass der Eintrag und eine Vielzahl zusätzlicher Einträge in dem Journal gespeichert wurden.
49. 49. Computerimplementiertes Verfahren nach einer der Klauseln 45-48, ferner Folgendes umfassend:
    • Berechnen eines Hash-Werts für einen inneren Knoten, der mindestens teilweise auf dem ersten und dem zweiten Blattknoten basiert, wobei der erste und der zweite Blattknoten untergeordnete Elemente des inneren Knotens sind.
50. 50. Computerimplementiertes Verfahren nach einer der Klauseln 45-49, ferner Folgendes umfassend:
    • Berechnen des Hash-Werts des zweiten Blattknotens basierend mindestens teilweise auf einem symmetrischen Hash-Operator.
51. 51. Computerimplementiertes Verfahren nach einer der Klauseln 45-50, wobei die Liste von Hash-Werten einen Hash-Wert für einen Blattknoten vor dem ersten und zweiten Blattknoten umfasst.
52. 52. Computerimplementiertes Verfahren nach einer der Klauseln 45-51, wobei die Liste der Hash-Werte ausreichend ist, wenn ein Digest-Wert durch eine weitere Anwendung eines symmetrischen Hash-Operators auf Hash-Werte der Liste berechnet werden kann.
53. 53. Computerimplementiertes Verfahren nach einer der Klauseln 45-52, wobei die Vielzahl von Blattknoten einen Digest-Blattknoten umfasst, wobei der Digest-Blattknoten einen Hash-Wert umfasst, der mindestens teilweise auf Hash-Werten des ersten und des zweiten Blattknotens basiert.
54. 54. Nichttransitorisches computerlesbares Speichermedium, auf dem ausführbare Anweisungen gespeichert sind, die bei Ausführung durch einen oder mehrere Prozessoren eines Computersystems das Computersystem zu mindestens Folgendem veranlassen:
    • Speichern eines Eintrags in einem Journal, wobei das Journal nach Speichern des Eintrags eine Hierarchie von inneren Knoten und eine Vielzahl von Blattknoten umfasst, wobei ein erster Blattknoten der geordneten Vielzahl von Blattknoten einen mindestens teilweise auf dem Eintrag basierenden Hash-Wert und einen Hash-Wert eines zweiten Blattknotens der Vielzahl von Blattknoten umfasst; und
    • Bereitstellen einer Liste von Hash-Werten von der Vielzahl von Blattknoten, wobei die Liste von Hash-Werten für einen kryptografischen Nachweis verwendbar ist, dass der Eintrag in dem Journal gespeichert wurde.
55. 55. Nichttransitorisches computerlesbares Speichermedium nach Klausel 54, wobei die ausführbaren Anweisungen ferner ausführbare Anweisungen umfassen, die bei Ausführung durch den einen oder die mehreren Prozessoren das Computersystem zu mindestens Folgendem veranlassen:
    • Bereitstellen der Liste von Hash-Werten als Reaktion auf eine Anfrage nachzuweisen, dass der Eintrag im Journal gespeichert wurde.
56. 56. Nichttransitorisches computerlesbares Speichermedium nach Klausel 54 oder 55, wobei die ausführbaren Anweisungen ferner ausführbare Anweisungen umfassen, die bei Ausführung durch den einen oder die mehreren Prozessoren das Computersystem zu mindestens Folgendem veranlassen:
    • Berechnen eines Hash-Werts für einen inneren Knoten, der mindestens teilweise auf dem ersten und dem zweiten Blattknoten basiert, wobei der erste und der zweite Blattknoten untergeordnete Elemente des inneren Knotens sind.
57. 57. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 54-56, wobei die ausführbaren Anweisungen ferner ausführbare Anweisungen umfassen, die bei Ausführung durch den einen oder mehrere Prozessoren das Computersystem zu mindestens Folgendem veranlassen:
    • Berechnen des Hash-Werts des ersten Blattknotens basierend mindestens teilweise auf einem symmetrischen Hash-Operator.
58. 58. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 54-57, wobei die Liste von Hash-Werten einen Hash-Wert für einen Blattknoten vor dem ersten und zweiten Blattknoten umfasst.
59. 59. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 54-58, wobei die Liste der Hash-Werte ausreichend ist, wenn ein Digest-Wert durch eine weitere Anwendung eines symmetrischen Hash-Operators auf Hash-Werte der Liste berechnet werden kann.
60. 60. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 54-59, wobei die Vielzahl von Blattknoten einen Digest-Blattknoten umfasst, wobei der Digest-Blattknoten einen Hash-Wert umfasst, der mindestens teilweise auf Hash-Werten des ersten und des zweiten Blattknotens basiert.
61. 61. System, Folgendes umfassend:
    • mindestens einen Prozessor; und
    • einen Speicher, der Anweisungen umfasst, die als Reaktion auf die Ausführung durch den mindestens einen Prozessor das System zu mindestens Folgendem veranlassen:
      • Speichern eines ersten Eintrags und eines zweiten Eintrags in einem Journal, wobei das Journal nach Speichern des ersten Eintrags und des zweiten Eintrags eine Vielzahl von Blattknoten und eine Hierarchie von inneren Knoten umfasst, wobei ein Blattknoten aus der Vielzahl von Blattknoten einen Verweis auf den ersten Eintrag und einen Hash-Wert, der mindestens teilweise auf dem ersten Eintrag basiert, umfasst;
      • als Reaktion auf eine Anfrage zum Löschen des ersten Eintrags aus dem Journal, Entfernen des Verweises auf den ersten Eintrag aus dem Blattknoten, wobei der Blattknoten den Hash-Wert nach dem Entfernen des Verweises aufbewahrt; und
      • Bereitstellen einer Liste von Hash-Werten, die ausreichend ist, um nachzuweisen, dass der zweite Eintrag im Journal gespeichert ist.
62. 62. System nach Klausel 61, wobei die Liste der Hash-Werte ausreichend ist, wenn ein Digest des Journals durch eine weitere Anwendung eines symmetrischen Hash-Operators auf Hash-Werte der Liste von Hash-Werten berechnet werden kann.
63. 63. System nach Klausel 61 oder 62, wobei der Speicher weitere Anweisungen umfasst, die als Reaktion auf die Ausführung durch den mindestens einen Prozessor das System zu mindestens Folgendem veranlassen:
    • als Reaktion auf die Anfrage Bereitstellen eines Digest-Werts, der mindestens teilweise auf dem aufbewahrten Hash-Wert basiert.
64. 64. System nach einer der Klauseln 61-63, wobei der Hash-Wert des Blattknotens mindestens teilweise auf einem Hash-Wert eines anderen Blattknotens der Vielzahl der Blattknoten basiert.
65. 65. System nach einer der Klauseln 61-64, wobei ein zweiter Hash-Wert eines zweiten Blattknotens mindestens teilweise auf dem Hash-Wert basiert, der mindestens teilweise auf dem ersten Eintrag basiert.
66. 66. System nach einer der Klauseln 61-65, wobei die Liste der Hash-Werte den aufbewahrten Hash-Wert umfasst.
67. 67. Computerimplementiertes Verfahren, Folgendes umfassend:
    • Speichern eines ersten Eintrags und eines zweiten Eintrags in einem Journal, wobei das Journal nach Speichern des ersten Eintrags und des zweiten Eintrags eine Vielzahl von Blattknoten umfasst, wobei ein Blattknoten aus der Vielzahl von Blattknoten einen Verweis auf den ersten Eintrag und einen Hash-Wert, der mindestens teilweise auf dem ersten Eintrag basiert, umfasst;
    • als Reaktion auf eine Anfrage zum Löschen des ersten Eintrags aus dem Journal, Entfernen des Verweises auf den ersten Eintrag aus dem Blattknoten;
    • Aufbewahren des Hash-Werts im Blattknoten nach dem Entfernen des Verweises; und
    • Bereitstellen einer Liste von Hash-Werten, die ausreichend ist, um nachzuweisen, dass der zweite Eintrag im Journal gespeichert ist.
68. 68. Computerimplementiertes Verfahren nach Klausel 67, wobei die Liste der Hash-Werte ausreichend ist, wenn ein Digest des Journals durch eine weitere Anwendung eines symmetrischen Hash-Operators auf Hash-Werte der Liste von Hash-Werten berechnet werden kann.
69. 69. Computerimplementiertes Verfahren nach einer der Klauseln 67 oder 68, wobei der erste Eintrag in einem verschachtelten Journal erfolgt.
70. 70. Computerimplementiertes Verfahren nach einer der Klauseln 67-69, wobei ein zweiter Hash-Wert eines zweiten Blattknotens mindestens teilweise auf dem Hash-Wert basiert, der mindestens teilweise auf dem ersten Eintrag basiert.
71. 71. Computerimplementiertes Verfahren nach einer der Klauseln 67-70, ferner Folgendes umfassend:
    • Bereitstellen einer zusätzlichen Liste von Hash-Werten, die ausreichend ist, um nachzuweisen, dass der erste Eintrag im Journal gespeichert worden ist.
72. 72. Computerimplementiertes Verfahren nach einer der Klauseln 67-71, wobei die Liste der Hash-Werte den aufbewahrten Hash-Wert umfasst.
73. 73. Computerimplementiertes Verfahren nach einer der Klauseln 67-72, wobei das Journal einen Digest umfasst, der mindestens teilweise auf dem aufbewahrten Hash-Wert basiert.
74. 74. Nichttransitorisches computerlesbares Speichermedium, auf dem ausführbare Anweisungen gespeichert sind, die bei Ausführung durch einen oder mehrere Prozessoren eines Computersystems das Computersystem zu mindestens Folgendem veranlassen:
    • Speichern eines ersten Eintrags und eines zweiten Eintrags in einem Journal, wobei das Journal nach Speichern des ersten Eintrags und des zweiten Eintrags eine Vielzahl von Blattknoten umfasst, wobei ein Blattknoten aus der Vielzahl von Blattknoten einen Verweis auf den ersten Eintrag und einen Hash-Wert, der mindestens teilweise auf dem ersten Eintrag basiert, umfasst;
    • als Reaktion auf eine Anfrage zum Löschen des ersten Eintrags aus dem Journal, Entfernen des Verweises auf den ersten Eintrag aus dem Blattknoten;
    • Aufbewahren des Hash-Werts im Blattknoten nach dem Entfernen des Verweises; und
    • Bereitstellen einer Liste von Hash-Werten, die ausreichend ist, um nachzuweisen, dass der zweite Eintrag im Journal gespeichert ist.
75. 75. Nichttransitorisches computerlesbares Speichermedium nach Klausel 74, wobei die Liste der Hash-Werte ausreichend ist, wenn ein Digest des Journals durch eine weitere Anwendung eines symmetrischen Hash-Operators auf Hash-Werte der Liste von Hash-Werten berechnet werden kann.
76. 76. Nichttransitorisches computerlesbares Speichermedium nach Klausel 74 oder 75, wobei das nichttransitorische computerlesbare Speichermedium darauf weitere ausführbare Anweisungen speichert, die als Ergebnis dessen, dass sie durch den einen oder die mehreren Prozessoren ausgeführt werden, das Computersystem zu mindestens Folgendem veranlassen:
    • als Reaktion auf die Anfrage Bereitstellen einer Anzeige, dass der erste Eintrag aus dem Journal gelöscht wurde.
77. 77. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 74-76, wobei der Hash-Wert des Blattknotens mindestens teilweise auf einem Hash-Wert eines anderen Blattknotens der Vielzahl der Blattknoten basiert.
78. 78. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 74-77, wobei das nichttransitorische computerlesbare Speichermedium darauf weitere ausführbare Anweisungen speichert, die als Ergebnis dessen, dass sie durch den einen oder die mehreren Prozessoren ausgeführt werden, das Computersystem zu mindestens Folgendem veranlassen:
    • Bereitstellen einer zusätzlichen Liste von Hash-Werten, die ausreichend ist, um nachzuweisen, dass der erste Eintrag im Journal gespeichert worden ist.
79. 79. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 74-78, wobei die Liste der Hash-Werte den aufbewahrten Hash-Wert umfasst.
80. 80. Nichttransitorisches computerlesbares Speichermedium nach einer der Klauseln 74-79, wobei das Journal einen Digest umfasst, der mindestens teilweise auf dem aufbewahrten Hash-Wert basiert.

Embodiments of the disclosure may be described in terms of the following clauses:

1. 1. System comprising:
   • at least one processor; and
   • a memory comprising instructions that, in response to execution by the at least one processor, cause the system to do at least one of the following:
     • Storing one or more entries in a first version of a journal, the first version of the journal after storing the one or more entries comprising:
       • an ordered plurality of leaf nodes, a leaf node of the ordered plurality of leaf nodes comprising a hash value based at least in part on a hash value of a previous node in the ordered plurality of leaf nodes;
       • a hierarchy of interior nodes, an interior node comprising a hash value based at least in part on hash values of one or more children of the interior node; and
   • providing a first digest of the first version of the journal, the first digest being usable as evidence that the one or more entries are unmodified and stored in the first version of the journal;
   • providing a second digest of a second version of the journal after adding one or more additional entries to the journal; and
   • providing hash values sufficient to demonstrate that the second digest is based at least in part on information contained in the first digest and that the one or more entries are unmodified and stored in the second version of the journal.
2. 2. The system of clause 1, wherein the provided hashes are sufficient if the hashes can be used, wherein a preserved hash value is based at least in part on the one or more ones lazily based to calculate the second digest.
3. 3. The system of clause 2, wherein the preserved hash value corresponds to a leaf node of the journal.
4. 4. The system of any one of clauses 1-3, wherein proving that the second digest is based at least in part on the first digest comprises successively applying a symmetric hash operator to the provided hash values.
5. 5. The system of any one of clauses 1-4, wherein proving that the one or more entries are unchanged comprises determining that a leaf node of the journal is based at least in part on a hash value based at least in part on the one or calculated based on the multiple entries.
6. 6. The system of any one of clauses 1-5, wherein the memory comprises further instructions that, in response to execution by the at least one processor, cause the system to receive at least one request to verify that the one or more entries unmodified and stored in the second version of the journal, the request comprising at least one of information indicative of a location of the one or more entries or information indicative of the first version of the journal.
7. 7. A computer-implemented method, comprising:
   • Saving an entry in a first version of a journal, the first version of the journal after saving the entry includes:
     • a plurality of leaf nodes, a leaf node of the plurality of leaf nodes comprising a hash value based at least in part on a hash value of a previous node in the plurality of leaf nodes;
     • a hierarchy of interior nodes, an interior node of the hierarchy of interior nodes comprising a hash value based at least in part on hash values of one or more children of the interior node;
   • providing a first digest of the first version of the journal, the first digest being usable to prove that the entry is unmodified and stored in the first version of the journal;
   • providing a second digest of a second version of the journal; and
   • providing hash values sufficient to demonstrate that the second digest is based at least in part on information contained in the first digest and that the entry is unmodified and stored in the second version of the journal.
8. 8. The computer-implemented method of clause 7, wherein the list of hashes is sufficient if the provided hashes can be used with an additional hash based at least in part on the entry to compute the second digest.
9. 9. The computer-implemented method of clause 7 or 8, wherein the additional hash value corresponds to a leaf node of the journal.
10. 10. The computer-implemented method of any one of clauses 7-9, wherein proving that the second hash value is based at least in part on the first hash value comprises sequentially applying a hash operator to the provided hash values.
11. 11. The computer-implemented method of clause 9, wherein the hash operator is a symmetric hash operator.
12. 12. The computer-implemented method of any one of clauses 7-11, wherein the second digest comprises one or more recomputed nodes that were border nodes in the first version of the journal and non-border nodes of the first version of the journal in forming the second version of the journal were not recalculated.
13. 13. The computer-implemented method of any one of clauses 7-12, further comprising:
    • receiving a request to provide information proving that the entry is unmodified and stored in the second version of the journal, the request including at least one of information indicative of a location of the entry or information indicative of the first version of the journal , includes.
14. 14. A non-transitory computer-readable storage medium storing executable instructions that, when executed by one or more processors of a computer system, cause the computer system to do at least the following:
    • Storing an entry in a first version of a journal, the first version of the Journals after saving the entry includes:
      • a plurality of leaf nodes, a leaf node of the plurality of leaf nodes comprising a hash value based at least in part on a hash value of a previous node in the plurality of leaf nodes;
      • a hierarchy of interior nodes, an interior node of the hierarchy of interior nodes comprising a hash value based at least in part on hash values of one or more children of the interior node;
    • providing a first digest of the first version of the journal, the first digest being usable to prove that the entry is unmodified and stored in the first version of the journal;
    • providing a second digest of a second version of the journal; and
    • providing hash values sufficient to demonstrate that the second digest is based at least in part on information contained in the first digest and that the entry is unmodified and stored in the second version of the journal.
15. 15. The non-transitory computer-readable storage medium of clause 14, wherein the provided hashes are sufficient if the provided hashes can be used with an additional hash to compute the second digest.
16. 16. The non-transitory computer-readable storage medium of clause 15, wherein the additional hash value is from a leaf node of the journal.
17. 17. The non-transitory computer-readable storage medium of any one of clauses 14-16, wherein establishing that the one or more entries are unchanged comprises determining that a leaf node of the journal is based at least in part on a hash value based at least in part on the entry was calculated based.
18. 18. The non-transitory computer-readable storage medium of any one of clauses 14-17, wherein proving that the second hash value is based at least in part on the first hash value comprises sequentially applying a symmetric hash operator to the provided hash values.
19. 19. The non-transitory computer-readable storage medium of any one of clauses 14-18, wherein the second digest comprises one or more nodes that were border nodes in the first version of the journal, and non-border nodes of the first version of the journal are not recalculated.
20. 20. The non-transitory computer-readable storage medium of any one of clauses 14-19, wherein the non-transitory computer-readable storage medium stores thereon further executable instructions that, as a result of being executed by one or more processors of the computer system, cause the computer system to do at least one of the following:
    • receiving a request to provide information proving that the entry is unmodified and stored in the second version of the journal, the request including at least one of information indicative of a location of the entry or information indicative of the first version of the journal , includes.
21. 21. System comprising:
    • at least one processor; and
    • a memory comprising instructions that, in response to execution by the at least one processor, cause the system to do at least one of the following:
      • storing an entry in a journal, wherein after storing the entry the journal comprises a hierarchy of nodes, a node of the hierarchy of nodes comprising a hash value computed by a symmetric hash operator limited to a first hash value of a first child node and a second hash value of a second child node; and
      • providing a list of hash values of nodes of the hierarchy, the list of hash values sufficient for cryptographic proof that the entry was stored in the journal.
22. 22. The system of clause 21, wherein the list of hash values is sufficient if a digest value can be computed by further applying the symmetric hash operator to hash values of the list.
23. 23. The system of clause 21 or 22, wherein the output of the symmetric hash operator when applied to the first and second operands is equivalent regardless of an order of the first and second operands.
24. 24. The system according to clause 23, wherein the output of the symmetric hash operator is at least based at least in part on a sorting and concatenation of the first and second operands.
25. 25. The system of clause 23 or 24, wherein the output of the symmetric hash operator is equivalent to the first operand if the second operand is zero.
26. 26. A computer-implemented method, comprising:
    • storing an entry in a journal, wherein after storing the entry the journal comprises a hierarchy of nodes, a node of the hierarchy of nodes comprising a hash value computed by a symmetric hash operator limited to a first hash value of a first child node and a second hash value of a second child node; and
    • providing a list of hash values of nodes of the hierarchy, the list of hash values sufficient for cryptographic proof that the entry was stored in the journal.
27. 27. The computer-implemented method of clause 26, wherein the list of hash values is sufficient if a digest value can be computed by further applying the symmetric hash operator to hash values of the list.
28. 28. The computer-implemented method of clause 26 or 27, wherein the output of the symmetric hash operator when applied to the first and second operands is equivalent regardless of an order of the first and second operands.
29. 29. The computer-implemented method of clause 28, wherein the output of the symmetric hash operator is based at least in part on a sorting and concatenation of the first and second operands.
30. 30. The computer-implemented method of clause 29, wherein a hash is computed from the concatenation of the first and second operands.
31. 31. The computer-implemented method of any one of clauses 28, wherein the output of the symmetric hash operator is equivalent to the first operand when the second operand is zero.
32. 32. The computer-implemented method of any one of clauses 26-31, wherein the hierarchy of nodes comprises a leaf node, the leaf node comprising a reference to the entry and a hash value based at least in part on application of the symmetric hash operator to an entry -Hash and a hash value based on a second leaf node.
33. 33. The computer-implemented method of any one of clauses 26-32, wherein the cryptographic proof is based at least in part on applying the symmetric hash operator to one or more hash values of the list of hash values.
34. 34. A non-transitory computer-readable storage medium storing executable instructions that, when executed by one or more processors of a computer system, cause the computer system to do at least the following:
    • storing an entry in a journal, wherein after storing the entry the journal comprises a hierarchy of nodes, a node of the hierarchy of nodes comprising a hash value computed by a symmetric hash operator limited to a first hash value of a first child node and a second hash value of a second child node; and
    • providing a list of hash values of nodes of the hierarchy, the list of hash values sufficient for cryptographic proof that the entry was stored in the journal.
35. 35. The non-transitory computer-readable storage medium of clause 34, wherein the list of hash values is sufficient if a digest value can be computed by further applying the symmetric hash operator to hash values of the list.
36. 36. The non-transitory computer-readable storage medium of clause 34 or 35, wherein the output of the symmetric hash operator when applied to the first and second operands is equivalent regardless of an order of the first and second operands.
37. 37. The non-transitory computer-readable storage medium of clause 36, wherein the output of the symmetric hash operator is based at least in part on a sorting and concatenation of the first and second operands.
38. 38. The non-transitory computer-readable storage medium of clause 37, wherein a hash is computed from the concatenation of the first and second operands.
39. 39. The non-transitory computer-readable storage medium of any one of clause 36, wherein the output of the symmetric hash operator is equivalent to the first operand if the second operand is zero.
40. 40. The non-transitory computer-readable storage medium of any one of clauses 34-39, wherein the hierarchy of nodes includes a leaf node, the leaf node including a reference to the entry and a hash value.
41. 41. System comprising:
    • at least one processor; and
    • a memory comprising instructions that, in response to execution by the at least one processor, cause the system to do at least one of the following:
      • Storing an entry in a journal, wherein after storing the entry the journal comprises a hierarchy of interior nodes and an ordered plurality of leaf nodes, a leaf node of the ordered plurality of leaf nodes having a hash value based at least in part on the entry and a hash value a previous leaf node of the ordered plurality of leaf nodes; and
      • providing a list of hash values from the ordered plurality of leaf nodes, the list of hash values being sufficient to cryptographically prove that the entry was stored in the journal.
42. 42. The system of clause 41, wherein the list of hash values is sufficient to provide cryptographic evidence that the entry and a plurality of additional entries have been stored in the journal.
43. 43. The system of clause 41 or 42, wherein an interior node comprises a hash value based at least in part on first and second leaf nodes of the ordered plurality of leaf nodes.
44. 44. The system of any one of clauses 41-43, wherein the hash value is computed using a symmetric hash operator.
45. 45. A computer-implemented method, comprising:
    • storing an entry in a journal comprising a hierarchy of interior nodes and a plurality of leaf nodes, a second leaf node of the plurality of leaf nodes comprising a hash value based at least in part on the entry and a hash value of a first leaf node of the plurality based on leaf nodes; and
    • providing a list of hash values from the plurality of leaf nodes, the list of hash values being sufficient to establish that the entry has been stored in the journal.
46. 46. The computer-implemented method of clause 45, further comprising:
    • providing the list of hash values in response to a request to prove that the entry was journaled.
47. 47. The computer-implemented method of clause 45 or 46, wherein the entry indicates a database transaction.
48. 48. The computer-implemented method of any one of clauses 45-47, wherein the list of hash values is provided to a client as evidence that the entry and a plurality of additional entries have been stored in the journal.
49. 49. A computer-implemented method according to any one of clauses 45-48, further comprising:
    • computing a hash value for an interior node based at least in part on the first and second leaf nodes, the first and second leaf nodes being children of the interior node.
50. 50. The computer-implemented method of any one of clauses 45-49, further comprising:
    • computing the hash value of the second leaf node based at least in part on a symmetric hash operator.
51. 51. The computer-implemented method of any one of clauses 45-50, wherein the list of hash values comprises a hash value for a leaf node prior to the first and second leaf nodes.
52. 52. The computer-implemented method of any one of clauses 45-51, wherein the list of hash values is sufficient if a digest value can be computed by further applying a symmetric hash operator to hash values of the list.
53. 53. The computer-implemented method of any one of clauses 45-52, wherein the plurality of leaf nodes comprises a digest leaf node, the digest leaf node comprising a hash value based at least in part on hash values of the first and second leaf nodes.
54. 54. Non-transitory computer-readable storage medium storing executable instructions which, when executed by one or more processors of a computer system cause the computer system to do at least the following:
    • Storing an entry in a journal, wherein after storing the entry the journal comprises a hierarchy of interior nodes and a plurality of leaf nodes, a first leaf node of the ordered plurality of leaf nodes having a hash value based at least in part on the entry and a hash value a second leaf node of the plurality of leaf nodes; and
    • providing a list of hash values from the plurality of leaf nodes, the list of hash values being usable for cryptographic proof that the entry was stored in the journal.
55. 55. The non-transitory computer-readable storage medium of clause 54, wherein the executable instructions further comprise executable instructions that, when executed by the one or more processors, cause the computer system to at least do the following:
    • providing the list of hash values in response to a request to prove that the entry was journaled.
56. 56. The non-transitory computer-readable storage medium of clause 54 or 55, wherein the executable instructions further comprise executable instructions that, when executed by the one or more processors, cause the computer system to at least do the following:
    • computing a hash value for an interior node based at least in part on the first and second leaf nodes, the first and second leaf nodes being children of the interior node.
57. 57. The non-transitory computer-readable storage medium of any one of clauses 54-56, wherein the executable instructions further comprise executable instructions that, when executed by the one or more processors, cause the computer system to at least do the following:
    • computing the hash value of the first leaf node based at least in part on a symmetric hash operator.
58. 58. The non-transitory computer-readable storage medium of any one of clauses 54-57, wherein the list of hash values includes a hash value for a leaf node prior to the first and second leaf nodes.
59. 59. The non-transitory computer-readable storage medium of any one of clauses 54-58, wherein the list of hash values is sufficient if a digest value can be computed by further applying a symmetric hash operator to hash values of the list.
60. 60. The non-transitory computer-readable storage medium of any one of clauses 54-59, wherein the plurality of leaf nodes comprises a digest leaf node, the digest leaf node comprising a hash value based at least in part on hash values of the first and second leaf nodes.
61. 61. System comprising:
    • at least one processor; and
    • a memory comprising instructions that, in response to execution by the at least one processor, cause the system to do at least one of the following:
      • storing a first entry and a second entry in a journal, wherein after storing the first entry and the second entry, the journal comprises a plurality of leaf nodes and a hierarchy of interior nodes, a leaf node of the plurality of leaf nodes having a reference to the first entry and a hash value based at least in part on the first entry;
      • in response to a request to delete the first entry from the journal, removing the reference to the first entry from the leaf node, the leaf node retaining the hash value after removing the reference; and
      • Providing a list of hash values sufficient to prove that the second entry is stored in the journal.
62. 62. The system of clause 61, wherein the list of hash values is sufficient if a digest of the journal can be computed by further applying a symmetric hash operator to hash values of the list of hash values.
63. 63. The system of clause 61 or 62, wherein the memory comprises further instructions that, in response to execution by the at least one processor, cause the system to at least:
    • in response to the request, providing a digest value based at least in part on the preserved hash value.
64. 64. The system of any one of clauses 61-63, wherein the hash value of the leaf node is based at least in part on a hash value of another leaf node of the plurality of leaf nodes.
65. 65. The system of any one of clauses 61-64, wherein a second hash value of a second leaf node is based at least in part on the hash value based at least in part on the first entry.
66. 66. The system of any one of clauses 61-65, wherein the list of hash values includes the preserved hash value.
67. 67. A computer-implemented method, comprising:
    • Storing a first entry and a second entry in a journal, the journal comprising a plurality of leaf nodes after storing the first entry and the second entry, a leaf node from the plurality of leaf nodes having a reference to the first entry and a hash value, based at least in part on the first entry;
    • in response to a request to delete the first entry from the journal, removing the reference to the first entry from the leaf node;
    • keeping the hash value in the leaf node after removing the reference; and
    • Providing a list of hash values sufficient to prove that the second entry is stored in the journal.
68. 68. The computer-implemented method of clause 67, wherein the list of hashes is sufficient if a digest of the journal can be computed by further applying a symmetric hash operator to hashes of the list of hashes.
69. 69. The computer-implemented method of either clause 67 or 68, wherein the first entry is in a nested journal.
70. 70. The computer-implemented method of any one of clauses 67-69, wherein a second hash value of a second leaf node is based at least in part on the hash value based at least in part on the first entry.
71. 71. The computer-implemented method of any one of clauses 67-70, further comprising:
    • Providing an additional list of hash values sufficient to prove that the first entry has been stored in the journal.
72. 72. The computer-implemented method of any one of clauses 67-71, wherein the list of hash values includes the preserved hash value.
73. 73. The computer-implemented method of any one of clauses 67-72, wherein the journal comprises a digest based at least in part on the preserved hash value.
74. 74. A non-transitory computer-readable storage medium storing executable instructions that, when executed by one or more processors of a computer system, cause the computer system to do at least the following:
    • Storing a first entry and a second entry in a journal, the journal comprising a plurality of leaf nodes after storing the first entry and the second entry, a leaf node from the plurality of leaf nodes having a reference to the first entry and a hash value, based at least in part on the first entry;
    • in response to a request to delete the first entry from the journal, removing the reference to the first entry from the leaf node;
    • keeping the hash value in the leaf node after removing the reference; and
    • Providing a list of hash values sufficient to prove that the second entry is stored in the journal.
75. 75. The non-transitory computer-readable storage medium of clause 74, wherein the list of hashes is sufficient if a digest of the journal can be computed by further applying a symmetric hash operator to hashes of the list of hashes.
76. 76. The non-transitory computer-readable storage medium of clause 74 or 75, the non-transitory computer-readable storage medium storing thereon further executable instructions that, as a result of being executed by the one or more processors, cause the computer system to at least do the following:
    • in response to the request, providing an indication that the first entry has been deleted from the journal.
77. 77. Non-transitory computer-readable storage medium according to any one of clauses 74-76, wherein the hash value of the leaf node is based at least in part on a hash value of another leaf node of the plurality of leaf nodes.
78. 78. The non-transitory computer-readable storage medium of any one of clauses 74-77, the non-transitory computer-readable storage medium storing thereon further executable instructions that, as a result of being executed by the one or more processors, cause the computer system to do at least one of the following:
    • Providing an additional list of hash values sufficient to prove that the first entry has been stored in the journal.
79. 79. The non-transitory computer-readable storage medium of any of clauses 74-78, wherein the list of hash values includes the preserved hash value.
80. 80. The non-transitory computer-readable storage medium of any one of clauses 74-79, wherein the journal comprises a digest based at least in part on the preserved hash value.

The various embodiments may also be implemented in a wide variety of operating environments, which in some cases may include one or more user computers, computing devices, or processing devices that may be used to operate any number of applications. In one embodiment, user or client devices include any number of computers, such as desktop, laptop, or tablet computers running a standard operating system, as well as cellular (mobile), wireless, and handheld devices running mobile software and capable of supporting a number of network and messaging protocols, and such a system also includes a number of workstations running a variety of commercial operating systems and other well-known applications for purposes such as development and database management. In one embodiment, these devices also include other electronic devices such as dummy terminals, thin clients, gaming systems and other devices that can communicate over a network, and virtual devices such as virtual machines, hypervisors, software containers that support virtualization at the operating system level, and other virtual devices or non-virtual devices that support virtualization that can communicate over a network.

In one embodiment, a system utilizes at least one network that would be known to those skilled in the art to support communications using any of a variety of commercially available protocols, such as Transmission Control Protocol/Internet Protocol ("TCP/IP"), User Datagram Protocol (" UDP"), protocols operating in various layers of the Open System Interconnection ("OSI") model, File Transfer Protocol ("FTP"), Universal Plug and Play ("UPnP"), Network File System ("NFS") ), Common Internet File System (“CIFS”) and other protocols. The network, in one embodiment, is a local area network, a wide area network, a virtual private network, the Internet, an intranet, an extranet, a public switched telephone network, an infrared network, a wireless network, a satellite network, and any combination thereof. In one embodiment, a connection-oriented protocol is used to communicate between network endpoints such that the connection-oriented protocol (sometimes referred to as a connection-based protocol) is able to transmit data in an ordered stream. In one embodiment, a connection-oriented protocol can be reliable or unreliable. For example, the TCP protocol is a reliable, connection-oriented protocol. Asynchronous Transfer Mode ("ATM") and Frame Relay are unreliable connection-oriented protocols. Connection-oriented protocols are in contrast to packet-oriented protocols such as UDP, which transmit packets without a guaranteed order.

In one embodiment, the system utilizes a web server running one or more of a variety of server or mid-tier applications, including Hypertext Transfer Protocol ("HTTP") server, FTP server, Common Gateway Interface( "CGI") servers, data servers, Java servers, Apache servers and business application servers. In one embodiment, the one or more servers are also capable of executing programs or scripts in response to requests from user devices, such as by running one or more web applications implemented as one or more scripts or programs running in any programming language such as ^Java® , C, C# or C++ or any scripting language such as Ruby, PHP, Perl, Python or TCL and combinations thereof. In one embodiment, the one or more servers also include database servers including, without limitation, off-the-shelf ^Oracle® , Microsoft®, ^Sybase® and ^{IBM® as} well as open source servers such as MySQL, Postgres, SQLite, MongoDB and any others Server capable of storing structured or unstructured data and access them. In one embodiment, a database server includes table-based servers, document-based servers, unstructured servers, relational servers, non-relational servers, or combinations of these and/or other database servers.

In one embodiment, the system includes a variety of data storage and other main storage and storage media, as discussed above, which may reside in a variety of locations, such as on a storage medium local to (and/or resident in) one or located on several of the computers or remotely from any or all computers across the network. In one embodiment, the information resides on a storage-area network (“SAN”) known to those skilled in the art, and similarly, all files necessary to perform the functions attributed to the computers, servers, or other network devices are local and or removed as needed saved. In an embodiment in which a system includes computerized devices, each such device may include hardware elements electrically coupled via a bus, the elements including, for example, at least one central processing unit (central processing unit - "CPU" or "processor"), at least one input device (e.g., a mouse, keyboard, controller, touch screen, or keypad), at least one output device (e.g., a display device, printer, or speaker), at least one storage device, such as hard drives, optical storage devices, and Solid state storage devices such as random access memory (“RAM”) or read-only memory (“ROM”), as well as removable media devices, memory cards, flash cards, etc., and various combinations thereof.

In one embodiment, such a device also includes a computer-readable media reader, a communications device (e.g., a modem, network card (wireless or wired), infrared communications device, etc.) and memory as described above, wherein the computer-readable media reader connected to or configured to include a computer-readable storage medium representing remote, local, fixed and/or removable storage devices and storage media for temporarily and/or more permanently containing, storing, transmitting and retrieving computer-readable information. In one embodiment, the system and various devices also typically include a number of software applications, modules, services, or other elements residing within at least one memory device, including an operating system and application programs, such as a client application or a web browser. In one embodiment, custom hardware is used and/or certain elements are implemented in hardware, software (including portable software such as applets), or both. In one embodiment, connections to other computing devices such as network input/output devices are employed.

In one embodiment, storage media and computer-readable media that contain code or portions of code include any suitable media known or used in the art, including but not limited to storage media and communication media, such as volatile and non-volatile, removable and non-removable media implemented in any method or technology for storage and/or transmission of information, such as computer-readable instructions, data structures, program modules, or other data, including RAM, ROM, electrically erasable programmable read-only memory ( Electrically Erasable Programmable Read-Only Memory - "EEPROM"), flash memory or other storage technology, Compact Disc Read-Only Memory ("CD-ROM"), Digital Versatile Disk (DVD) or other optical storage, magnetic cassette, magnetic tape, magnetic disk storage or other magnetic storage devices n or any other medium that can be used to store the desired information and that can be accessed by the system device. Based on the disclosure and teachings provided herein, one of ordinary skill in the art will know of other ways and/or methods of implementing the various embodiments.

The specification and drawings are, therefore, to be regarded in an illustrative rather than a restrictive sense. It will, however, be evident that various modifications and changes can be made thereto without departing from the broader spirit and scope of the invention as set forth in the claims.

Other variations are within the spirit of the present disclosure. While the techniques presented are susceptible to various modifications and alternative constructions, certain illustrative embodiments have been shown in the drawings and have been described above in detail. However, it should be understood that it is not intended to limit the invention to the specific to the form(s) disclosed, but on the contrary the intention is to cover all modifications, alternative constructions and equivalents as may be included within the spirit and scope of the invention as defined in the appended claims.

The use of the terms "a", "an", "an" and "an" as well as "the", "the" and "the" and similar references in the context of the description of the disclosed embodiments (particularly in the context of the following claims) shall be understood to cover both the singular and the plural unless otherwise indicated herein or unless the context clearly conflicts. Similarly, use of the term “or” should be understood to mean “and/or” unless the context expressly conflicts therewith. The terms “comprising”, “comprising”, “including” and “including” are to be construed as open-ended (i.e., including but not limited to) unless otherwise specified. The term “connected”, when unchanged and referring to physical connections, is to be understood as being partially or fully contained within, attached to, or joined to something, even if something is in between. The naming of ranges of values herein is intended solely as a shorthand technique to individually identify each individual value that falls within the range, unless otherwise specified herein, and each individual value is included in the specification as if it were individually identified herein. The use of the term "set" (e.g., "a set of elements") or "subset", unless otherwise specified or conflicting with the context, is to be understood as a non-empty collection comprising one or more constituents. Further, unless otherwise indicated or in conflict with the context, the term “subclause” of a corresponding sentence does not necessarily mean a true subclause of the corresponding sentence, but the subclause and the corresponding sentence may be the same. The use of the phrase "based on" means "based at least in part on" and is not limited to "based solely on" unless expressly stated otherwise or apparent from the context.

Conjunctive formulations, such as sentences of the form "at least one of A, B and C", unless expressly stated otherwise or the context clearly conflicts, are to be understood within the context as they are generally used, to represent that an element, term, etc. can be either A or B or C, any non-empty sub-sentence of the set of A and B and C, or any sentence not contradicted by context or otherwise excluded that contains at least one A, at least one B or at least one C contains. For example, in the illustrative example of a three-element sentence, the conjunctional phrase "at least one of A, B, and C" refers to any of the following sentences: {A}, {B}, {C}, {A, B}, {A, C}, {B, C}, {A, B, C} and, unless expressly stated otherwise or the context conflicts, any sentence containing {A}, {B} and/or { C} as a sub-sentence (e.g. sentences with multiple "A"). Thus, such conjunctional phrases are generally not intended to imply that particular embodiments require that at least one of A, at least one of B, and at least one of C be present. Similarly, phrases such as "at least one of A, B, or C" refer to the same thing as "at least one of A, B, and C" and refer to any of the following sentences: {A}, {B}, {C} , {A, B}, {A, C}, {A, B, C}, unless a different meaning is expressly stated or clear from the context. Unless otherwise specified or the context conflicts, the term "plurality" denotes a state of plurality (e.g., "a plurality of items" indicates multiple items). The number of elements in a plurality is at least two, but can be more, either where expressly indicated or where the context indicates.

Operations of processes described herein may be performed in any suitable order, unless otherwise noted herein or the context otherwise clearly contradicts. In one embodiment, a process, such as the processes described herein (or variations and/or combinations thereof), is executed under the control of one or more computer systems configured with executable instructions and is expressed as code (e.g., executable instructions, a one or more computer programs or one or more applications) that executes collectively on one or more processors, hardware, or combinations thereof. In one embodiment, the code is stored on a computer-readable storage medium, for example in the form of a computer program comprising a plurality of instructions executable by one or more processors. In one embodiment, a computer-readable storage medium is a non-transitory computer-readable storage medium that excludes transient signals (e.g., propagating transient electrical or electromagnetic transmission) but non-transitory data storage circuitry (e.g., buffers, cache, and queues) within transceivers of transient includes signals. In one embodiment, code (e.g., executable code or source code) is stored on a set of one or more non-transitory computer-readable storage media storing executable instructions that, when executed by one or more processors of a computer system (ie, as result of execution), causing the computer system to perform operations described herein. The set of non-transitory computer-readable storage media, in one embodiment, includes multiple non-transitory computer-readable storage media, and one or more individual non-transitory storage media of the multiple non-transitory computer-readable storage media lacks all code, while the multiple non-transitory computer-readable storage media collectively store all code. In one embodiment, the executable instructions are executed such that different instructions are executed by different processors - for example, in one embodiment, a non-transitory computer-readable storage medium stores instructions, and a main CPU executes some of the instructions while a graphics processing unit executes other instructions. In another embodiment, different components of a computer system have separate processors, and different processors execute different subsets of instructions.

Accordingly, in one embodiment, computer systems are configured to implement one or more services that individually or collectively perform operations of processes described herein, and such computer systems are configured with applicable hardware and/or software that enable the operations to be performed. Furthermore, in one embodiment of the present disclosure, a computer system is a single device and in another embodiment is a distributed computer system that includes multiple devices that operate differently such that the distributed computer system performs the operations described herein and such that a single device does not perform all of the operations .

The use of any and all examples or exemplary language (e.g., "such as") provided herein is merely intended to better elucidate embodiments of the invention and does not limit the scope of the invention unless otherwise claimed. No language in the specification should be taken to indicate any non-claimed element as essential to the practice of the invention.

Embodiments of this disclosure are described herein, including the best mode known to the inventors for carrying out the invention. Variations on these embodiments may become apparent to those of ordinary skill in the art upon reading the foregoing description. The inventors expect those skilled in the art to apply such variations as appropriate, and the inventors desire that embodiments of the present disclosure be practiced otherwise than as specifically described herein. Accordingly, the scope of the present disclosure includes all modifications and equivalents of the subject matter recited in the appended claims to the extent permitted by applicable law. Furthermore, any combination of the elements described above, in all possible variations thereof, encompasses the scope of the present disclosure, unless otherwise specified herein or the context otherwise clearly contradicts it.

All references cited herein, including publications, patent applications, and patents, are hereby incorporated by reference to the same extent as if each reference were individually and specifically incorporated by reference and set forth in their entirety.

QUOTES INCLUDED IN DESCRIPTION

This list of documents cited by the applicant was generated automatically and is included solely for the better information of the reader. The list is not part of the German patent or utility model application. The DPMA assumes no liability for any errors or omissions.

Patent Literature Cited

• US 16/446512 [0001]
• US 16/446543 [0001]
• US 16/446528 [0001]
• US 16/446556 [0001]

Claims (15)

System comprising: at least one processor; and a memory comprising instructions that, in response to execution by the at least one processor, cause the system to do at least one of the following: storing a first entry and a second entry in a journal, wherein after storing the first entry and the second entry, the journal comprises a plurality of leaf nodes and a hierarchy of interior nodes, a leaf node of the plurality of leaf nodes having a reference to the first entry and a hash value based at least in part on the first entry; in response to a request to delete the first entry from the journal, removing the reference to the first entry from the leaf node, the leaf node retaining the hash value after removing the reference; and Providing a list of hash values sufficient to prove that the second entry is stored in the journal. system after claim 1 , where the list of hash values is sufficient if a digest of the journal can be computed by further applying a symmetric hash operator to hash values of the list of hash values. system after claim 1 wherein the memory comprises further instructions that, in response to execution by the at least one processor, cause the system to at least: provide, in response to the request, a digest value based at least in part on the preserved hash value. system after claim 1 , wherein the hash value of the leaf node is based at least in part on a hash value of another leaf node of the plurality of leaf nodes. system after claim 1 , wherein a second hash value of a second leaf node is based at least in part on the hash value based at least in part on the first entry. system after claim 1 , where the list of hashes includes the preserved hash value. A computer-implemented method, comprising: Storing a first entry and a second entry in a journal, the journal comprising a plurality of leaf nodes after storing the first entry and the second entry, a leaf node from the plurality of leaf nodes having a reference to the first entry and a hash value, based at least in part on the first entry; in response to a request to delete the first entry from the journal, removing the reference to the first entry from the leaf node; keeping the hash value in the leaf node after removing the reference; and Providing a list of hash values sufficient to prove that the second entry is stored in the journal. Computer-implemented method claim 7 , where the list of hash values is sufficient if a digest of the journal can be computed by further applying a symmetric hash operator to hash values of the list of hash values. Computer-implemented method claim 7 , where the first entry is in a nested journal. Computer-implemented method claim 7 , wherein a second hash value of a second leaf node is based at least in part on the hash value based at least in part on the first entry. Computer-implemented method claim 7 , further comprising: providing an additional list of hash values sufficient to prove that the first entry has been stored in the journal. Computer-implemented method claim 7 , where the list of hashes includes the preserved hash value. Computer-implemented method claim 7 , wherein the journal includes a digest based at least in part on the preserved hash value. A non-transitory computer-readable storage medium storing executable instructions that, when executed by one or more processors of a computer system, cause the computer system to at least do the following: store a first entry and a second entry in a journal, wherein after storing the first entry and the second entry comprises a plurality of leaf nodes, wherein a leaf node of the plurality of leaf nodes comprises a reference to the first entry and a hash value based at least in part on the first entry; in response to a request to delete the user th entry from the journal, removing the reference to the first entry from the leaf node; keeping the hash value in the leaf node after removing the reference; and providing a list of hash values sufficient to prove that the second entry is stored in the journal. Non-transitory computer-readable storage medium Claim 14 , where the list of hash values is sufficient if a digest of the journal can be computed by further applying a symmetric hash operator to hash values of the list of hash values.

Images