Patent Application
20200259663
This invention relates to data security through the use of digital signatures.
Many different forms of server-based and interactive signature systems exist. One example is the so-called On-line/Offline Signature system (OOS) proposed by Even, Goldreich and Micali in order to speed up the signature creation procedure, which is usually much more time-consuming than verification. The so-called Server-Supported Signatures (SSS) of Asokan, Tsudik, and Waidner delegate the use of time-consuming operations of asymmetric cryptography from clients (ordinary users) to a server. Clients may use hash chain authentication to send their messages to a signature server in an authenticated way and the server then creates a digital signature by using an ordinary public-key digital signature scheme. In SSS, signature servers are not assumed to be Trusted Third Parties (TTPs) because the transcript of the hash chain authentication phase can be used as evidence.
The so-called Delegate Servers (DS) proposed by, for example, Perrin, et al., reduce the problems and costs related to individual private keys. In their solution, clients (ordinary users) delegate their private cryptographic operations to a DS. Users authenticate to the DS and request to sign messages on their behalf by using the server's own private key. The main motivation behind DS was that private keys are difficult for ordinary users to use and easy for attackers to abuse. Private keys are not memorable like passwords or derivable from persons like biometrics and cannot easily be entered from keyboards like passwords. Private keys are mostly stored as files in computers or on smartcards, which may be stolen.
The main drawback in server-based signature solutions is that the server must be completely trusted. Still, it is somewhat unclear whether such a server-based signature system is less trustworthy than the traditional PKI (Public Key infrastructure) based signature solutions, where the signature keys are held by end-users. In fact, “average persons” creating electronic signatures may be compared to illiterate persons signing paper documents in the presence of a notary public. Indeed, the electronic devices generally used for creating electronic signatures are far more complicated than pens used to sign paper documents. Having full control over the electronic signature technology is out of the question for most users. Therefore, blind trust is inevitable in most electronic signature systems and it does not make much difference whether to trust one's personal computer or a signature server. Considering the limited knowledge average persons have about elementary security procedures, server-based solutions are preferable to the traditional ones.
The issue of trust is mitigated by server-supported signature schemes, where a signature is created in collaboration with both server and client, so that neither of the parties alone can create signatures. An example of such a scheme is “multiprime RSA”, where private key components are shared between a signer and a server. Server-supported signature schemes can realize several advantages:
Interactive signature protocols, based on interaction either between signer and verifier or with an external time-stamping service, have also been considered. In the “Guy Fawkes Protocol” proposed by R. J. Anderson, et al., once bootstrapped, a message is preceded by publishing the hash of the message, and each message is authenticated by accompanying it with a secret whose hash was published together with an earlier message. A broadcast commitment step is critical for providing non-repudiation of origin. Although the verification is limited to a single party, the protocol may be considered a signature scheme according to several definitions.
A similar concept in the context of authentication was first used in the TESLA protocol proposed by A. Perrig, et al.. TESLA was designed to authenticate parties who are constantly communicating with each other; thus, it has the same inflexibility as the Guy Fawkes protocol of not supporting multiple independent verifiers.
Other signature schemes have been proposed that are based on hash functions. Among the earliest digital signature schemes constructed from hash functions is due to Lamport. This is a one-time scheme and requires generation of a new key pair and distribution of a new public key for each message to be signed.
R. C. Merkle contributed the concept of a hash tree, which enables a large number of public keys to be represented by a single hash value. With the hash value published, any one of the N public keys can be shown to belong to the tree with a proof consisting of log2N hash values, thus combining N instances of a one-time scheme into an N-time scheme. Buldas and Saarepera, and Coronado Garcia showed the aggregation to be secure if the hash function used to build the tree is collision resistant.
The current state of the art in hash-based signature schemes is represented by systems known as XMSS, SPHINCS, and the BLT system provided by Guardtime AS of Tallinn, Estonia.
An authenticated data structure is a data structure whose operations can be performed by an untrusted prover (server) and the integrity of results can be verified efficiently by a verifier. Authenticated data structures were first proposed for checking the correctness of computer memory and later analyzed in the context of tamper-evident logging. The concept found a practical use in PKI certificate management, first proposed by A. Buldas, P. Laud, and H. Lipmaa as “undeniable attesters”, where PKI users receive attestations of their certificates' inclusion or removal from a valid certificate database, and then the “certificate transparency” framework (B. Laurie, et al.), which facilitates public auditing of certification authority operations.
Although the term “blockchain” itself, as well as related terms, do not yet have universally accepted definitions, typically a “blockchain” is understood as being a data structure comprising a series of usually (but not necessarily) cryptographically linked, time-stamped blocks, where each block includes data corresponding to one or more transactions, hashed together with linking data, such as the hash of some data and/or metadata of at least one preceding block. The blockchain can then be used to create a ledger, which is typically an append-only database.
Some blockchain variants involve distribution and consensus, that is, copies of the blockchain are distributed to several entities, which then follow a procedure to “agree” on what data is to be allowed to constitute the next block. Many of the blockchains used for cryptocurrencies follow this model, for example, since they, usually by design philosophy, wish to avoid any central authority. In other configurations, a single entity may control access to a proprietary blockchain according to its own rules; governments, banks, enterprises, etc., will, for example, usually not want the operation of their blockchains to depend on consensus among distributed, often anonymous outside entities. In either case, once data is entered into a block of the chain, the entry is essentially irrefutable, that is, non-repudiable, since any tampering with the data would be reflected in the chained hash calculations and thus easily detected.
One current point of dispute when it comes to the concept of a “blockchain” is whether, by definition, any entity may be allowed to submit blocks to and verify blocks in the blockchain, possibly only upon meeting some proof-of-work (such as Bitcoin's “mining”), or proof-of-stake requirement, or whether the entities that may submit to and verify blocks in the data structure must be permissioned by some central authority. In other words, there is dispute as to whether “blockchain” by definition implies “open” or not; the invention embodiments described below are not limited to any particular one of these definitions.
Embodiments of this invention provide new methods, and corresponding system implementations, that are practical, provide forward security, non-repudiation of the origin, are resistant to known attacks even by quantum computers, and may even provide “built in” cryptographic time-stamping. The sizes of the signatures and keys, and their efficiency, are comparable with the state of the art of hash-based signature schemes. The new signature solutions are stateful, and the maximum number of signatures they create using a set of keys may be determined at the key-generation time.
Some of the present inventors (Buldas, Laanoja, Truu) have themselves previously presented a hash-based solution—referred to as the “BLT” signature scheme—which depends on interaction with a time-stamping service.
In more detail, in order to be able to sign messages at time epochs (1; . . . ; T), the Signer:
The resulting data structure is shown in i) to the public key p, that is, h(i;
i)˜ci˜>p.
To sign a message m during epoch t, the signer:
Note that the signature is composed and emitted only after the verification of rt, which makes it safe for the signer to release the key t as part of the signature—the time-stamping service will already have closed the aggregation epoch t so that it's no longer possible to link new message authenticators to rt.
To verify that the message m and the signature s=(t; ; c; a) match the public key p, the verifier:
The BLT signature scheme thus uses one-time, time-bound keys, together with a cryptographic time-stamping service. It is post-quantum secure against known attacks and the integrity of a BLT signature does not depend on the secrecy of keys. The fact that keys have to be pre-generated for every possible signing epoch, for every signature, however, creates some implementation challenges, making, for example, on-smartcard key generation prohibitively slow in the case of real-world parameters.
Embodiments of this invention do not require any specific form of time-stamping service, but a particularly advantageous form (based on the Guardtime infrastructure) is described below. In a preferred embodiment, the time-stamping is implemented using the data signature infrastructure developed and marketed under the name “KSI” by Guardtime AS of Tallinn, Estonia. This system is described in general in U.S. Pat No. 8,719,576 (also Buldas, et al., “Document verification with distributed calendar infrastructure”). In summary, for each of a sequence of calendar periods (typically related one-to-one with physical time units, such as one second), the Guardtime infrastructure takes digital input records as inputs, that is, lowest-level tree “leaves”. These are then cryptographically hashed together in an iterative, preferably binary hash tree, ultimately yielding an uppermost hash value (a “calendar value”) that encodes information in all the input records. This uppermost hash value is then entered into a “calendar”, which is structured as a form of blockchain which, in some implementations, may involve aggregating calendar values into a progressive hash tree. The KSI system then may return a signature in the form of a vector, including, among other data, the values of sibling nodes in the hash tree that enable recomputation of the respective calendar value if a purported copy of the corresponding original input record is in fact identical to the original input record.
As long as it is formatted according to specification, almost any set of data, including concatenations or other combinations of multiple input parameters, may be submitted as the digital input records, which do not even have to comprise the same parameters. One advantage of the KSI system is that each calendar block, and thus each signature generated in the respective calendar time period, has an irrefutable relationship to the time when the block was created. In other words, a KSI signature also acts as an irrefutable timestamp, since the signature itself encodes time to within the precision of the calendar period.
One other advantage of using a Guardtime infrastructure is that there is no need to store and maintain public/private (such as PKI) key pairs—the Guardtime system may be configured to be totally keyless except possibly for the purposes of identifying users or as temporary measures in some implementations in which calendar values are themselves combined in a hash tree structure for irrefutable publication. Another advantage is less apparent: Given the signature vector for a current, user-presented data record and knowledge of the hash function used in the hash tree, an entity will be able to verify (through hash computations as indicated by the signature vector) that a “candidate” record is correct even without having to access the signature/timestamping system at all.
Yet another advantage of the Guardtime infrastructure is that the digital input records that are submitted to the infrastructure for signature/timestamping do not need to be the “raw” data; rather, in most implementations, the raw data is optionally combined with any other desired input information (such as user ID, system information, various metadata, etc.) and then hashed. Given the nature of cryptographic hash functions, what gets input into the KSI system, and thus ultimately into the calendar blockchain, cannot be reconstructed from the hash, or from what is entered into the calendar blockchain.
In order to avoid the inherent inefficiency of pre-assigning individual keys to every time epoch, it would be advantageous if keys may be spent sequentially, one-by-one, as needed. This approach is particularly useful for real-world use cases where signing is performed in infrequent batches, for example, when paying monthly bills. Sequential key use needs more elaborate support from the server; in particular, it is necessary to keep track of spent keys by both the signer and the server, and to avoid successful re-use of the spent keys. Embodiments of the invention described herein manage these keys sequentially without placing too much trust in the server.
Embodiments of this invention, which improve on the basic BLT signature scheme, should preferably have as many of the following properties as possible:
Embodiments guarantee that reused one-time keys do not produce valid signatures. The previous BLT signature method employs time-bound keys, where every key can be used for signing at a specific point of time and no later. This incurs quite large overhead, however: Keys must be pre-generated even for time periods when no signatures are created. In contrast, the embodiments discussed below use keys sequentially, with server-side support—every signer has a designated server, which keeps track of spent keys, together with the signer, and does not allow creation of valid signatures using already spent keys.
One solution is to trust the server to behave honestly. In this case, the server maintains a spent key counter that is synchronized with the signer. The server then refuses to create signatures if key indexes do not match. One drawback of this solution is lack of non-repudiation—the server can collect spent keys and create valid signatures on behalf of the signer. This situation can be improved upon with trusted logging and auditing. Below, an embodiment is presented that addresses this problem of an untrusted signing server.
The signer may publish all signing events, including a key counter, in a public repository, such that the server cannot reuse keys and does not have to be treated as a trusted component. This approach will often be inefficient because of the amount of public, replicated data, which must be distributed and processed during verification; moreover, it leaks information about the signer's behavior. In this case, the public repository is like a component often called the “ledger” in literature relating to blockchains.
Embodiments described below avoid publishing all signing transactions, while not trusting the server. As a common feature, embodiments use spent key counters both at the signer side and server side; and the server periodically creates hash trees on top of its counters (i) and input hashes (y); and publishes root hashes to a public repository.
Assuming no collaboration between server and verifiers, the server cannot learn keys i, and thus cannot produce valid signatures that depend on those keys. This may be difficult to enforce in practical implementations, however—one may normally assume that signatures can be published, and that the server has access to spent keys. With this restriction, a better method should eliminate the attack where the server decrements the spent key counter to i, signs a message using captured
i, and then increments the counter to its previous value.
Assuming the server and (other) signers do not cooperate maliciously, one solution is “neighborhood watch”: Signers observe changes in returned hash-chains and published roots and request proofs from the server that all changes were legitimate, by checking that key counters of signers assigned to neighboring leaves were incremented only. This approach detects forgeries but does not block them. A weakness of this approach is that it fails to deal with the possibility (or ever-present suspicion) of malicious cooperation between server and some of its clients.
The concept of authenticated data structures (see above) can be used for verifying the correct operation of the server. If the proof of correct operation is a part of signatures, then verifiers can reject signatures without valid proof and thus the server cannot forge signatures by tampering with the counters. This approach has quite large overhead: All potential verifiers must be able to validate all counters throughout their operational time. Other parties who can perform such validation are the Repository, the Signer, or an independent Auditor. Both Signer and Auditor could discover a forgery after the fact, but this will typically not be early enough to avoid creation of forged signatures.
In an embodiment, pre-validation is done by the Repository R, which may be implemented in a manner analogous to double-spending prevention performed by blockchains backing cryptographic currencies. In this case, Servers S should provide proofs of correct operation to the trusted Repository. The Repository may then publish a root hash only after validating the correct operation of the Servers. Published hashes may be made immutable using known cryptographic techniques and be widely distributed. Because signatures can be verified based only on the corresponding published root hash in the Repository, servers' forging of signatures by temporarily decrementing key usage counters can be eliminated. This solution is efficient since the blockchain (the amount of public data) grows only in linear relation to time; there is a relatively low number of trusted components; the blockchain, including its input validation is forward secure; the server's forgery attempts will be prevented at the signing time; and it is not necessary to have a long-term log of private data. The Repository may be implemented as a Byzantine fault tolerant distributed state machine, which eliminates the need to trust a single party. This embodiment will be described in more detail below.
See now
Signer/Device D generates keys and then signs data.
Server S assists signers in generating signatures and keeps counters i of spent keys and publishes aggregate hashes to the Repository R. The correctness of operation of S may be verified by R before publishing.
S operates in rounds. It maintains a hash tree; there is one pre-assigned leaf for every signer client, indexed by j. A leaf lt=(it; yt) for round t contains the tuple of the counter value and the last input query from the Signer.
S is allowed only to increment i; for every changed leaf it presents a proof P of correct operation to R. A proof consists of the value of the leaf in the previous round and hash chain leading to the root of previous round, previously published by R, the leaf value at current round, and the newly computed root of current round.
The Repository R performs two tasks. First (depicted as layer Rv), it verifies the operation of S and after successful verification it commits the new root value r to a public append-only ledger or other irrefutable data structure.
The Verifier V is any relying party who wishes or needs to verify the signatures in any known manner. Described above is how Guardtime KSI signatures may be verified.
Keys may be generated in the same manner as in the basic BLT, although the number of keys required will typically be much smaller, and thus the generation process may be more efficient. In order to be able to sign N messages the Signer:
The resulting data structure (shown in i)˜ci˜>p.
For signing, each Signer should keep its state, the sequence number i of next key. To sign a message in, the Signer:
Finally, the Signer increments its spent key counter: i←i+1.
The Server S, upon receiving a request y, performs the following steps:
Note that, as before, the signatures are composed and emitted only after the verification of rt, which makes it safe for the Signer to release the key i as part of the signature—the server has already incremented its counter i so that only
i+1 could be used to produce the next valid signature.
The blockchain, which may be implemented in any entity, performs following operations:
To verify that the message in and the signature s=(i; ; c; t; a) match the public key p, the Verifier:
The proofs of correct operation that the Server presents to the Repository can be constructed either iteratively, by generating hash chains before and after each leaf change, or in batches, taking hash chains before a round, applying all changes to leaves, generating a final Merkle tree, and then generating “after”-hash chains for each changed leaf. An iterative approach has the advantage that it is not necessary to perform explicit consistency and completeness checks between each leaf's chain.
Denote the sequence of indexes of leaf positions of clients who have provided a request during a round as a. Proof of correct operation of the round t may be defined as the sequence
t=((ijt−1;yjt−1)ajt;(ijtyjt):j=v,v=(1; . . . ;|
|),
where (ijt; yjt) is the j-th leaf of the server hash tree in round t and ajt is the hash-chain from the leaf to the root. For the computation of the proof, the server tree is updated every time a leaf is changed (denoted by incrementing the in-round change counter v). Note that the content of the hash chain aj does not change when the j-th leaf changes, because the rest of the leaves are still the same; this fact allows verification of the completeness of and consistency of its elements by just verifying hash chains in the provided sequence, and checking that each “after”-root is the same as the “before”-root of the following change, checking the correctness and matching root of hash chains when computed in the same order.
A verification routine for is illustrated as the Oracle Ra in
In this section of the disclosure, an embodiment is described that enables delegation of signing to an untrusted server. This extension to the basic BLT signature scheme described above allows a client to delegate the signing process to an untrusted server in such a way that the user will be able to verify what the server is signing before a valid signature is formed. This may be particularly relevant for the situations when the client has to produce signatures in an environment that is constrained, for example, by low computational power. To achieve that, the key generation, signing, and verification procedures are changed as follows.
To prepare to sign messages at time epochs (1; . . . ; T), the Signer:
The resulting data structure (shown in i)˜ci˜>p can be extracted; and second, for each signing key
i, the corresponding secret key si, when disclosed, can be verified via the relationship
i=f(i; si).
To have the Server sign a message m on its behalf, the Signer:
Note that, to authenticate the message m, this embodiment uses a secret key and not a signing key.
To verify that the message m and the augmented signature sig=(t; s; c; a) match the public key p, the verifier:
This embodiment provides an extension to the basic BLT scheme that allows even a computationally weak user to delegate the signature-forming process to an untrusted server. The security of the described extension is based on the fact that the untrusted server produces only a “partial” signature sig=(t, , a, c), which can be checked by the signer before completing the signing process. To complete the process,
, which acts as a token, is replaced with its pre-image s. Under standard cryptographic assumptions, this should be possible only by the signer who knows the original secret key s.
The solution provided by this embodiment may be compared with signature production methods that rely on zero-knowledge techniques. ZQL, for example, is a language for writing computations over hidden inputs. The disadvantage of the zero-knowledge approach is increased cryptographic and computational complexity, which results in performance penalties. In contrast, this “extended” BLT embodiment relies on well-known secure, yet easily computed hash functions.
This application claims priority of U.S. Provisional Patent Application No. 62/802,462, filed 7 Feb. 2019.
| Number | Date | Country | |
|---|---|---|---|
| 62802462 | Feb 2019 | US |
