Data handling apparatus, data handling method, and non-transitory computer-readable medium

Abstract

A data handling apparatus acquires an identifier of a target nonce. The target nonce is stored in a leaf node of a tree, the tree including nodes each of which stores a nonce and a tag. The nonce stored in the node is verified using the tag stored in the node and the nonce stored in the parent node. To verify a target node that stores the target nonce, the data handling apparatus recursively verifies the ancestors of the nodes if necessary. Specifically, in the data handling apparatus, the verification of two or more target nodes can be concurrently performed. Thus, the data handling apparatus performs verification of an ancestor node of the target node when this verification has not been initiated yet as a part of verification of another target node.

Description

DATA HANDLING APPARATUS, DATA HANDLING METHOD, AND NON-TRANSITORY COMPUTER-READABLE MEDIUM

[0001] The present disclosure generally relates to data handling apparatus, data handling method, and non-transitory computer-readable medium.

[0002] Memory data is required to be protected and secured. In regard to memory data protection, memory banks, which store memory data, are considered unsecured and could be tempered with to modify the memory data within. Thus, it is important to verify the integrity of the memory data when the memory data is being read. PTL1 discloses a general electronic processing system that achieves authenticated memory encryption.

[0003] PTL1: US Patent Publication No. 2019 / 0050347

[0004] PTL1 does not concretely describe a method for efficiently processing intermediary data necessary to verify the memory data. An objective of the present disclosure is to provide a novel technique to improve the performance of the verification of the memory data.

[0005] The present disclosure provides a data handling apparatus that comprises at least one logic circuit that is configured to: acquire an identifier of a target nonce that is stored in a leaf node of a tree, wherein the tree includes: a root node storing a nonce; a plurality of intermediary nodes storing a nonce and a tag; and a plurality of the leaf nodes storing a nonce and a tag, and wherein the tag stored in a node is computed using the nonce that is valid and stored in a parent of the node and the nonce stored in the node, generate a chain data for a target node that is the node storing the target nonce and add the chain data to verification information, wherein the chain data represents a progress of a set of verification chain process for the target node and one or more verification chain processes for ancestors of the target node, wherein the verification chain process can be concurrently performed for a plurality of the target nodes, and wherein the verification information includes the chain data for each target node for which the verification chain process is in progress; execute the verification chain process for the target node; and output the target node when the target node is verified as valid, wherein the verification chain process for a particular node includes: using the chain data to determine whether the verification chain process for the parent of the particular node has been initiated; recursively executing the verification chain process for the parent when the verification chain process for the parent has not been initiated; and verifying the particular node using the tag stored in the particular node and the nonce stored in the parent.

[0006] The present disclosure further provides a data handling method that is performed by a computer, comprises: acquiring an identifier of a target nonce that is stored in a leaf node of a tree, wherein the tree includes: a root node storing a nonce; a plurality of intermediary nodes storing a nonce and a tag; and a plurality of the leaf nodes storing a nonce and a tag, and wherein the tag stored in a node is computed using the nonce that is valid and stored in a parent of the node and the nonce stored in the node, generating a chain data for a target node that is the node storing the target nonce and add the chain data to verification information, wherein the chain data represents a progress of a set of verification chain process for the target node and one or more verification chain processes for ancestors of the target node, wherein the verification chain process can be concurrently performed for a plurality of the target nodes, and wherein the verification information includes the chain data for each target node for which the verification chain process is in progress; executing the verification chain process for the target node; and outputting the target node when the target node is verified as valid, wherein the verification chain process for a particular node includes: using the chain data to determine whether the verification chain process for the parent of the particular node has been initiated; recursively executing the verification chain process for the parent when the verification chain process for the parent has not been initiated; and verifying the particular node using the tag stored in the particular node and the nonce stored in the parent.

[0007] The present disclosure further provides a non-transitory computer readable medium storing a program. The program that causes a computer to execute: acquiring an identifier of a target nonce that is stored in a leaf node of a tree, wherein the tree includes: a root node storing a nonce; a plurality of intermediary nodes storing a nonce and a tag; and a plurality of the leaf nodes storing a nonce and a tag, and wherein the tag stored in a node is computed using the nonce that is valid and stored in a parent of the node and the nonce stored in the node, generating a chain data for a target node that is the node storing the target nonce and add the chain data to verification information, wherein the chain data represents a progress of a set of verification chain process for the target node and one or more verification chain processes for ancestors of the target node, wherein the verification chain process can be concurrently performed for a plurality of the target nodes, and wherein the verification information includes the chain data for each target node for which the verification chain process is in progress; executing the verification chain process for the target node; and outputting the target node when the target node is verified as valid, wherein the verification chain process for a particular node includes: using the chain data to determine whether the verification chain process for the parent of the particular node has been initiated; recursively executing the verification chain process for the parent when the verification chain process for the parent has not been initiated; and verifying the particular node using the tag stored in the particular node and the nonce stored in the parent.

[0008] According to the present disclosure, a novel technique to improve the performance of the verification of the memory data is provided.

[0009] Fig. 1 illustrates data structures that are handled by an data handling apparatus and used for memory authentication.Fig. 2 illustrates an overview of the data handling apparatus.Fig. 3 illustrates an example structure of the verification information.Fig. 4 is a block diagram showing an example of the functional configuration of the data handling apparatus.Fig. 5 is a block diagram illustrating an example of the hardware configuration of a computer that realizes the data handling apparatus.Fig. 6 is a flowchart illustrating an example of an overall flow of processes performed by the data handling apparatus.Fig. 7 is a flowchart illustrating an example flow of verification chain process.Fig. 8 illustrates an example of the more detailed structure of the head data and the state data.Fig. 9 illustrates an example of the storage area preassigned to the verification information.Fig. 10 is an example flow of the verification process.Fig. 11 is a flowchart illustrating an example of an overall flow of processes performed by the data handling apparatus.Fig. 12 shows a flowchart illustrating an example flow of verification chain process.Fig. 13 shows a flowchart illustrating an example flow of verification chain process.

[0010] Example embodiments according to the present disclosure will be described hereinafter with reference to the drawings. The same reference signs are assigned to the same elements throughout the drawings, and redundant explanations are omitted as necessary. In addition, predetermined information (e.g., a predetermined value or a predetermined threshold) is stored in advance in a storage unit to which a computer using that information has access unless otherwise described. In the present disclosure, a storage unit may be implemented with one or more storage devices, such as hard disks, solid-state drives (SSDs), or random-access memories (RAMs).

[0011] FIRST EXAMPLE EMBODIMENT <Overview>

