Abstract:
A computer system to authenticate documents periodically appending a hash representing a document to a data structure, the data structure configured to store one or more hashes and creating a commitment for the data structure at pre-established intervals by creating a digest of the one or more hashes of the of the data structure, wherein the size of the commitment is constant regardless of the number of hashes in the data structure. A method, system, and computer product for verifying the existence of a document comprising postulating a state of existence of the document, obtaining, from a server, a proof of existence of the document at a time T, obtaining, from a trusted medium, a commitment for time T, and testing the postulate by determining whether there is a pre-established correspondence between the proof obtained from the server and the commitment obtained from the trusted medium, wherein a successful determination establishes the postulate is true and wherein a negative comparison establishes the postulate is false.

Description:
A portion of the disclosure of this patent document may contain command formats and other computer language listings, all of which are subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records and is made available to third parties in accordance with Patent and Trademark Office rules, but otherwise reserves all copyright rights whatsoever. 
     TECHNICAL FIELD 
     This invention relates to time stamping for archival storage. 
     BACKGROUND 
     There are some applications in which it is necessary or highly advantageous to be able to prove that a file has not been altered. By non-alterable it is meant that the data in the file can not be altered without leaving some sort of audit trail concerning that change. For example, insurance policies, while being written, are subject to change while they are being negotiated or compiled; once the insurance policy is issued, both the insurance company and policy holder want to be sure any change to that policy is detected. Similar requirements for permanence exist for medical records, images, and governmental compliance requirements. 
     Typical solutions offered to show that a file has not been altered may include WORM (Write-Once-Read-Many) storage. WORM storage is generally available in two types, a hardware or media implementation, which tends to be expensive, and a software implementation. Due to the high cost of the WORM media i.e. CDs or DVD ROMS, WORM is usually created in software and uses hard disks as the underlying storage media. The software WORM products are vulnerable to insider attacks by those with full access privileges and control of the storage system that can easily compromise the integrity of data stored on the disk. As well, typical systems do not provide for both existence and non-existence proofs. 
     SUMMARY 
     In one aspect, the invention comprises a computer system to authenticate documents by periodically appending a hash representing a document to a data structure, the data structure configured to store one or more hashes and creating a commitment for the data structure at pre-established intervals by creating a digest of the one or more hashes of the of the data structure, wherein the size of the commitment is constant regardless of the number of hashes in the data structure. In another aspect, the invention comprises a method, system, and computer product for verifying the existence of a document, comprising: postulating a state of existence of the document: obtaining, from a server, a proof of existence of the document at a time T: obtaining, from a trusted medium, a commitment for time T; and testing the postulate by determining whether there is a pre-established correspondence between the proof obtained from the server and the commitment obtained from the trusted medium, wherein a successful determination establishes the postulate is true and wherein a negative comparison (in the case of postulated existence, any other finding) establishes the postulate is false. 
    
    
     
       DESCRIPTION OF DRAWINGS 
         FIG. 1  shows an embodiment of a system on which the current techniques may be practiced. 
         FIG. 2  shows an embodiment of an apparatus of the current techniques including a data structure, an auditor, and a trusted medium; 
         FIG. 3  shows an alternative embodiment of a method of current techniques for committing a commitment; 
         FIG. 4  shows an alternative embodiment of a method of the current techniques for committing a digest to a trusted medium; 
         FIG. 5  shows an embodiment of a method of current techniques for verifying a proof; 
         FIG. 6  shows an embodiment of a data structure of the current techniques; 
         FIG. 7  shows an alternative embodiment of a data structure of the current techniques; 
         FIG. 8  shows an alternative embodiment of a data structure of the current techniques at a time T=1; 
         FIG. 9  shows an alternative embodiment of a data structure of the current techniques at a time T=2; 
         FIG. 10  shows an alternative embodiment of a data structure of the current techniques at a time T=3; 
         FIG. 11  shows an optimized alternative embodiment of a data structure of the current techniques at a time T=1; 
         FIG. 12  shows an optimized alternative embodiment of a data structure of the current techniques at a time T=2; 
         FIG. 13  shows an optimized alternative embodiment of a data structure of the current techniques at a time T=3; 
         FIG. 14  shows an embodiment of a system at a time T=1 on which the current techniques may be practiced; 
         FIG. 15  shows an embodiment of a system at a time T=2 on which the current techniques may be practiced; 
         FIG. 16  shows an embodiment of a system at a time T=90 on which the current techniques may be practiced; 
         FIG. 17  shows an embodiment of a system of the current techniques that may be used to verify the existence or non-existence of a document; 
         FIG. 18  shows an embodiment of a system of the current techniques that may be used to verify the existence or non-existence of a document at time T=50; 
         FIG. 19  shows an embodiment of a system according to the current techniques that may be used to verify the existence or non-existence of a document at time T=50; 
         FIG. 20  shows an embodiment of a system of the current techniques that may be used to verify the existence or non-existence of a document at time T=50; 
         FIG. 21  shows verification of a proof according to an embodiment of the current techniques; 
         FIG. 22  shows an embodiment of the current techniques stored as program logic on a computer readable storage medium; and 
         FIG. 23  shows an embodiment of a computer system on which the current techniques may be practiced. 
     
    
    
     DETAILED DESCRIPTION 
     Due to numerous regulations, including the recent eDiscovery laws, the Sarbanes-Oxley act and the Securities and Exchange Commission rules, there is a need for electronic data to be securely retained and made available in a number of circumstances. A typical challenge in complying with existing regulations is ensuring that electronic records have not been inadvertently or maliciously altered. The integrity of the records themselves may need to be maintained, and also the integrity of metadata information, such as creation time or non-existence of a document. Often organizations may have incentives to modify the creation time of their documents either forward or backward in time. For example, document back-dating might enable a company to claim intellectual property rights for an invention that had been discovered by its competitor first. A party involved in litigation might be motivated to change the date on which an email was sent or received, or to disguise the existence of a document. 
     Existing solutions offered by industrial products may implement WORM (Write-Once-Read-Many) storage, as previously described. Other solutions may be based on secure co-processors that defend against document tampering by an inside adversary; however, this may come at a substantial performance overhead. 
     Other solutions, such as external time-stamping services, can be leveraged for authenticating a few important documents, but these solutions are usually not scalable to large document repositories. This is because each document to be time stamped is usually sent to an external time stamping resource which must stamp and store the document. In addition, typical time stamping solutions may prevent back-dating and establish the relative ordering of documents, but previous time-stamping solutions do not prevent forward-dating as users could obtain multiple time-stamps on the same document. Moreover, time-stamping services are typically not scalable to a large number of documents. The current techniques provide a cost-effective and scalable mechanism to establish the integrity and creation time of electronic documents. Examples of documents to which these techniques maybe beneficial include those whose retention may be mandated by governmental or state regulation (e.g., email, business records, financial transactions). 
     The current techniques enable a rigorous security definition for time-stamping schemes that offers document authenticity against a powerful inside attacker. The current techniques provide scalable methods to authenticate the content and creation time of documents archived for compliance requirements. The current techniques enable time-stamping for archival storage, are scalable to large number of documents (which prevents document back-dating and forward-dating), and enable generation of existence and non-existence proofs for a document at any time interval. The current techniques enable a method, scalable to large number of documents, of locally manipulating a data structure summarizing the document repository. The current techniques are resilient to inside attackers. 
     In an embodiment of the current techniques, once a document is committed, its existence or non-existence can be established with certainty for any time interval. 
     In an embodiment, the current techniques enable document verification by providing a proof of a persistent medium at a given period in time. That proof may be used by an auditor in conjunction with a public commitment stored on a public medium to verify that the documents existed at that point in time. The current techniques enable detection of any modifications to documents occurring after they have been archived. The current techniques prevent both back-dating and forward-dating of documents, where typical time-stamping services only prevent back-dating. This is because conventional time stamping services enable only existence proofs, and the current techniques, with the append-only data structure, allow for both existence proofs and non-existence proofs. 
     In an embodiment of the current techniques of  FIG. 1  and  FIG. 2 , there is a local server  120 , a data structure  110 , and a trusted medium  130 . A set of users or employees in an organization may generate documents that are archived for retention in archival storage. A unique hash, such as hash  150 , may be created for each document retained and stored in a leaf of the data structure  110 . The hash may be computed with a cryptographically secure hash function, such as SHA-1, SHA-256 or the like. A reference to SHA-1 may be the NIST standard. 
     The hash  150  may be inserted  210  into the local data structure  110 , which may contain all the hashes of the archived documents. The server  120  may commit its internal state of the data structure  110 , periodically by registering  230  a short commitment  140 , with an external trusted medium  130 . The public commitment  140  may be a function  220  of all the hashes in the trusted medium  130 . In this way the current techniques enable compact proofs to be provided to a third party, such as auditor  160 , to verify existence or non-existence of a particular document at any moment in time. The hash value stored in the root of the tree may be committed to a trusted medium periodically. Since this hash may be of relatively small size, in comparison to the documents or the tree itself, it can be e-mail or published in a trusted medium. For example, the hash of the tree is small enough to be published on a publicly available web site similar to publishing information in a newspaper. 
     In an alternative embodiment of  FIG. 3  and  FIG. 4 , documents, such as document  310 , may be received  410  at and retained by a local server  320 . Server  320  may maintain locally a state  330  which is updated  420  as new documents are generated and reflects the full state of the document repository. Periodically, Server  320  may compute  430  a short digest or hash  340  from its local state  330  and submit  440  the digest  340  to an external trusted party  350 . 
     The trusted party  350  mainly may act as a reliable storage medium for commitments generated by Server  330 . With access to the commitments  340  provided by trusted party  350  and proofs  360  generated by server  330 , a third party, such as auditor  380 , may verify the authenticity and exact creation time of documents. In an embodiment, the external party  350  used to store the periodic commitments may itself be an auditor, but in an alternative embodiment, the auditor role may performed by another party. Referring to  FIG. 5 , server  330  may generate a proof  510 . Auditor  380  may receive the proof  360  and a commitment  340  from the trusted party  350 . Auditor  380  may then verify the proof  360  which may correspond to verification of existence or non-existence of a document at a given time. 
     In an embodiment, the current techniques may operate in time intervals or rounds representing, for example, predetermined numbers of documents. The server may maintain locally a persistent, append-only data structure, updated at the end of a round or time period. The server may commit to the batch of documents created in a round by sending a commitment to the trusted medium. Documents may be addressed by a fixed-size name or handle, which may be implemented by a secure hash of the document (e.g., if SHA-256 is used for creating handles, then their sizes will be 32 bytes). 
     To enable the efficient creation of both existence and non-existence proofs, the current techniques may use a data structure that minimizes the amount of local storage and the size of commitments. The data structure may support fast insertion of documents, fast document search and may be used to generate compact proofs of membership and non-membership, e.g. existence and non-existence. The data structure may implement an append-only, persistent, authenticated dictionary (PAD). The current techniques may reduce total amount of storage necessary to maintain all versions of the data structure in time, as well as the cost of non-membership proofs compared to previous approaches. 
     Terminology 
     The following terminology may be useful in understanding an embodiment of the current invention. An authenticated dictionary (AD) is a data structure that supports efficient insertion, search and deletion of elements, as well as proofs of membership and non-membership with short commitments. ADs may be based on hash trees. Persistent authenticated dictionaries (PAD) are ADs that maintain all versions in time and can provide membership and non-membership proofs for any time interval in the past. 
     A Merkle tree is a binary tree with a leaf for each value, and a hash value stored at each node. The hash for the leaf corresponding to value v is h(v). The hash for an internal node with children v and w is computed as h(v∥w). The Merkle tree can also create a commitment, or “proof” of the values stored in the tree. The commitment for the entire set or tree is the hash value stored in the root of the tree and the generated commitment may be a constant-size for any set of values. Given the commitment to the set, a proof that a value is in the set includes all the siblings of the nodes on the path from the root to the leaf that stores that value. Merkle trees can be generalized to trees of arbitrary degree. 
     A trie is a tree indexed by document handles. Trie data structures are organized as trees, with branching performed on key values. Consider a binary trie in which each node is labeled by a string as follows. The root is labeled by the empty string λ, a left child of node u is label by u0 and a right child of node u is labeled by u1. When a new string is inserted in the trie, its position is uniquely determined by its value. The trie is traversed starting from the root and following the left path if the first bit of the string is 0, and the right path, otherwise. The process is repeated until all bits of the string are exhausted. When traversing the trie, new nodes are created if they do not already exist. Siblings of all these nodes with a special value null are also created, if they do not exist. 
       FIG. 6  shows an example of a trie  600  containing strings 010, 011 and 110. The root  610  of trie  600  shows how the trie branches according to 0 or one of the string to be inserted. As this trie  600  is not optimized, several nulls such as nodes  630  and  660  exist. Nodes  640 ,  690 , and  680  show the respective strings 010, 011, and 110. 
     A Patricia tree is an optimized trie, also indexed by document handles. A Patricia tree may be optimized using a technique called path compression. With path compression, a skip value may be stored at each node that includes a 0 (or 1) for each left (or right, respectively) edge that is skipped in the optimized tree. The optimized tree then does not contain any null values. 
       FIG. 7  illustrates a data structure storing the same data as shown in  FIG. 6 , however note that this tree is optimized to remove the null nodes within the tree. This enables quicker search of the tree for existing and non-existent documents. In  FIG. 7 , Patricia tree  710  contains 5 nodes, none of which represent null nodes. Nodes  730 ,  740 , and  750 , which are the only leaves, represent the respective strings 010, 011, and 110. Also,  720  and  760  denote where “skips” occur in the optimized tree, which would represent null nodes in a tree that was not optimized. 
     Example Embodiment 
     In a particular embodiment, the data structure of the current techniques may layer a Merkle tree over a trie or Patricia tree. This data structure may also be considered a type of PAD and may allow for append only functionality, not allowing deletions. Layering of the Merkle tree over the trie or Patricia tree may be done by computing hashes for internal nodes using the hash values of children. The tree may be indexed by document handles. 
     As document hashes are added to the tree, the commitment for each round may be the value stored in the root of the tree. At each time interval, the hashes of internal nodes might change as new nodes are inserted into the tree. In order to generate membership and non-membership proofs at any time interval, it may be necessary to maintain all versions of node hashes. In addition, it may be necessary to enumerate all documents generated at time T. The commitment or verification for each round or each document commitment may be the value stored in the root of the tree. At each time interval, the hashes of internal nodes might change as new nodes are inserted into the tree. In the data structure each node in the tree stores a list of hashes (computed similarly to Merkle trees) for all time intervals the hash of the node has been modified. The list of hashes is ordered by time intervals. 
     To speed the creation of existence and non-existence proofs in the past time periods, the current techniques enable some additional values to be stored in each node. Specifically, each node u maintains a list of records L u, ordered by time intervals. L u contains one record v u for each time interval t in which the hash value for that node changed. v u.hash is the hash value for the node at time t, v u.lpos is the index of the record at time t for its left child in Lu0, and v u.rpos is the index of the record at time t for its right child in Lu1. If one of the children of node u does not contain a record at time t, then v u.lpos or v u.rpos store the index of the largest time interval smaller than t for which a record is stored in that child. 
     By storing these additional values, the subtree of the current tree for any previous time interval t may be easily extracted traversing the tree from the root and following at each node v the lpos and rpos pointers from record v u. The cost of generating existence and non-existence proofs at any time in the past is then proportional to the tree height, and does not depend on the number of time intervals. In addition, all documents generated at a time interval t may be determined by traversing the tree in pre-order and pruning all branches that do not have records created at time t. 
     Insertion into a Non-Optimized Data Structure 
       FIGS. 8 ,  9 , and  10  provide an example of insertion of document hashes into an un-optimized tree at time T=1, T=2 and T=3 according to the current techniques. Referring to  FIG. 8 , at time T=1, trie  800  has four null nodes,  830 ,  850 ,  870 , and  890 . Trie  800  has had two strings, 011 and 101 inserted into the tree and are represented by Nodes  860  and  880 , respectively. Each Node,  810 - 890 , has a value associated with it. For example, Node  890  is Null, while its parent node is represented as h(v10∥Null),1,1. As well, the root of the tree is shown as h(v0∥v1),1,1. 
     Referring to  FIG. 9 , trie  900  represents trie  800  of  FIG. 8  at time T=2, where String 000 has been inserted into trie  800  to arrive at trie  900 . Each node of trie  900  tracks not only the current value of each node,  910 - 990 , but also the previous value of the node. For example, node  910 , the root of the trie, has two values associated with it, the value at t=1 and the value at t=2, h(v0∥v1),1,1 and h(v0∥v1),2,1, respectively. This allows trie  900  to track the current state of the tree as well as to calculate the previous state of the tree. Again, in this trie there are null values for nodes, such as nodes  940 ,  950 ,  970 , and  990 . Node  940 , a null node, did not exist at time t=1, so there is only one value at this node. Nodes  930  and  940  were added when string 000, corresponding to node  930 , was added to this trie. 
     Referring now to  FIG. 10 , the trie  1000  represents the trie of  FIG. 9  at time t=3, where String 010 has been inserted into trie  900  to arrive at trie  1000 . As in  FIG. 9 , each node  1010 - 1090  has been updated to contain a value for the time at T=3. As in  FIG. 8 , some nodes, such as node  1060  contain only one value, as they only existed in the current time period or, such as node  1070 , have had the same value since T=1. 
     Insertion into an Optimized Data Structure 
     Consider now, an embodiment of the data structure of the current techniques applying an optimized tree as the data structure. To construct a time-stamping scheme for archival storage, the local server may need to maintain a persistent data structure that supports insertions of new documents, enables generation of proofs of membership and non-membership of documents for any time interval, and has short commitments per interval. The current techniques enable efficient search by document handle, and also enumeration of all documents that have been generated in a particular time interval. 
     Refer now to  FIG. 11 , which represents an embodiment of an optimized trie containing strings 011 and 101 at time T=1. This optimized trie has three nodes, a root node  1110  and two child nodes  1120  and  1130 . This optimized tree may be contrasted to the trie of  FIG. 8 . This optimized trie  1100  is able to represent in 3 nodes what trie  800  represented in 11 nodes. This enables quicker insertion and searching in trie  1100  than would be possible in trie  800 . As well, in the optimized version of the data structure, skip values may be included when computing node hashes and may be included in the commitment. 
     Refer now to  FIG. 12 , which represents trie  1100  at time T=2 after string 000 has been inserted to create trie  1200 . In this trie, there are 3 end nodes,  1230 ,  1240 , and  1250  which correspond to the three strings entered into the trie, 000, 010, and 101. This represents an optimized trie of  FIG. 12 . Finally, refer now to  FIG. 13 , which represents trie  1200  at time T=3 after string 010 has been inserted to created trie  1300 . In this three there are 4 end nodes,  1330 ,  1350 ,  1360 , and  1370 , which correspond to the four inserted strings, 000, 010, 011, and 101, respectively. Each node has a value for each time period for which the node existed. For example, root node  1310  has three values, where node  1370  has one constant value for all three times and Node  1320  has two values, as it only has existed for 2 time steps. 
     Commitment to a Trusted Medium 
     Refer now to  FIGS. 14-16  which represent a sample embodiment of documents being stored in the data structure and a commitment being stored with a trusted medium. A commitment for a time interval is a hash of the current time interval and the hash value stored in the root of the tree. In  FIG. 14 , values  1410  represent the hashes of documents and are inserted into data structure  1420  in the current round at time T=1. The data structure  1420  is stored on local server  1430 . After insertion of the documents, a commitment C 1 ,  1440 , is calculated. C 1  may be a hash of the time interval (1 in this case) and the value may be stored in the root of the tree. C 1 ,  1440 , is then sent to the Trusted Medium  1450 . 
     Referring now to  FIG. 15 , values  1510  have been inserted into data structure  1420  to create data structure  1520 . Data structure  1520  consists of values in the tree at time T=1 and values inserted at the time T=2. A commitment  1530  is generated and sent to trusted medium  1540 , which stores the commitment  1530 . Note that the value of the trie at T=2 may have changed from the trie of  FIG. 14  at T=1 as additional hash values may be inserted into the trie at time T=2 of  FIG. 15 . Note that the if no new documents are inserted into the trie, the commitment for different times may also be different. This could be because the time of construction of the commitment is used to create the commitment. 
       FIG. 16  illustrates an embodiment of the invention at time T=90. As shown in data structure  1610 , different commitments of values have been performed, such as at T 1 , T 2 , T 50 , and T  89 . New values  1620  have been inserted into the data structure  1610 . For time T=90, a commitment  1630  has been generated and the commitment is being sent to the trusted medium  1640 . 
     Verification of Existence and Non Existence 
     To prove a document&#39;s existence at time t, the server may provide evidence that the document handle was included in the tree at its correct position at time t. Similarly to Merkle trees, the server may provide the siblings of the nodes on the path from the leaf to the root and the auditor may compute the root hash value and checks it is equal to the commitment at time t. In addition, the proof may include the skip Values for the nodes on the path from the leaf to the root of the tree. 
     A document&#39;s non-existence at time t needs to demonstrate (for the trie version) that one of the nodes on the path from the root of the tree to that document&#39;s position in the tree has value null. For the optimized Patricia tree version, non-existence proofs demonstrate that the search path for the document starting from the root either stops at a leaf node with a different handle, or encounters an internal node with both children&#39;s labels non-prefixes of the document handle. 
     In the exemplary embodiment of  FIG. 17 , hashes C 1   1710 , C 2   1720  . . . C 90   1730  have been committed to the trusted medium. Say, for example, it is desired to verify whether document  1740  existed at time T=50. This request may correspond to requesting a proof from the local server  1750  and a commitment, e.g. C 50 , from the trusted medium  1760 . 
       FIG. 18  illustrates an example tree  1810 , stored within the overall data structure  1820  stored on the Server  1830 . The tree  1810  represents the values that had been committed to the data structure  1820  at time T=50. It is with this tree  1810  that local server  1830  will generate a proof. In  FIG. 19 , the hash is searched by descending into the tree until a leaf is encountered, and it is found it existed in the tree. Conversely, referring to  FIG. 20 , it is shown that the particular value did not exist at time T=50. The search path in this case (for non-existing documents) might end at internal node in the tree. 
     In  FIG. 21 , server  2110  has generated a proof  2120  and submitted the proof  2120  to auditor  2130 . As well, trusted medium  2140  has submitted a commitment  2150  for time T=50 to auditor  2130 . The auditor  2130  may use the proof of existence or non-existence and the commitment to verify existence or non-existence of the document  2160 . 
     Take for example the generation of an existence proof. To generate a proof, the server may need to search the digest of the document. A search path may contain the nodes from the root of the tree extending to the leaf containing the digest. The proof may contain the hashes of the sibling nodes from the search path and the skip values of the nodes on the search path. To verify an existence proof, the auditor may recompute the hashes of the nodes on the search path from the leaf containing the digest up to the root of the tree. This may be done with the sibling and skip values contained in the existence proof. The server may compare the value at the root of the tree with the commitment received from the auditor. If they match, it accepts the proof. A non-existence proof is performed in a similar manner with the difference that the search could stop at an internal node in the tree search whereas for existence proof it always stops at a leaf node. 
     In an alternative embodiment, there may be a data structure. The data structure may store document values, such as hashes of documents. The data structure may also generate a commitment. The commitment may represent a function of all the document values within the data structure. The commitments of the data structure may be periodically submitted to a trusted medium. The trusted medium may maintain all the commitments. 
     Existence or non-existence of a document may be confirmed by an auditor. The auditor may request a commitment at a given time from the trusted medium. The auditor may also request a proof of existence or non-existence from the data structure. Using the commitment and the proof, the auditor can confirm the existence or non-existence of a document at a given time. 
     The methods and apparatus of this invention may take the form, at least partially, of program code (i.e., instructions) embodied in tangible media, such as floppy diskettes, CD-ROMs, hard drives, random access or read only-memory, or any other machine-readable storage medium. When the program code is loaded into and executed by a machine, such as a computer, the machine becomes an apparatus for practicing the invention. When implemented on one or more general-purpose processors, the program code combines with such a processor to provide a unique apparatus that operates analogously to specific logic circuits. As such a general purpose digital machine may be transformed into a special purpose digital machine.  FIG. 23  shows Program Logic  2310  embodied on a computer-readable medium  2330  as shown, and wherein the Logic is encoded in computer-executable code configured for carrying out the reservation service process of this invention and thereby forming a Computer Program Product  2300 . 
     The logic for carrying out the method may be embodied as part of the system described below, which is useful for carrying out a method described with reference to embodiments shown in, for example,  FIG. 1  and  FIG. 2 . For purposes of illustrating the present invention, the invention is described as embodied in a specific configuration and using special logical arrangements, but one skilled in the art will appreciate that the device is not limited to the specific configuration but rather only by the claims included with this specification. 
     Although the foregoing invention has been described in some detail for purposes of clarity of understanding, it will be apparent that certain changes and modifications may be practiced within the scope of the appended claims. Accordingly, the present implementations are to be considered as illustrative and not restrictive, and the invention is not to be limited to the details given herein, but may be modified within the scope and equivalents of the appended claims.