Secret calculation device, secret distribution system, secret distribution restoration method, and program
The secure computing device's commit history table management system addresses the challenge of maintaining database consistency post-failure by identifying and correcting commit misalignments within the secret sharing system, ensuring efficient recovery without decrypting the secret sharing value, thus maintaining database consistency among secure computing devices.
Patent Information
- Application Number
- PCT/JP2023/019913
- Authority / Receiving Office
- WO · WO
- Patent Type
- Applications
- Current Assignee / Owner
- Filing Date
- 2023-05-29
- Publication Date
- 2024-12-05
AI Technical Summary
In a secret sharing system, when a failure occurs, restoring consistency among secure computing devices is challenging, especially in identifying and correcting commit misalignments without revealing shares, and existing methods are inefficient for large datasets.
A secure computing device with a storage unit, table sharing unit, commit deviation detection unit, and secret sharing value recovery unit manages a plaintext commit history table to identify and correct inconsistencies among secure computing devices, allowing regeneration of secret sharing tables without decrypting the secret sharing value, thus maintaining database consistency.
This approach enables consistent database recovery among secure computing devices without plaintext restoration, reducing processing time by utilizing the commit history table to identify and correct inconsistencies, even in cases where less than k devices are affected.
Smart Images

Figure JP2023019913_05122024_PF_FP_ABST
Abstract
Description
Secure computing device, secret sharing system, secret sharing recovery method, and program
[0001] The disclosed technology relates to a method for recovering a secret sharing system storing secret shared data when a failure occurs.
[0002] In general cryptographic methods, even if data to be kept secret is encrypted and stored in a secure computing device, the value must first be decrypted before calculations can be performed. In contrast, a secure computation technique described in Reference 1 (Koji Senda et al., "Rethinking Lightweight Verifiable Three-Party Secure Function Computation," CSS 2010) allows calculations to be performed while the data remains encrypted. Reference 1 discloses a multi-party protocol in which a single number is converted into multiple encrypted shares, and N secure computing devices each have a share, allowing them to perform addition, multiplication, logical operations, etc. without disclosing their own share information.
[0003] In a (k,N) secret sharing system, if there are k shares out of N shares, the original value can be restored. Therefore, the premise of security is that each secure computing device does not leak its own shares to other secure computing devices (information-theoretic security). Therefore, if k or more secure computing devices are attacked, it is not possible to protect the shares, but it is possible to design a system that maintains security by assuming that less than k secure computing devices are attacked.
[0004] Attackers can be classified into passive and active attackers depending on the type of attack. Passive attackers only peek at data. In secure computation, in addition to their own data, they also peek at data obtained during the secure computation process, attempting to obtain information about the original value or the original value itself from this data. They are also called semi-honest or honest-but-curious. Active attackers not only peek at data, but also tamper with it or perform arbitrary actions not specified in the protocol (such as sending unnecessary data). In secure computation, they tamper with their own data and data obtained during the secure computation process, so that the data received by other secure computation devices becomes tampered values, causing them to output invalid computation results, or attempting to obtain information about the original value or the original value itself. They are also called malicious.
[0005] Assuming a case in which less than k secure computing devices are attacked by an active attacker and shares are tampered with, a secure computing protocol has been proposed that detects inconsistencies from the shares of N secure computing devices (Patent Document 1). This protocol can detect inconsistencies when N >= 2k-1, and can identify tampered shares (secure computing devices) when N >= 2k.
[0006] Published Patent Application No. 2016-145880
[0007] In a typical DB system, the options when a failure occurs are as follows: (1) After recovery, roll back or roll forward the DB and return to the state before or after the in-progress process was executed. (2) In an active / standby configuration, switch to the standby machine and return the DB state to the state before or after the in-progress process was executed. (3) Recover from backup data and return to the latest state for which backup data is available.
[0008] In a secret sharing system, if a failure occurs in x secure computing devices, it is not enough to restore only the DB state of the failed device itself when the secure computing device is restarted or when switching between active and standby. It is also necessary to ensure consistency with the other Nx devices that are not experiencing failures, and to prevent DB inconsistency from occurring between the N secure computing devices after recovery. In a secret sharing system, even under normal circumstances, the order and timing of DB access is thought to be synchronized in order to maintain DB consistency between the N secure computing devices. However, if a failure occurs in x of the N devices, a commit gap will occur depending on the timing of the failure.
[0009] Note that "commit" as used in this specification refers to the commit operation of one DB in a general sense, and "commit misalignment" refers to the coexistence of N secure computing devices in which the DB commit operation for the same request has been completed (committed secure computing devices) and in which it has not been completed (uncommitted secure computing devices).
[0010] One way to detect whether a commitment gap has occurred is to use the inconsistency detection secure computation protocol mentioned above. When using this protocol, if k+1 or more DBs are committed, it is possible to identify uncommitted shares, but if k DBs are committed, it is not possible to identify corrupted shares. This process is explained using Figure 1.
[0011] First, a brief explanation of Shamir's secret sharing will be given. <Secret sharing> Let s be the information you want to keep secret. Create a k-1-th order function f(x) whose constant term is s. Find the coordinates (x) of the points through which f(x) passes. i ,f(x i ))(i=1,2,...,N, N>k) are shares. This is called Shamir's (k,N) secret sharing. <Information recovery> Obtain k arbitrary coordinates from N shares. Find the k-1 degree function f(x) that passes through all the coordinates. f(0) is the secret information.
[0012] Figure 1(a) illustrates the relationship between secret information and shares for (k,N)=(2,4). Reference numeral 101 denotes secret information, and 102 to 105 denote shares distributed to each secure computing device. Figure 1(b) illustrates the relationship between secret information and shares for (k,N)=(2,3). Reference numeral 106 denotes secret information, and 107 to 109 denote shares distributed to each secure computing device. Since k-1=1 in both cases, the shares lie on a straight line (linear function).
[0013] Figures 1(a-2) and (b-2) show how share inconsistency occurs due to a commit slippage. In (a-2), shares 102, 103, and 105 are on the same line, so share 104-1 is inconsistent. As shown in (a-2), x i The share can be restored from the value of (b-2). In the case of (b-2), shares 107, 108-1, and 109 are not on the same line, so it is clear that an inconsistency has occurred. However, since a linear function is determined when there are two shares, it is not clear which share is inconsistent.
[0014] Furthermore, in the inconsistency detection disclosed in Patent Document 1, if the target data size is large, it is expected that the processing will take a long time.
[0015] In order to solve the above problems, a secure computing device according to the disclosed technology includes a storage unit, a table sharing means, a commit misalignment detection unit, and a secret sharing value recovery unit. The storage unit stores a plaintext commit history table, and shares the commit history table with other secure computing devices via the table sharing means. The commit misalignment detection unit extracts secret sharing tables with inconsistent commits based on the shared commit history table. If the number of committed secure computing devices is k or more, the secret sharing value recovery unit performs, in cooperation with the other secure computing devices, a process of regenerating and overwriting the secret sharing tables of the uncommitted secure computing devices from the secret sharing tables of the committed secure computing devices, and if the number of committed secure computing devices is less than k and the number of uncommitted secure computing devices is k or more, the secret sharing value recovery unit performs, in cooperation with the other secure computing devices, a process of regenerating and overwriting the secret sharing tables of the committed secure computing devices from the secret sharing tables of the uncommitted secure computing devices.
[0016] According to the disclosed technology, if a commit mismatch occurs among N secure computing devices due to a failure or other reason, it is possible to restore the consistency of the DBs of the N secure computing devices without restoring the secret sharing values to plaintext. Since the size of the commit history table itself is expected to be small and the table to be restored can be identified from the commit history table, processing time can be shortened.
[0017] FIG. 1 is a diagram for explaining an overview of problems in the prior art and solutions thereto. FIG. 1 is a configuration diagram of a secret sharing system according to a first embodiment. FIG. 2 is a functional block diagram of a secure computing device according to a first embodiment. FIG. 3 is a diagram for explaining a failure recovery procedure according to the first embodiment using a specific example. FIG. 4 is a flowchart for explaining the operation of a secure computing device according to a first embodiment. FIG. 5 is a flowchart for explaining the operation of a plaintext recovery unit according to the first embodiment. FIG. 6 is a flowchart for explaining the operation of a secret sharing value recovery unit according to the first embodiment. FIG. 7 is a flowchart for explaining the operation of a secure computing device according to a second embodiment. FIG. 8 is a diagram showing an example of the functional configuration of a computer.
[0018] Hereinafter, embodiments of the disclosed technology will be described in detail. Note that components having the same functions are assigned the same numbers, and duplicated descriptions will be omitted.
[0019] [Key Points of the Disclosed Technology] The key points of the disclosed technology will be explained with reference to Fig. 1. With the technology of Patent Document 1, when k+1 or more DBs are committed, it is possible to identify uncommitted shares, but when k DBs are committed, it is not possible to identify corrupted shares. This is because the corrupted shares are identified by secure computation.
[0020] The disclosed technology prepares a new plaintext "commit history table" that identifies the commit misalignment between secure computing devices and identifies the shares that should be restored. As shown in Figures 1(a-3) and (b-3), if the shares that should be restored (104-1 and 108-1) can be identified, the inconsistent shares can be restored to the line that the consistent shares follow.
[0021] [Notation] The notation in the disclosed technology will be explained. N (N≧2) secure computing devices S 0 , S1 , . . . , S N-1 In this case, the value a∈Z is n The encrypted value (secret sharing value) is [a] i ∈Z n Let's say Z n is a finite ring consisting of the set of integers from 0 to n (n is an integer greater than or equal to 1). However, each S i Since the algorithm is common in [a], the notation of the algorithm is [a] without considering i. i (1) The encrypted (secretly shared) table T is denoted as [T]. (2) The secure computing device S i The plaintext table T stored by j S i .T j (3) Secure computing device S i The encryption table [T j ] to S i .[T j ]. (4) Let j ≥ k, and S 0 .[T i ],S 1 .[T i ],..., S j .[T i The process of selecting k arbitrary secret sharing values from
[0000] and creating new secret sharing values from the k secret sharing values is called "secret reproduction process."
[0022] 2 is a diagram showing an example of the configuration of a secret sharing system according to a first embodiment of the disclosed technology. The secret sharing system 2 includes N (N≧3) secure computing devices S 0 ,..,S i ,..,S N-1 are connected via a network 202. Each secure computing device 201 stores a table T 0 ,T 1 ,..,T x-1 is encrypted (secret sharing) [T 0 ],[T 1 ],..,[T x-1 ] and a memory unit that stores a table of plaintexts, and a secret sharing system is constructed in which the original value can be restored using k secret sharing values.
[0023] 3 is a functional block diagram showing an example of the configuration of one secure computing device 201. The secure computing device 201 includes a commitment deviation detection unit 301, a plaintext recovery unit 302, a secret sharing value recovery unit 303, a communication unit 304, and a data storage unit 305. The secure computing device 201 cooperates with other secure computing devices via the communication unit 304 to perform multiplication, logical operations, etc. The data storage unit 305 stores table T 0 ,T 1 ,..,T x-1 is encrypted (secret sharing) [T 0 ],[T 1 ],..,[T x-1 ]. The data storage unit also stores a plaintext commit history table that manages the committed / uncommitted status of secure computation requests. Figure 4 shows an example of a commit history table for three secure computing devices. The commit history table manages secure computation request identifiers (request IDs), commit target tables, and commit processing dates and times.
[0024] <Specific Example of Secret Sharing Recovery Procedure> A specific example of the secret sharing recovery procedure when (k, N)=(2, 3) will be described with reference to FIG.
[0025] <Sharing of Commit History Table> First, the secure computing devices 1, 2, and 3 share the commit history tables they manage.
[0026] <Extracting inconsistent records> Next, extract records with inconsistent commit states. The record with request ID 1000 has all three machines committed and is consistent. The record with request ID 1001 has all three machines uncommitted and is consistent. The record with request ID 1002 has two machines committed and one machine uncommitted and is inconsistent. Therefore, table C is the target for recovery.
[0027] <Determining the Recovery Method> In the first embodiment, a table is recovered based on the following concepts: (1) When the table includes shares: (1-1) When the number of committed secure computing devices is k or more, the shares of the uncommitted secure computing devices are restored from the shares of the committed secure computing devices, and the DB of the uncommitted secure computing devices is overwritten (roll forward). (1-2) When the number of committed secure computing devices is less than k, and the number of uncommitted secure computing devices is k or more, the shares of the committed secure computing devices are restored from the shares of the uncommitted secure computing devices, and the DB of the committed secure computing devices is overwritten (roll back).
[0028] (2) When the table does not contain shares: (2-1) If the number of committed secure computing devices is k or more, copy data from the committed secure computing devices and overwrite the DB of the uncommitted secure computing devices (roll forward). (2-2) If the number of committed secure computing devices is less than k, copy data from the uncommitted secure computing devices and overwrite the DB of the committed secure computing devices (roll back).
[0029] Then, since table C corresponds to the above (1-1), the shares of secure computing apparatus 3 (uncommitted) are restored from the shares of secure computing apparatuses 1 and 2 (committed), and the DB of secure computing apparatus 3 is overwritten. Note that existing technology can be used to restore the shares. For example, the share recovery method described in Reference Document 2 (Patent Publication No. 59684) can be used.
[0030] The next record with request ID 1003 is processed in the same way. Table D has one committed record and two uncommitted records, which is inconsistent. And since the data is a "share," the inconsistent state corresponds to (1-2) above. Therefore, the share of secure computing apparatus 1 (committed) is restored from the shares of secure computing apparatuses 2 and 3 (uncommitted), and the DB of secure computing apparatus 1 is overwritten.
[0031] The next record with request ID 1004 is processed in the same way. Table E has one committed record and two uncommitted records, which means it is inconsistent. And since the data is "plain text," the inconsistent state corresponds to (2-2) above. Therefore, the data is copied from secure computing devices 2 and 3 (uncommitted) and overwrites the DB of secure computing device 1 (committed).
[0032] A generalized procedure of the above will now be described. Fig. 5 is a flowchart illustrating an example of the operation of the secure computing device 201. Fig. 6 is a flowchart illustrating an example of the operation of the plaintext recovery unit 302. Fig. 7 is a flowchart illustrating an example of the operation of the secret sharing value recovery unit 303.
[0033] A secret computation request R i For the commit target, T i , the number of committed secure computing devices is j, and the number of committed secure computing devices is S c0 , S c1 ,..., S cj , the uncommitted secret sharing value is S u0 , S u1 ,...,S u(N-j) Let T be the commit history table. com Let's say.
[0034] <Sharing of Commit History Table> Each secure computing device transmits its own commit history table to other secure computing devices to share it (step S501). c0 .T com ,S c1 .T com ,..., S cj .T com , S u0 .T com ,S u1 .T com ,..., S u(N-j) .T com The commit history table is shared by a predetermined secure computing device S x After consolidating into S x The secure computing device may transmit the secure computing information to each of the secure computing devices.
[0035] <Extraction of Inconsistent Record> The commit mismatch detection unit 301 extracts one record whose commit is inconsistent (step S502).
[0036] <Counting Committed Secure Computing Devices> The commitment discrepancy detection unit 301 counts the number of committed secure computing devices. The count result is j (step S503).
[0037] <Determining Data Type> The commit mismatch detection unit 301 determines whether the recovery target table is a table including share data (step S504), and outputs the recovery target table to the plaintext recovery unit if Yes, or to the secret sharing value recovery unit if No.
[0038] <Plaintext Table Recovery Process> The plaintext recovery unit 302 determines whether j is greater than or equal to k (step S505). If yes, it performs a first plaintext recovery process (described later), and if no, it performs a second plaintext recovery process (described later).
[0039] <Share Table Recovery Process> The secret sharing value recovery unit 303 determines whether j is greater than or equal to k (step S508), and if yes, performs the first share recovery process (described later). If step S508 is no, the secret sharing value recovery unit 303 determines whether (N-j) is greater than or equal to k (step S510), and if yes, performs the second share recovery process (described later). If step S510 is no, the share recovery process cannot be performed, so recovery is performed from backup data, for example.
[0040] <First plaintext recovery process> Fig. 6(a) is a flowchart explaining the "first plaintext recovery process" in Fig. 5. The first plaintext recovery process is a process of rolling forward the plaintext recovery target table to committed. The plaintext recovery unit 302 determines whether the recovery target table has been committed in the commit history table of its own secure computing device (step S601). If the determination is Yes, the recovery target table is sent to an uncommitted secure computing device (step S602), and the first plaintext recovery process is terminated. In other words, the own secure computing device c0 , S c1 ,..., S cj Either S u0 , S u1 ,...,Su(N-j) S c0 .T i ,S c1 .T i ,..., S cj .T i If the answer is No, the recovery target table is received from the committed device (step S603), and the consistency of the received data is checked (step S604). u0 , S u1 ,...,S u(N-j) Either S c0 .T i ,S c1 .T i ,..., S cj .T i If the answer is Yes in step S604, the plaintext recovery unit 302 reflects (copies) the received table in the recovery target table (step S605), updates the content of the commit history table to "committed" (step S606), and ends the first plaintext recovery process.
[0041] <Second plaintext recovery process> Fig. 6(b) is a flowchart explaining the "second plaintext recovery process" in Fig. 5. The second plaintext recovery process is a process of rolling back the plaintext recovery target table to uncommitted. The plaintext recovery unit 302 determines whether the recovery target table is uncommitted in the commit history table of its own secure computing device (step S611). If the determination is Yes, the recovery target table is sent to a committed secure computing device (step S612), and the second plaintext recovery process is terminated. In other words, the own secure computing device u0 , S u1 ,...,S u(N-j) Either S c0 .T i ,S c1 .T i ,..., S cj .T i S u0 .T i ,S u1 .T i ,..., S u(N-j) .T iIf the answer is No, the recovery target table is received from the uncommitted device (step S613), and the consistency of the received data is checked (step S614). c0 , S c1 ,..., S cj Either S u0 .T i ,S u1 .T i ,..., S u(N-j) .T i If the answer is Yes in step S614, the plaintext recovery unit 302 reflects (copies) the received table in the recovery target table (step S615), updates the content of the commit history table to "uncommitted" (step S616), and ends the second plaintext recovery process.
[0042] <First share recovery process> Fig. 7(a) is a flowchart explaining the "first share recovery process" in Fig. 5. The first share recovery process is a process of rolling forward the recovery target table including the shares to committed. The secret sharing value recovery unit 303 judges whether the recovery target table has been committed in the commit history table of its own secure computing device (step S701). If the answer is Yes, it performs secret regeneration process from the standpoint of providing the share data (step S702), and ends the first share recovery process. In other words, the own secure computing device c0 , S c1 ,..., S cj Either S c0 .[T i ],S c1 .[T i ],..., S cj .[T i ] is used to execute the secret reproduction protocol. If the answer is No, the secret reproduction process is executed at the receiving end of the share reproduction data (step S703), and the consistency of the received data is checked (step S704). u0 , S u1 ,...,S u(N-j) Either S c0 , Sc1 ,..., S cj If there are no problems in the consistency check (OK in step S704), the secret sharing value recovery unit 303 reflects the regenerated data in the recovery target table (step S705), updates the contents of the commit history table to "committed" (step S706), and ends the first share recovery process.
[0043] <Second Share Recovery Process> Fig. 7(b) is a flowchart explaining the "second share recovery process" in Fig. 5. The second share recovery process is a process of rolling back the recovery target table including the shares to uncommitted. The secret sharing value recovery unit 303 determines whether the recovery target table is uncommitted in the commit history table of its own secure computing device (step S711). If the result is Yes, it performs secret regeneration process from the standpoint of providing the share data (step S712), and ends the second share recovery process. In other words, the own secure computing device u0 , S u1 ,...,S u(N-j) Either S u0 .[T i ],S u1 .[T i ],..., S uj .[T i ] is used to perform the secret reproduction process. If the answer is No, the secret reproduction process is performed at the receiving end of the share reproduction data (step S713), and the consistency of the received data is checked (step S714). c0 , S c1 ,..., S cj Either S u0 , S u1 ,...,S u(N-j) If there are no problems in the consistency check (OK in step S714), the secret sharing value recovery unit 303 reflects the regenerated data in the recovery target table (step S715), updates the contents of the commit history table to "uncommitted" (step S716), and ends the second share recovery process.
[0044] The above is the description of the secure computing apparatus and secret sharing recovery method according to the first embodiment.
[0045] [Second Embodiment] In the first embodiment, regarding the recovery of the plaintext table, whether to roll forward or roll back the plaintext table was determined depending on whether the number of committed secure computing devices was k or more. Alternatively, a configuration may be adopted in which the plaintext table is rolled forward if there is at least one committed secure computing device. Note that a situation in which there are no committed devices means that the table is in a consistent uncommitted state.
[0046] The functional block diagram of the secure computing device according to the second embodiment is the same as that of the first embodiment (FIG. 3). Fig. 8 is a flowchart illustrating an example of the operation of the secure computing device 201 according to the second embodiment. Steps S501 to S504 are the same as those of the first embodiment.
[0047] <Plaintext Table Recovery Process> If it is determined in step S504 that the table to be recovered is plaintext, the plaintext recovery unit 302 performs a first plaintext recovery process (step S506). The first plaintext recovery process is the same as that in the first embodiment.
[0048] <Share Table Recovery Process> The process of the secret sharing value recovery unit 303 according to the second embodiment is the same as that according to the first embodiment.
[0049] The above is the description of the secure computing apparatus and secret sharing recovery method according to the second embodiment.
[0050] [Program, Recording Medium] The various processes described above can be implemented by loading a program that executes each step of the above method into the recording unit 2020 of the computer 2000 shown in FIG. 9, and operating the control unit 2010, input unit 2030, output unit 2040, display unit 2050, etc.
[0051] The program describing the processing contents can be recorded on a computer-readable recording medium, which may be, for example, a magnetic recording device, an optical disk, a magneto-optical recording medium, a semiconductor memory, or any other suitable recording medium.
[0052] The program may be distributed by, for example, selling, transferring, lending, etc. portable recording media such as DVDs and CD-ROMs on which the program is recorded. Furthermore, the program may be stored in a storage device of a server computer, and then transferred from the server computer to other computers via a network, thereby distributing the program.
[0053] A computer that executes such a program may first temporarily store the program recorded on a portable recording medium or transferred from a server computer in its own storage device. Then, when executing a process, the computer reads the program stored on its own recording medium and executes the process in accordance with the read program. Alternatively, the computer may read the program directly from a portable recording medium and execute the process in accordance with the program. Furthermore, the computer may execute the process in accordance with each program transferred from the server computer. Alternatively, the server computer may not transfer the program to the computer, but may instead execute the process through a so-called ASP (Application Service Provider) service, which realizes the processing function by issuing an execution instruction and obtaining the results. In this embodiment, the program includes information used for processing by a computer that is equivalent to a program (e.g., data that is not a direct instruction to the computer but has properties that define computer processing).
[0054] Furthermore, in this embodiment, the device is configured by executing a predetermined program on a computer, but at least a part of the processing contents may be realized by hardware.
[0055] 201 Secure computing device 202 Network 301 Commit deviation detection unit 302 Plaintext recovery unit 303 Secret sharing value recovery unit 304 Communication unit 305 Data storage unit 2000 Computer 2010 Control unit 2020 Recording unit 2030 Input unit 2040 Output unit 2050 Display unit
Claims
1. A secret sharing recovery method implemented by one of multiple secure computing devices constituting a secret sharing system in which an original value can be restored from k shares, the method comprising: a step of sharing a plaintext commit history table with other secure computing devices; a step of extracting a secret sharing table with inconsistent commits based on the shared commit history table; a step of implementing, in cooperation with the other secure computing devices, a process of regenerating and overwriting the secret sharing table of an uncommitted secure computing device from the secret sharing table of the committed secure computing device, when the number of committed secure computing devices is k or more; and a step of implementing, in cooperation with the other secure computing devices, a process of regenerating and overwriting the secret sharing table of the committed secure computing device from the secret sharing table of the uncommitted secure computing device, when the number of committed secure computing devices is less than k and the number of uncommitted secure computing devices is k or more.
2. A secret sharing recovery method implemented in one of multiple secure computing devices constituting a secret sharing system in which an original value can be restored from k shares, the method including the steps of: sharing a plaintext commit history table with other secure computing devices; extracting a plaintext table with inconsistent commits based on the shared commit history table; if the number of committed secure computing devices is k or more, implementing a process of overwriting the table of an uncommitted secure computing device with the table of the committed secure computing device in cooperation with the other secure computing devices; and if the number of committed secure computing devices is less than k, implementing a process of overwriting the table of the committed secure computing device with the table of the uncommitted secure computing device in cooperation with the other secure computing devices.
3. A secret sharing recovery method as claimed in claim 1 or 2, wherein the record of the commit history table has fields for recording the name of the table to be committed and whether the commit process has been performed or not, and the secret sharing recovery method includes a step of updating the commit history table from committed to not committed, or from not committed to committed, after the overwrite process.
4. A secure computing device constituting a secret sharing system in which an original value can be restored from k shares, comprising: a memory unit that stores a plaintext commit history table; a means for sharing the commit history table with other secure computing devices; a commit deviation detection unit that extracts a secret sharing table with an inconsistent commit based on the shared commit history table; and a secret sharing value recovery unit that, when the number of committed secure computing devices is k or more, performs a process of regenerating and overwriting the secret sharing table of an uncommitted secure computing device from the secret sharing table of the committed secure computing device in cooperation with the other secure computing devices, and, when the number of committed secure computing devices is less than k and the number of uncommitted secure computing devices is k or more, performs a process of regenerating and overwriting the secret sharing table of a committed secure computing device from the secret sharing table of an uncommitted secure computing device in cooperation with the other secure computing devices.
5. A secure computing device constituting a secret sharing system in which an original value can be restored from k shares, comprising: a memory unit that stores a plaintext commit history table; a means for sharing the commit history table of other secure computing devices; a commit deviation detection unit that extracts plaintext tables with inconsistent commits based on the shared commit history table; and a plaintext recovery unit that, when the number of committed secure computing devices is k or more, performs a process of overwriting the table of an uncommitted secure computing device with the table of the committed secure computing device in cooperation with the other secure computing devices, and, when the number of committed secure computing devices is less than k, performs a process of overwriting the table of the committed secure computing device with the table of the uncommitted secure computing device in cooperation with the other secure computing devices.
6. A secure computing device as described in claim 4 or 5, wherein a record of the commit history table has fields for recording the name of the table to be committed and whether the commit process has been performed or not, and after the overwrite process, the secret sharing value recovery unit or the plaintext recovery unit updates the commit history table from committed to uncommitted, or from uncommitted to committed.
7. A secret sharing system comprising a plurality of secure computing devices and capable of restoring an original value from k shares, wherein each secure computing device comprises: a memory unit for storing a plaintext commit history table; a means for acquiring the commit history tables of the other secure computing devices; a commit deviation detection unit for extracting secret sharing tables with inconsistent commits based on the shared commit history table; and a secret sharing value recovery unit for, when the number of committed secure computing devices is k or more, performing a process of regenerating and overwriting the secret sharing tables of the uncommitted secure computing devices from the secret sharing tables of the committed secure computing devices in cooperation with the other secure computing devices, and, when the number of committed secure computing devices is less than k and the number of uncommitted secure computing devices is k or more, performing a process of regenerating and overwriting the secret sharing tables of the committed secure computing devices from the secret sharing tables of the uncommitted secure computing devices in cooperation with the other secure computing devices.
8. A program for causing a computer to execute each step of the secret sharing recovery method according to claim 1 or 2.
Citation Information
Patent Citations
Committing control method for distributed transaction
JP1997185539A
One-phase commit in shared-nothing database systems
JP2007501456A
Mismatch detection method, mismatch detection system, mismatch detection device, and program
JP2016145880A
Transaction processing system, method and program
WO2013046883A1