[0012] Fig. 1 illustrates data structures that are handled by an data handling apparatus and used for memory authentication. There is a computer memory 10 that are divided into multiple memory locations, each of which can store memory data 20. The computer memory 10 is a storage medium storing temporary data, such as a random access memory (RAM). The memory location 12 can be identified by an identifier assigned thereto, such as an address.

[0013] The memory location 12 in which the memory data 20 is stored is associated with an authentication tag 30. The authentication tag 30 is generated using the corresponding memory data 20. For example, a hash function or other types of rules may be used to compute the authentication tag 30 from the corresponding memory data 20. When a predefined hash function is used, the authentication tag 30 is a hash value that is computed by applying the corresponding memory data 20 to the hash function.

[0014] To prevent identical authentication tags 30 from being generated from different memory data 20, nonces 40 (arbitrary numbers used once) are used in conjunction with the memory data 20. Each memory location 12 is also associated with the nonce 40. The nonce 40 corresponding to the memory location 12 is updated when the memory data 20 in the memory location 12 changes. For example, the nonce 40 may be an integer that increments with each update to the corresponding memory location 12. In this case, nonce can also be referred to as counter.

[0015] Suppose that a function F() is used to compute the tag T from a certain data D and a nonce N. In this case, the computation of the tag T can be denoted by T=F(D, N).

[0016] To ensure the integrity of the memory data 20, it is also required to ensure the integrity of the nonces 40. To ensure the integrity of the nonces 40, the nonces 40 are managed using a hieratical data structure, such as a tree. The tree 50 includes a root node 52, intermediary nodes 54, and a leaf nodes 56.

[0017] The root node 52 is the node located at the highest level of the tree 50. Unless otherwise stated, the level of the tree 50 at which the root node is located is referred to as level zero. The nonce 40 stored in the root node 52 is referred to as a root nonce.

[0018] The root node 52 is stored in a RoT (root of trust) storage device 70, which is inherently trusted and secure by design, and thus can be treated as an RoT. The RoT storage device 70 may be, for example, a temper-resistant storage. The integrity of the root nonce is assured since the root node 52 is stored in the RoT storage device 70.

[0019] The intermediary node 54 are nodes located between the root node 52 and the leaf nodes 56, and therefore have both a parent and one or more children. The intermediary node 54 includes a pair of the nonce tag 60 and the nonce 40.

[0020] The leaf nodes 56 are nodes having no children, and associated with an authentication tag 30 and one or more memory locations 12. The leaf node 56 also includes a pair of the nonce tag 60 and the nonce 40. The nodes other than the root node 52 are stored in a storage device 80, which is not treated as an RoT. The storage device 80 may be the computer memory 10 or another storage device, such as a RAM, a memory card, a hard disk, etc.

[0021] The nonce tag 60 stored in a particular node is computed using the nonce 40 stored in the parent of that particular node. Suppose that, as exemplified above, the function F(D, N) is used to compute a tag T from data D and a nonce N: i.e., T=F(D, N). In this case, the nonce 40 stored in a node is treated as the data D and the nonce 40 stored in the parent of that node is treated as the nonce N, thereby computing T as the nonce tag 60 to be stored in that node.

[0022] The authentication tag 30 is computed using the memory data 20 stored in the corresponding memory location 12 and the nonce 40 stored in the corresponding leaf node 56. When the function F(D, N) is used to compute a tag T from data D and a nonce N as mentioned above, T is computed as the authentication tag 30 by applying the memory data 20 stored in the corresponding memory location 12 as the data D and the nonce 40 stored in the corresponding leaf node 56 as the nonce N to the function F(D, N). It is noted that the function or rule to compute the authentication tag 30 can be different from that to compute the nonce tag 60.

[0023] It is noted that two or more trees 50 can be used. In this case, for example, the computer memory 10 is divided into two or more sections, and the tree 50 is generated for each section. In another example, two or more pieces of computer memory 10 are used, and the tree 50 is generated for each computer memory 10.

[0024] When the memory data 20 is being read, a system, referred to as a verification system, performs memory authentication on the memory data 20. The memory authentication on the memory data 20 requires the nonce 40 stored in the leaf node 56 corresponding to that memory data 20, hereinafter, referred to as a target nonce. Thus, the verification system sends the request for the target nonce.

[0025] Hereinafter, the data handling apparatus of the first example embodiment will be explained under the assumption depicted by Fig. 1. Fig. 2 illustrates an overview of a data handling apparatus 2000. It is noted that Fig. 2 does not limit operations of the data handling apparatus 2000, but merely show an example of possible operations of the data handling apparatus 2000.

[0026] The data handling apparatus 2000 acquires the identifier of the target nonce. Then, the data handling apparatus 2000 verifies the node in which the target nonce stored (hereinafter, referred to as a target node) and outputs result data, which represents the result of the verification on the target node. For example, the result data is the target nonce when the target node is determined to be valid whereas the target data is an error notification (e.g., a specific error code) that indicates the target node is determined to be invalid. It is noted that the verification of a node means the verification of the nonce stored in that node.

[0027] The verification of the target node requires the verification of the parent of the target node since the nonce 40 stored in the parent is required to verify the target node. The same applies to all the intermediary nodes 54 on the path from the target node to the root node 52. This means that, generally speaking, to the verification of the target node and the verification of all the parents of the target node except for the root node 52 are required to verify the target node. Hereinafter, this set of verifications required for the verification of the target node is called a verification chain for the target node.

[0028] The data handling apparatus 2000 is configured to handle a verification chain for the target node more efficiently than simply verifying all the parents of the target node. It is assumed that the data handling apparatus 2000 is configured to be capable of concurrently handling two or more verification chains. When two or more target nodes share common ancestor nodes, the verifications of those ancestors would be performed redundantly. These redundant executions of verifications waste the computer resources and the computation time.

[0029] To tackle this issue, the data handling apparatus 2000 manages the progress of the verification chains using state information, which indicates the current progress for each verification chain, thereby reducing redundancy in verifications of nodes.

[0030] Fig. 3 illustrates an example structure of the verification information 100. The verification information 100 includes a chain data 120 for each verification chain and a root data 130. The root data 130 includes the root nonce. The root nonce may be put into the root data 130 in advance or when the first time the root nonce is required to verify the node. It is noted that the verification information 100 may include two or more root data 130 when one or more trees 50 are used.

[0031] The chain data 120 indicates the current progress of the verification chain corresponding thereto. Specifically, the chain data 120 includes a head data 140 and one or more pieces of state data 150. The head data 140 indicates the identifier of the corresponding verification chain. The identifier of the verification chain may be the identifier of the target nonce for which this verification chain is being performed.

[0032] The state data 150 is associated with a node, and indicates the current progress of the verification of the corresponding node. The state data 150 is linked with other state data 150 to represent a chain of verifications. Specifically, the state data 150 of a particular node may be linked to the state data 150 of the parent of that particular node.

[0033] After acquiring the identifier of the target nonce, the data handling apparatus 2000 generates the chain data 120 for the target node and add it to the verification information 100. This chain data 120 includes the head data 140 and the state data 150 of the target node that are linked with each other.

[0034] Then, the data handling apparatus 2000 performs verification chain process for the target node to perform verification chain for the target node. In the verification chain process for the target node, the verification chain process is recursively performed for the ancestors of the target node if necessary. Specifically, the verification chain process for a node includes: recursively executing the verification chain process for the parent of the node if necessary; acquiring the node from the storage device 80; and verifying the node using the nonce 40 stored in the parent.

[0035] The verification chain process for the parent is not necessary when this verification chain process has already been initiated as a part of another verification chain. Thus, in the verification chain process, the data handling apparatus 2000 determines whether the verification information 100 includes the state data 150 of the parent. When the verification information 100 includes the state data 150 of the parent, the data handling apparatus 2000 does not perform verification chain process for the parent since the verification chain process for the parent has already been initiated. This means that recursive executions of the verification chain process stops at this point. On the other hand, when the verification information 100 does not include the state data 150 of the parent, the data handling apparatus 2000 performs the verification chain process for the parent.

[0036] It is noted that the node is verified after the verification chain process for its parent finishes. The node is verified as invalid when its parent is verified as invalid.

[0037] After the verification chain for the target node terminates, the data handling apparatus 2000 outputs the result data.

[0038] <Example of Advantageous Effect> 　　According to the data handling apparatus 2000, the current progress of each verification chain is managed using the verification information, and the verification chain process for the parent is not performed when this verification chain process has already been initiated. Due to this mechanism, the number of executions of the verification chain processes is reduced. Thus, according to the data handling apparatus 2000, the consumption of computer resources and the time required for acquiring the valid target node are reduced.

[0039] Hereinafter, more detailed explanation of the data handling apparatus 2000 will be described.

[0040] <Example of Functional Configuration> 　　Fig. 4 is a block diagram showing an example of the functional configuration of the data handling apparatus 2000. The data handling apparatus 2000 includes an acquiring unit 2020, a verifying unit 2040, and an output unit 2060.

[0041] The acquiring unit 2020 acquires the identifier (e.g., address) of the target node.

[0042] The verifying unit 2040 performs verification chain for the target node. Specifically, the verifying unit 2040 performs verification chain process for the target node. In the verification chain process for the target node, verification chain process is recursively performed for the ancestors of the target node if necessary.

[0043] Specifically, the verification chain process for a node determines whether the verification chain process for the parent has already been initiated, by referring to the verification information 100. The verifying unit 2040 performs verification chain process for the parent when the verification information 100 indicates that the verification chain process for the parent has not been initiated.

[0044] The verification chain process for the parent is also not performed when the parent is the root node 52. Since the root node 52 is stored in the RoT storage device 70, the validity of the root node 52 is assured without verification.

[0045] The output unit 2060 outputs the result data that indicates the result of the verification of the target node. For example, the target node is set to the result data when the target node is verified as valid while the error notification is set to the result data when the target node is verified as invalid.

[0046] <Example of Hardware Configuration> 　　The data handling apparatus 2000 may be realized by a special-purpose computer manufactured for implementing the data handling apparatus 2000, or may be a general-purpose computer. In some implementations, this computer is a semiconductor that includes a field-programmable gate arrays (FPGA), an application-specific integrated circuit (ASIC), or a microprocessor unit (MPU).

[0047] The computer is configured to execute a program (e.g., firmware) implementing the functional units of the data handling apparatus 2000. This means that the program causes the computer to function as the data handling apparatus 2000.

[0048] This program may be deployed in various ways. For example, the program is deployed by deploying a storage medium (such as a DVD (digital versatile disc) or a USB (Universal Serial Bus) memory) in which the program is stored in advance. In another example, the program can be downloaded from a server machine that manages a storage medium in which the program is stored in advance.

[0049] Fig. 5 is a block diagram illustrating an example of the hardware configuration of a computer 1000 that realizes the data handling apparatus 2000. In Fig. 5, the computer 1000 includes a bus 1020, a processor 1040, a primary storage 1060, a secondary storage 1080, a first interface 1100, and a second interface 1120.

[0050] The bus 1020 is a data transmission channel in order for the processor 1040, the primary storage 1060, the secondary storage 1080, the first interface 1100, and the second interface 1120 to mutually transmit and receive data. The processor 1040 is a processer, such as a FPGA, an ASIC or an MPU, that is configured to execute the instructions included in the above mentioned program.

[0051] The primary storage 1060 is a primary memory component, such as a RAM, on which the program to be executed by the processor 1040 is loaded from the secondary storage 1080. The verification information 100 and other temporary data may also be stored in the primary storage 1060.

[0052] The secondary storage 1080 is a secondary memory component, such as a read only memory (ROM) or a RAM, in which the program is stored in advance.

[0053] The first interface 1100 is an interface between the computer 1000 and a device (e.g., a processor such as a central processing unit (CPU)) that accesses the computer memory 10 to acquire the memory data 20. The second interface 1120 is an interface between the computer 1000 and the computer memory 10.

[0054] It is noted that, in some implementations, the functions of the data handling apparatus 2000 may be implemented as hardwired program, instead of software program. In this case, the functions of the data handling apparatus 2000 are embedded into hardware components such as logic circuits. The collection of the logic circuits that implements the data handling apparatus 2000 is included in a semiconductor device, such as ASICs or FPGAs.

[0055] <Flow of Process> 　　Fig. 6 is a flowchart illustrating an example of an overall flow of processes performed by the data handling apparatus 2000. The acquiring unit 2020 acquires the identifier of the target nonce (S102). The verifying unit 2040 generates the chain data 120 for the target node and add it to the verification information 100 (S104). The verifying unit 2040 performs verification chain process for the targe node (S106). The output unit 2060 outputs the result data (S108).

[0056] Fig. 7 is a flowchart illustrating an example flow of verification chain process. In Fig. 7, the node currently undergoing the verification chain process is denoted by Nc. In addition, the parent of the node Nc is denoted by Np.

[0057] The verifying unit 2040 determines whether the parent Np is the root node (S202). When the parent Np is the root node (S202: YES), the verifying unit 2040 links the state data 150 of the node Nc to the root data 130 (S204).

[0058] When the parent Np is not the root node (S202: NO), the verifying unit 2040 determines whether the verification information 100 includes the state data 150 of the parent Np (S206). When the verification information 100 includes the state data 150 of the parent Np (S206: YES), the verifying unit 2040 links the state data 150 of the node Nc to the state data 150 of the parent Np (S208).

[0059] When the verification information 100 does not include the state data 150 of the parent Np (S206: NO), the verifying unit 2040 generates the state data 150 of the parent Np (S210) and links the state data 150 of the node Nc to the state data 150 of the parent Np (S212).

[0060] Then, the verifying unit 2040 performs verification chain process for the parent Np (S214). It is preferable that the verification chain process for the parent Np is concurrently performed with the verification chain process for the node Nc. In this case, the verification chain process for the node Nc continues without waiting until the verification chain process for the parent Np finishes.

[0061] After Steps S204, S208, or S214, the verifying unit 2040 acquires the node Nc from the storage device 80 (S216) and verify it (S218). It is noted that, as described in detail later, the verification of the node Nc (S218) is performed after the parent Np is verified since the parent Np is required to verify the node Nc.

[0062] <As to State Information 100> 　　The verification information 100 is explained in more detail here. As mentioned above, the verification information 100 includes the chain data 120 for each verification chain. The chain data 120 includes the head data 140 identifying the verification chain and the state data 150 indicating the current progress of the verification of the corresponding node.

[0063] Fig. 8 illustrates an example of the more detailed structure of the head data 140 and the state data 150. The head data 140 includes an identifier 142 and a link 144. The identifier 142 includes the identifier of the corresponding verification chain. Specifically, the identifier 142 may indicates the identifier of the target node for which the corresponding verification chain is being performed. The link 144 indicates a link to the state data 150 of the target node.

[0064] In Fig. 8, the state data 150 includes a node identifier 151, a node 152, a verification flag 153, a valid flag 154, a number of children 155, a level 156, and a link 157. The node identifier 151 indicates the identifier of the corresponding node. The node 152 includes the content of the corresponding node, including the nonce tag 60 and the nonce 40. The verification flag 153 indicates whether the corresponding node has been verified. The valid flag 154 indicates whether the corresponding node is valid.

[0065] The number of children 155 indicates the number of the state data 150 of the children of the corresponding node. The level 156 indicates the level within the tree 50 at which the corresponding node is located. It is noted that the state data 150 need not to include the level 156 when a specific set of storage areas, e.g., a set of registers, is preassigned to each level of the tree 50 as exemplified later. The link 157 indicates a link to another state data 150 or the root data 130.

[0066] In some implementations, a specific storage area, e.g., a set of registers, is preassigned to the verification information 100. Fig. 9 illustrates an example of the storage area preassigned to the verification information 100. In this example, the storage area 200 includes a sub area 210 for each head data 140, a sub area 220 for each state data 150, and a sub area 230 for the root data 130. Each sub area may be realized by a certain type of storage device, such as a register. These storage devices may be installed in the computer, such as a semiconductor device, with which the data handling apparatus 2000 is implemented.

[0067] In Fig. 9, the storage area 200 is configured to include M sub areas 210 so that the verification information 100 can contain a maximum of M chain data 120 (M is an integer larger than one). The storage area 200 is configured to include M x K sub areas 220 so that each chain data 120 can contain a maximum of K state data 150 (K is an integer larger than one). Each sub area 220 is preassigned to a specific level of the tree. Specifically, the sub area 220 in the i-th column is preassigned to the i-th level of the tree 50, with the root node 52 being at level zero.

[0068] It is noted that the state data 150 does not need to include the level 156 when each sub area 220 is preassigned to a specific level of the tree 50. It is because the position of the sub area 220 in which the state data 150 is stored implicitly represents the level of the tree 50 at which the node corresponding to the state data 150 is located.

[0069] The link to the state data 150 can be indicated by a pair of the row number and the column number that represents the position of the sub area 220 in which this state data 150 is stored. As a premise, each sub area 220 is assigned a row number and a column number. In this case, at least logically, the sub areas 220 are arranged in a table form.

[0070] The link to the root data 130 can also be indicated by a pair of the row number and the column number that represents a position at which no sub area 220 exists. For example, the position (row, column) = (0, 0) is preassigned to the root data 130.

[0071] <Acquisition of Identifier of Target Node: S102> 　　The acquiring unit 2020 acquires the identifier of the target nonce (S102). There are various ways to acquire the identifier of the target nonce. For example, the acquiring unit 2020 receives, through the first interface 1100, the identifier of the target nonce that is sent from the device (e.g., a processor) that is requesting the valid target nonce. In another example, the identifier of the target nonce is stored at a specific storage device. In this case, the acquiring unit 2020 acquires the identifier of the target nonce from this storage device.

[0072] <Generation of Chain Data: S104> 　　The verifying unit 2040 generates the chain data 120 for the target node (S104). Specifically, the verifying unit 2040 generates the head data 140 and the state data 150 for the target node and link them with each other, thereby generating the chain data 120 for the target node storing those head data 140 and state data 150. The identifier 142 is set to the identifier of the target node in which the target nonce is stored. The link 144 is set to the sate data 150 of the target node.

[0073] Suppose that the verification information 100 is stored in the storage area 200. In this case, the verifying unit 2040 selects one of available sub areas 210, and stores the head data 140 into the selected sub area 210. In addition, the verifying unit 2040 selects one of available sub areas 220 from the column corresponding to the level of the tree 50 at which the target node is located, and stores the state data 150 of the target node into the selected sub area 220.

[0074] <Verification Chain Process: S106> 　　The verifying unit 2040 performs the verification chain process for the target node (S106). The overall flow of the verification chain process has been already exemplified with referring to Fig. 7. Hereinafter, the verification chain process depicted by Fig. 7 is further explained in more detail for the case where the storage area 200 is employed to store the verification information 100.

[0075] In Step S202, the verifying unit 2040 determines whether the parent Np is the root node 52. To perform this determination, the verifying unit 2040 determines the identifier of the parent Np. There may be various ways to determine the identifier of the parent Np. For example, when the address of the node is used as the identifier of the node, the addresses are assigned to the tree 50 in such a manner that the position of each node can be converted into the address of the node.

[0076] In Step S204, the verifying unit 2040 links the state data 150 of the node Nc to the root data 130. Specifically, the verifying unit 2040 sets the link 157 of the state data 150 of the node Nc to a predefined value representing the root data 130, e.g., (row, column) = (0,0).

[0077] In Step S206, the verifying unit 2040 determines whether the verification information 100 includes the state data 150 of the parent Np. Specifically, the verifying unit 2040 checks whether the node identifier 151 indicates the identifier of the parent Np, for each one of the state data 150 stored in the sub area 220 in the column corresponding to the level in the tree 50 at which the parent Np is located. Suppose that the node Nc is located at the level j in the tree 50. In this case, the verifying unit 2040 refers to the sub areas 220 in the j-1 th column.

[0078] When the verifying unit 2040 finds the node identifier 151 indicating the identifier of the parent Np, the verifying unit 2040 determines that the verification information 100 includes the state data 150 of the parent Np. On the other hand, the verifying unit 2040 does not find the node identifier 151 indicating the identifier of the parent Np, the verifying unit 2040 determines that the verification information 100 does not include the state data 150 of the parent Np.

[0079] In Step S208, the verifying unit 2040 links the state data 150 of the node Nc to the state data 150 of the parent Np. Specifically, the verifying unit 2040 sets the link 157 of the state data 150 of the node Nc to the position of the sub area 220 in which the state data 150 of the parent Np is stored. In addition, the verifying unit 2040 increments the number of children 155 of the state data 150 of the parent Np. Step S212 is performed in the same manner as Step S208.

[0080] In Step S210, the verifying unit 2040 generates the state data 150 of the parent Np. The verifying unit 2040 selects one of the available sub areas 220 from the column corresponding to the level at which the parent Np is located to store the state data 150 of the parent Np into this sub area 220.

[0081] As mentioned above, the state data 150 may include the node identifier 151, the node 152, the verification flag 153, the valid flag 154, the number of children 155, and the link 157. The verifying unit 2040 sets the node identifier 151 of the parent Np to the identifier of the parent Np, the verification flag 153 of the parent Np to false, and the number of children 155 of the parent Np to one. The verifying unit 2040 may set, to the node 152, a predefined value that represents the fact that the target node has not been acquired yet. The verifying unit 2040 may set arbitrary value to the valid flag 154 since the valid flag 154 represents nothing when the verification flag 153 indicates false.

[0082] In Step S216, the verifying unit 2040 acquires the node Nc from the storage device 80. In this step, the verifying unit 2040 stores the node Nc acquired from the storage device 80 into the node 152 of the state data 150 of the node Nc.

[0083] In Step S218, the verifying unit 2040 verifies the node Nc. In some implementations, the verifying unit 2040 performs a specific process, referred to as verification process, to verify the node Nc. Fig. 10 is an example flow of the verification process.

[0084] The verification of the node Nc requires the parent Np. Thus, the verification process for the node Nc is suspended until the node Np is verified (S302). There are various ways to notice that the node Np is verified. For example, in Step S302, the verifying unit 2040 repeatedly checks whether the verification flag 153 of the state data 150 of the parent Np indicates true. When this verification flag 153 indicates true, the verification process for the node Nc proceeds to Step S304.

[0085] The verifying unit 2040 determines whether the parent Np is valid (S304). Specifically, the verifying unit 2040 checks the valid flag 154 of the state data 150 of the parent Np. The parent Np is valid when this valid flag 154 indicates true while the parent Np is invalid when this valid flag 154 indicates false.

[0086] When the parent Np is invalid (S304: NO), the node Nc is determined as invalid. Specifically, the verifying unit 2040 sets the valid flag 154 of the node Nc to false (S312).

[0087] When the parent Np is valid (S304: YES), the verifying unit 2040 verifies the node Nc. Specifically, the verifying unit 2040 computes a current tag using the nonce 40 stored in the parent Np and the nonce 40 stored in the node Nc (S306), and determines whether this tag matches the nonce tag 60 stored in the node Nc (S308). It is noted that the nonce 40 stored in the parent Np can be acquired from the node 152 of the state data 150 of the parent Np that is linked from the state data 150 of the node Nc. It is also noted that the verification performed in Steps S306 and S308 may be delegated to an apparatus other than the data handling apparatus 2000.

[0088] When these tags match each other (S308: YES), the verifying unit 2040 sets the valid flag 154 of the state data 150 of the node Nc to true (S310), in order to represent that the node Nc is valid. When these tags do not match each other (S308: NO), the verifying unit 2040 sets the valid flag 154 to false (S312), in order to represent that the node Nc is invalid.

[0089] The verifying unit 2040 sets the verification flag 153 of the node Nc to true, in order to represent that the node Nc is verified (S312).

[0090] <<Schedule of Verification Process> 　　In some implementations, to efficiently perform verification processes, verification processes may be managed by a scheduler, referred to as verification scheduler to sequentially execute the verification processes. At least, the verification scheduler is configured to perform verification process for a node Nc after the parent Np is verified. Thus, in this case, the verification process does not need to include Step S302. In other words, the verification process does not need to be suspended until the verification of the parent finishes.

[0091] When the verification scheduler is employed, the verifying unit 2040 registers the node Nc in a verification list, which is a list of the nodes for which verification process is to be performed. The verification scheduler may be configured to repeatedly check the verification list, select one of the nodes from the verification list, and performs verification process for the selected node. Various scheduling algorithms, such as first in first out (FIFO), can be employed under the limitation that it is required to select the node from the verification list only after the parent of the node is verified.

[0092] <Deletion of Chain Data 120> 　　The verifying unit 2040 may delete the chain data 120 for the target node after the verification of that target node finishes. Specifically, the verifying unit 2040 deletes the chain data 120 by releasing the sub area 210 in which the head data 140 of that chain data 120 is stored and the sub areas 220 in which the state data 150 of that chain data 120 are stored, thereby making this sub area 210 and these sub areas 220 available for a future verification chain.

[0093] The sub area 210 may be released by setting a predefined value representing the sub area 210 is not used thereto. For example, this predefined value is set to a partial area of the sub area 210 that is preassigned to the identifier 142.

[0094] Similarly, the sub area 220 may be released by setting a predefined value representing the sub area 220 is not used thereto. For example this predefined value is set to a partial area of the sub area 220 that is preassigned to the node identifier 151.

[0095] The verifying unit 2040 can delete the chain data 120 at arbitrary timing after the verification of the target node finishes. For example, the verifying unit 2040 may delete after Step S218 (verification of node Nc) when the node Nc is the target node. In another example, the verifying unit 2040 may delete the chain data 120 after outputting the result data.

[0096] It is possible that one or more state data 150 are shared with other chain data 120. Thus, the verifying unit 2040 does not delete the state data 150, whose number of children 155 is larger than one, and its ancestors since those state data 150 are shared with other chain data 120.

[0097] Second Example Embodiment 　　The data handling apparatus 2000 of the second example embodiment is configured to store the node, which is acquired from the storage device 80 and verified as valid, into a cache storage for future use. This assures that the nodes stored in the cache storage are valid.

[0098] Thus, when the data handling apparatus 2000 is required to verify a node, the data handling apparatus 2000 tries to acquire this node from the cache storage first, and treat the node as valid without executing the verification chain process for this node when this node is acquired from the cache storage. When the node is not stored in the cache storage, the data handling apparatus 2000 acquires this node from the storage device 80 and verify it.

[0099] Fig. 11 is a flowchart illustrating an example of an overall flow of processes performed by the data handling apparatus 2000. The flow depicted by Fig. 11 is different from that depicted by Fig. 6 in that it has Step S402 between Steps S102 and S104. In Step S402, the verifying unit 2040 determines whether the target node is stored in the cache storage.

[0100] When the target node is stored in the cache storage, the data handling apparatus 2000 can acquire the target node that has been verified as valid from the cache storage, without performing the verification chain process for the target node. Thus, the output unit 2060 outputs the target node acquired from the cache storage as the result data when the target node is stored in the cache storage (S402: YES).

[0101] On the other hand, the target node is not stored in the cache storage, the data handling apparatus 2000 has to acquire the target node from the storage device 80 and verify it. Thus, when the target node is not stored in the cache storage (S402: NO), the verifying unit 2040 performs Steps S104 to S108.

[0102] As described in detail later, the verifying unit 2040 also tries to acquire the node from the cache storage in the chain verification process. When the node is acquired from the cache storage, the node is treated as valid without performing the verification process for that node. Since there is no need to verify that node, there is also no need to perform the verification chain process for the parent of that node.

[0103] Due to this mechanism, the number of executions of the verification chain processes is reduced. Thus, according to the data handling apparatus 2000, the consumption of computer resources and the time required for acquiring the valid target node are reduced.

[0104] <Verification Chain Process> 　　As mentioned above, the verifying unit 2040 also tries to acquire the node from the cache storage in the chain verification process. Hereinafter, the verification chain process performed by the verifying unit 2040 of the second example embodiment is exemplified.

[0105] Fig. 12 and Fig. 13 show a flowchart illustrating an example flow of verification chain process. The flow depicted by Fig. 12 and Fig. 13 is different from that depicted by Fig. 7 in that it has Steps 502 to S512 instead of S210 to S214.

[0106] When the verification information 100 does not include the state data 150 of the parent Np (S206: NO), the processes depicted by Fig. 13 are performed before performing Step S216. Specifically, the verifying unit 2040 determines whether the parent Np is stored in the cache storage (S502). When the parent Np is stored in the cache storage (S502: YES), the verifying unit 2040 generates the state data 150 of the parent Np (S504). Since the parent Np is acquired from the cache storage, the state data 150 of the parent Np is generated to indicate that the parent Np has already been verified as valid in Step S504. Specifically, the verifying unit 2040 sets both the verification flag 153 and the valid flag 154 to true.

[0107] After Step S504, the verifying unit 2040 links the state data 150 of the parent Np to the state data 150 of the node Nc (S506). Then, the verification chain process for the node Nc proceeds to S216, which is depicted by Fig. 12.

[0108] When it is determined that the parent Np is not stored in the cache storage in Step S502 (S502: NO), the verifying unit 2040 generates the state data 150 of the parent Np in the same manner as Step S210 (S508). In this case, the verification flag 153 is set to false to indicate that the parent Np is unverified. Then, the verifying unit 2040 links the state data 150 of the node Nc to the state data 150 of the parent Np (S510). Further, the verifying unit 2040 performs the verification chain process for the parent Np (S512). The verification chain process for the node Nc proceeds to Step S216, which is depicted by Fig. 12.

[0109] <Example of Hardware Configuration> 　　The hardware configuration of the computer 1000 by which the data handling apparatus 2000 may be illustrated by Fig. 5. However, the secondary storage 1080 stores the program that implements the data handling apparatus 2000 of the second example embodiment. In addition, the computer 1000 includes the cache storage or the computer 1000 has access to the cache storage installed outside the computer 1000.

[0110] The program can be stored and provided to a computer using any type of non-transitory computer readable media. Non-transitory computer readable media include any type of tangible storage media. Examples of non-transitory computer readable media include magnetic storage media (such as floppy disks, magnetic tapes, hard disk drives, etc.), optical magnetic storage media (e.g., magneto-optical disks), CD-ROM (compact disc read only memory), CD-R (compact disc recordable), CD-R / W (compact disc rewritable), and semiconductor memories (such as mask ROM, PROM (programmable ROM), EPROM (erasable PROM), flash ROM, RAM (random access memory), etc.). The program may be provided to a computer using any type of transitory computer readable media. Examples of transitory computer readable media include electric signals, optical signals, and electromagnetic waves. Transitory computer readable media can provide the program to a computer via a wired communication line (e.g., electric wires, and optical fibers) or a wireless communication line.

[0111] Although the present disclosure is explained above with reference to example embodiments, the present disclosure is not limited to the above-described example embodiments. Various modifications that can be understood by those skilled in the art can be made to the configuration and details of the present disclosure within the scope of the invention.

[0112] The whole or part of the example embodiments disclosed above can be described as, but not limited to, the following supplementary notes. <Supplementary notes> (Supplementary Note 1) 　　A data handling apparatus comprising: 　　at least one logic circuit that is configured to: 　　acquire an identifier of a target nonce that is stored in a leaf node of a tree, wherein the tree includes: a root node storing a nonce; a plurality of intermediary nodes storing a nonce and a tag; and a plurality of the leaf nodes storing a nonce and a tag, and wherein the tag stored in a node is computed using the nonce that is valid and stored in a parent of the node and the nonce stored in the node, 　　generate a chain data for a target node that is the node storing the target nonce and add the chain data to verification information, wherein the chain data represents a progress of a set of verification chain process for the target node and one or more verification chain processes for ancestors of the target node, wherein the verification chain process can be concurrently performed for a plurality of the target nodes, and wherein the verification information includes the chain data for each target node for which the verification chain process is in progress; 　　execute the verification chain process for the target node; and 　　output the target node when the target node is verified as valid, 　　wherein the verification chain process for a particular node includes: 　　　　using the chain data to determine whether the verification chain process for the parent of the particular node has been initiated; 　　　　recursively executing the verification chain process for the parent when the verification chain process for the parent has not been initiated; and 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent. (Supplementary Note 2) 　　The data handling apparatus according to supplementary note 1, 　　wherein the chain data includes state data for each node for which the verification chain process is being executed, 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the state data of the nodes located at one level higher than the particular node in the tree. (Supplementary Note 3) 　　The data handling apparatus according to supplementary note 2, 　　wherein, for each level of the tree, two or more storage areas are preassigned to store the state data of the node located at the level corresponding thereto, and 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the storage areas corresponding to the level at which the parent is located. (Supplementary Note 4) 　　The data handling apparatus according to supplementary note 1, 　　wherein the target node verified as valid is stored in a cache storage; 　　wherein the at least one logic circuit is configured further to: 　　determine whether the target node is stored in a cache storage; and 　　output the target node when the target node is stored in the cache storage, without executing the verification chain process for the target node. (Supplementary Note 5) 　　The data handling apparatus according to supplementary note 4, 　　wherein the verification of the particular node includes: 　　　　determining whether the parent of the particular node is stored in the cache storage; 　　　　determining that the parent is valid when the parent is stored in the cache storage; 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent; and 　　　　storing the particular node into the cache storage when the particular node is verified as valid. (Supplementary Note 6) 　　A data handling method performed by a computer, comprising: 　　acquiring an identifier of a target nonce that is stored in a leaf node of a tree, wherein the tree includes: a root node storing a nonce; a plurality of intermediary nodes storing a nonce and a tag; and a plurality of the leaf nodes storing a nonce and a tag, and wherein the tag stored in a node is computed using the nonce that is valid and stored in a parent of the node and the nonce stored in the node, 　　generating a chain data for a target node that is the node storing the target nonce and add the chain data to verification information, wherein the chain data represents a progress of a set of verification chain process for the target node and one or more verification chain processes for ancestors of the target node, wherein the verification chain process can be concurrently performed for a plurality of the target nodes, and wherein the verification information includes the chain data for each target node for which the verification chain process is in progress; 　　executing the verification chain process for the target node; and 　　outputting the target node when the target node is verified as valid, 　　wherein the verification chain process for a particular node includes: 　　　　using the chain data to determine whether the verification chain process for the parent of the particular node has been initiated; 　　　　recursively executing the verification chain process for the parent when the verification chain process for the parent has not been initiated; and 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent. (Supplementary Note 7) 　　The data handling method according to supplementary note 6, 　　wherein the chain data includes state data for each node for which the verification chain process is being executed, 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the state data of the nodes located at one level higher than the particular node in the tree. (Supplementary Note 8) 　　The data handling method according to supplementary note 7, 　　wherein, for each level of the tree, two or more storage areas are preassigned to store the state data of the node located at the level corresponding thereto, and 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the storage areas corresponding to the level at which the parent is located. (Supplementary Note 9) 　　The data handling method according to supplementary note 6, 　　wherein the target node verified as valid is stored in a cache storage; 　　wherein the data handling method further comprises: 　　determining whether the target node is stored in a cache storage; and 　　outputting the target node when the target node is stored in the cache storage, without executing the verification chain process for the target node. (Supplementary Note 10) 　　The data handling method according to supplementary note 9, 　　wherein the verification of the particular node includes: 　　　　determining whether the parent of the particular node is stored in the cache storage; 　　　　determining that the parent is valid when the parent is stored in the cache storage; 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent; and 　　　　storing the particular node into the cache storage when the particular node is verified as valid. (Supplementary Note 11) 　　A non-transitory computer-readable medium storing a program that causes a computer to execute: 　　acquiring an identifier of a target nonce that is stored in a leaf node of a tree, wherein the tree includes: a root node storing a nonce; a plurality of intermediary nodes storing a nonce and a tag; and a plurality of the leaf nodes storing a nonce and a tag, and wherein the tag stored in a node is computed using the nonce that is valid and stored in a parent of the node and the nonce stored in the node, 　　generating a chain data for a target node that is the node storing the target nonce and add the chain data to verification information, wherein the chain data represents a progress of a set of verification chain process for the target node and one or more verification chain processes for ancestors of the target node, wherein the verification chain process can be concurrently performed for a plurality of the target nodes, and wherein the verification information includes the chain data for each target node for which the verification chain process is in progress; 　　executing the verification chain process for the target node; and 　　outputting the target node when the target node is verified as valid, 　　wherein the verification chain process for a particular node includes: 　　　　using the chain data to determine whether the verification chain process for the parent of the particular node has been initiated; 　　　　recursively executing the verification chain process for the parent when the verification chain process for the parent has not been initiated; and 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent. (Supplementary Note 12) 　　The medium according to supplementary note 11, 　　wherein the chain data includes state data for each node for which the verification chain process is being executed, 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the state data of the nodes located at one level higher than the particular node in the tree. (Supplementary Note 13) 　　The medium according to supplementary note 12, 　　wherein, for each level of the tree, two or more storage areas are preassigned to store the state data of the node located at the level corresponding thereto, and 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the storage areas corresponding to the level at which the parent is located. (Supplementary Note 14) 　　The medium according to supplementary note 11, 　　wherein the target node verified as valid is stored in a cache storage; 　　wherein the program causes the computer to further execute: 　　determining whether the target node is stored in a cache storage; and 　　outputting the target node when the target node is stored in the cache storage, without executing the verification chain process for the target node. (Supplementary Note 15) 　　The medium according to supplementary note 14, 　　wherein the verification of the particular node includes: 　　　　determining whether the parent of the particular node is stored in the cache storage; 　　　　determining that the parent is valid when the parent is stored in the cache storage; 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent; and 　　　　storing the particular node into the cache storage when the particular node is verified as valid.

[0113] 10　　computer memory 12　　memory location 20　　memory data 30　　authentication tag 40　　nonce 50　　tree 52　　root node 54　　intermediary node 56　　leaf node 60　　nonce tag 70　　RoT storage device 80　　storage device 100　　verification information 120　　chain data 130　　root data 140　　head data 142　　identifier 144　　link 150　　state data 151　　node identifier 152　　node 153　　verification flag 154　　valid flag 155　　number of children 156　　level 157　　link 200　　storage area 210　　sub area 220　　sub area 230　　sub area 1000　　computer 1020　　bus 1040　　processor 1060　　primary storage 1080　　secondary storage 1100　　first interface 1120　　second interface 2000　　data handling apparatus 2020　　acquiring unit 2040　　verifying unit 2060　　output unit

Claims

1. A data handling apparatus comprising: 　　at least one logic circuit that is configured to: 　　acquire an identifier of a target nonce that is stored in a leaf node of a tree, wherein the tree includes: a root node storing a nonce; a plurality of intermediary nodes storing a nonce and a tag; and a plurality of the leaf nodes storing a nonce and a tag, and wherein the tag stored in a node is computed using the nonce that is valid and stored in a parent of the node and the nonce stored in the node, 　　generate a chain data for a target node that is the node storing the target nonce and add the chain data to verification information, wherein the chain data represents a progress of a set of verification chain process for the target node and one or more verification chain processes for ancestors of the target node, wherein the verification chain process can be concurrently performed for a plurality of the target nodes, and wherein the verification information includes the chain data for each target node for which the verification chain process is in progress; 　　execute the verification chain process for the target node; and 　　output the target node when the target node is verified as valid, 　　wherein the verification chain process for a particular node includes: 　　　　using the chain data to determine whether the verification chain process for the parent of the particular node has been initiated; 　　　　recursively executing the verification chain process for the parent when the verification chain process for the parent has not been initiated; and 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent.

2. The data handling apparatus according to claim 1, 　　wherein the chain data includes state data for each node for which the verification chain process is being executed, 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the state data of the nodes located at one level higher than the particular node in the tree.

3. The data handling apparatus according to claim 2, 　　wherein, for each level of the tree, two or more storage areas are preassigned to store the state data of the node located at the level corresponding thereto, and 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the storage areas corresponding to the level at which the parent is located.

4. The data handling apparatus according to claim 1, 　　wherein the target node verified as valid is stored in a cache storage; 　　wherein the at least one logic circuit is configured further to: 　　determine whether the target node is stored in a cache storage; and 　　output the target node when the target node is stored in the cache storage, without executing the verification chain process for the target node.

5. The data handling apparatus according to claim 4, 　　wherein the verification of the particular node includes: 　　　　determining whether the parent of the particular node is stored in the cache storage; 　　　　determining that the parent is valid when the parent is stored in the cache storage; 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent; and 　　　　storing the particular node into the cache storage when the particular node is verified as valid.

6. A data handling method performed by a computer, comprising: 　　acquiring an identifier of a target nonce that is stored in a leaf node of a tree, wherein the tree includes: a root node storing a nonce; a plurality of intermediary nodes storing a nonce and a tag; and a plurality of the leaf nodes storing a nonce and a tag, and wherein the tag stored in a node is computed using the nonce that is valid and stored in a parent of the node and the nonce stored in the node, 　　generating a chain data for a target node that is the node storing the target nonce and add the chain data to verification information, wherein the chain data represents a progress of a set of verification chain process for the target node and one or more verification chain processes for ancestors of the target node, wherein the verification chain process can be concurrently performed for a plurality of the target nodes, and wherein the verification information includes the chain data for each target node for which the verification chain process is in progress; 　　executing the verification chain process for the target node; and 　　outputting the target node when the target node is verified as valid, 　　wherein the verification chain process for a particular node includes: 　　　　using the chain data to determine whether the verification chain process for the parent of the particular node has been initiated; 　　　　recursively executing the verification chain process for the parent when the verification chain process for the parent has not been initiated; and 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent.

7. The data handling method according to claim 6, 　　wherein the chain data includes state data for each node for which the verification chain process is being executed, 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the state data of the nodes located at one level higher than the particular node in the tree.

8. The data handling method according to claim 7, 　　wherein, for each level of the tree, two or more storage areas are preassigned to store the state data of the node located at the level corresponding thereto, and 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the storage areas corresponding to the level at which the parent is located.

9. The data handling method according to claim 6, 　　wherein the target node verified as valid is stored in a cache storage; 　　wherein the data handling method further comprises: 　　determining whether the target node is stored in a cache storage; and 　　outputting the target node when the target node is stored in the cache storage, without executing the verification chain process for the target node.

10. The data handling method according to claim 9, 　　wherein the verification of the particular node includes: 　　　　determining whether the parent of the particular node is stored in the cache storage; 　　　　determining that the parent is valid when the parent is stored in the cache storage; 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent; and 　　　　storing the particular node into the cache storage when the particular node is verified as valid.

11. A non-transitory computer-readable medium storing a program that causes a computer to execute: 　　acquiring an identifier of a target nonce that is stored in a leaf node of a tree, wherein the tree includes: a root node storing a nonce; a plurality of intermediary nodes storing a nonce and a tag; and a plurality of the leaf nodes storing a nonce and a tag, and wherein the tag stored in a node is computed using the nonce that is valid and stored in a parent of the node and the nonce stored in the node, 　　generating a chain data for a target node that is the node storing the target nonce and add the chain data to verification information, wherein the chain data represents a progress of a set of verification chain process for the target node and one or more verification chain processes for ancestors of the target node, wherein the verification chain process can be concurrently performed for a plurality of the target nodes, and wherein the verification information includes the chain data for each target node for which the verification chain process is in progress; 　　executing the verification chain process for the target node; and 　　outputting the target node when the target node is verified as valid, 　　wherein the verification chain process for a particular node includes: 　　　　using the chain data to determine whether the verification chain process for the parent of the particular node has been initiated; 　　　　recursively executing the verification chain process for the parent when the verification chain process for the parent has not been initiated; and 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent.

12. The medium according to claim 11, 　　wherein the chain data includes state data for each node for which the verification chain process is being executed, 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the state data of the nodes located at one level higher than the particular node in the tree.

13. The medium according to claim 12, 　　wherein, for each level of the tree, two or more storage areas are preassigned to store the state data of the node located at the level corresponding thereto, and 　　wherein it is determined that the verification chain process for the parent of the particular node has not been initiated when failing to detect the state data of the parent from the storage areas corresponding to the level at which the parent is located.

14. The medium according to claim 11, 　　wherein the target node verified as valid is stored in a cache storage; 　　wherein the program causes the computer to further execute: 　　determining whether the target node is stored in a cache storage; and 　　outputting the target node when the target node is stored in the cache storage, without executing the verification chain process for the target node.

15. The medium according to claim 14, 　　wherein the verification of the particular node includes: 　　　　determining whether the parent of the particular node is stored in the cache storage; 　　　　determining that the parent is valid when the parent is stored in the cache storage; 　　　　verifying the particular node using the tag stored in the particular node and the nonce stored in the parent; and 　　　　storing the particular node into the cache storage when the particular node is verified as valid.

Images