BACKGROUND
Every day the amount of data collected from a wide array of sources continues to grow. Sensors may acquire data ranging from temperature, air pressure, wave height, seismic activity, stock prices, commodity prices, and so forth. Where large numbers of sensors are employed, aggregators may receive and consolidate the data from sensors. These aggregators combine data, until a final parent aggregator generates a complete set of sensor data.
A portal, such as a server on the internet, may request information from an aggregator to fulfill a request. Unfortunately, it has traditionally been difficult to provide an assurance that information which has been aggregated has not been corrupted. Such corruption may occur because of system glitches or a malicious actor. Corruption may include increasing the reported value of a sensor (“inflation”) or reducing the reported value (“deflation”).
Various schemes have been put forth to try and secure aggregation. One scheme involves a single entity tightly controlling all aggregators, then making the assumption that these aggregators are not compromised. This scheme has several drawbacks. For example, an organization may not be able to afford the cost of maintaining such a system. Or the organization may not have the technical expertise or geographic reach necessary to maintain the aggregators.
Another scheme to secure aggregation involves the encryption of data at the sensor. This scheme has several drawbacks as well. For example, if the aggregator has the capability to decrypt data, typically considered necessary to aggregate the data, it gains the ability to tamper with the data before sending along to the portal. If the data is not decrypted at the aggregator, the portal is heavily loaded with the task of decrypting and aggregating data itself, removing the benefits of aggregators in the first place.
Thus, there is a desire to outsource aggregation while retaining the capability to determine if sensor data has been inflated or deflated.
SUMMARY
This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.
Secure aggregation may be accomplished through the use of a framework incorporating inflation free proofs and a deflation free proofs for sensor data. This framework and associated protocols permits use of aggregates such as max, topk, sum, average, count, count distinct, etc., in such a fashion as to provide an assurance that an outsourced aggregator has not tampered with the results.
A sensor or other input data source generates a Verifiable Synopsis (“VS”) which includes sensor data, an Inflation Free Proof (“IFP”) generated using a cryptographic function and a SelfAuthenticating Value (“SEAL”) chain generated using a oneway function from a seed value. An aggregator may take a plurality of SEALs and fold them together, creating a SEAL representing the true aggregate result (e.g., the maximum value for the MAX aggregate). This folded value provides a concise proof of the aggregate value reported by a sensor, thus providing a check against deflation of sensor data. Similarly, the cryptographic function of the IFP provides a mechanism to prevent inflation of the sensor data. The aggregator may then create Aggregated Verifiable Synopses (“AVS”) which includes the folded SEAL, the IFP's and the sensor data.
In this application, the maximum function is used as an example aggregate function, and not by way of limitation. Many other aggregates such as Count, Sum, Average, Random Samples (and hence any answer based on samples) can be computed using Maximum as a black box; therefore, our solution for Maximum aggregate can be applied to all these aggregates as well.
A portal may take the AVS and generate a reference synopsis (RS) which is compared to the VS. When the RS equals the VS, the sensor data is valid.
SEAL chains of equal length may be folded together while retaining the deflationfree proof. In simple rolling, all SEAL chains are rolled forward (that is, iterated with the oneway function F( )) to the same length, then folded together. However, significant reductions in computational load are realized by folded rolling. Folded rolling involves ordering SEAL chains by length, rolling a shortest first SEAL chain forward to match a length of a next shortest second SEAL chain. The first SEAL chain and second SEAL chain are then folded together. The resulting folded SEAL is then folded with the next shortest SEAL chain. The process is repeated until only a single SEAL remains. Folded rolling results in significant reductions in computational overhead, allowing computationally intensive oneway functions F( ), such as RSA, to exceed the performance of simpler hash functions.
Finally, in addition to the maximum function described, other functions may benefit from this secure framework. For example, a topk function may securely aggregate a top “k” number of values, where k is an integer number. From a set of SEAL values, a maximum SEAL value is determined. The maximum SEAL value is stored and removed from the set, and the set is refolded and a next maximum SEAL value is determined. This process continues, removing the top value until k is reached.
BRIEF DESCRIPTION OF THE DRAWINGS
The detailed description is set forth with reference to the accompanying figures. In the figures, the leftmost digit(s) of a reference number identifies the figure in which the reference number first appears. The use of the same reference numbers in different figures indicates similar or identical items.
FIG. 1 is a flow diagram of an illustrative process of secure outsourced aggregation via oneway chains.
FIG. 2 is a schematic diagram of an illustrative verifiable synopsis generated by a sensor.
FIG. 3 is a schematic diagram of an illustrative oneway chain.
FIG. 4 is a schematic diagram of an illustrative environment of secure outsourced aggregation via oneway chains.
FIG. 5 is a schematic diagram illustrating generation and folding of selfauthenticating values (SEALs) for a secure maximum via oneway chains.
FIG. 6 is a schematic diagram illustrating aggregation of SEALS from multiple aggregators.
FIG. 7 is a flow diagram of an illustrative process of generating a verifiable synopsis (“VS”).
FIG. 8 is a flow diagram of an illustrative process of generating aggregated verifiable synopses (“AVS”) using a maximum function.
FIG. 9 is a flow diagram of an illustrative process of evaluating an AVS.
FIG. 10 is a schematic diagram illustrating simple rolling of SEALs.
FIG. 11 is a schematic diagram illustrating folded rolling of SEALs.
FIG. 12 is a flow diagram of an illustrative process of folded rolling.
FIG. 13 is a schematic diagram illustrating a topk query.
FIG. 14 is a flow diagram of an illustrative process of determining topk values.
DETAILED DESCRIPTION
Overview
As described above, secure aggregation of data may be provided by using oneway chains. Unlike prior solutions, an inflation free proof and a deflation free proof using a SEAL are provided, which constrains the opportunity for an aggregator to corrupt data. Thus, aggregation may be outsourced with the reasonable assurance that aggregator has not corrupted the sensor data. In this application, aggregation functions discussed are max and topk, however other aggregation functions are also possible.
A sensor generates a Verifiable Synopsis (“VS”) which includes sensor data, an Inflation Free Proof (“IFP”) generated using a cryptographic function such as a message authentication code (“MAC”) and a SelfAuthenticating Value (“SEAL”) chain generated using a homomorphic oneway function, such as the RSA algorithm developed by Ron Rivest, Adi Shamir, and Leonard Adleman at the Massachusetts Institute of Technology.
An aggregator may take a plurality of these SEALs which have been generated using a homomorphic function and “fold” them together using modulo multiplication to create a SEAL for a maximum value (for the Maximum aggregate function). The fold operation is denoted in this application with the symbol “⊙”. This folded value provides a concise proof that no value greater than the maximum value was reported by a sensor, thus providing a check against deflation of sensor data. Similarly, the MAC or other cryptographic function of the IFP provides a mechanism to prevent inflation of the sensor data. The aggregator may then create Aggregated Verifiable Synopses (“AVS”) which includes the folded SEAL, the IFP's and the sensor data. Because the aggregator lacks the cryptographic capability to generate a MAC or SEAL, it is unable to corrupt data.
A portal may take the AVS and generate a reference synopsis (RS) which is compared to the VS. This RS may be generated by a process similar to that used on the sensor and aggregator, such as computing an IFP and folding SEALs together. When the generated RS equals the VS, the sensor data is valid.
The folding described above is facilitated when SEAL chains are of equal length before folding. In simple rolling, all SEAL chains are rolled forward to the same length, then folded. While straightforward, simple rolling may be computationally inefficient. Forward rolling may be reduced by using folded rolling. Folded rolling orders SEAL chains by length and folds together SEAL chains of equal length. When SEAL chains are of unequal length, a shortest first SEAL chain is rolled forward to match a length of a next shortest second SEAL chain. The first SEAL chain and second SEAL chain, now of equal length, are then folded together. The resulting folded SEAL is then folded with the next shortest SEAL chain. The process may be repeated until only a single SEAL remains.
Previous techniques (e.g., the Count algorithm by Flajolet and Martin, the Count algorithm by Alon, Matias, and Szegedy) have shown how to compute approximate answer of Count/Sum/Average queries using Maximum queries. The processes presented in this application may be applied to these aggregates as well.
Finally, our scheme also supports returning a topk number of values, where k is an integer number. In this process, the aggregate returns k folded SEALs. The first SEAL is generated by folding all SEALs in the system, the second folded SEAL is computed by folding all but the maximum SEAL in the system, the third folded SEAL is computed by folding all but the two maximum SEALs in the system, and so on. A TopK query can be used to answer a random sample query as well, where every value may be tagged with a uniformly random number, and a topk query can be answered over the tags only; thus providing a uniformly random sample of the values.
Secure Outsourced Aggregation Via OneWay Chains
FIG. 1 is a flow diagram of an illustrative process 100 of secure outsourced aggregation via oneway chains. Input data sources 102(1) . . . (N) are referred to for convenience and not as a limitation as “sensors.” A sensor 102 may be a physical device providing data, a set of instructions configured to execute on a processor, software module stored in memory, etc. Each sensor is configured to generate a verifiable synopsis (“VS”) 104. For example, sensor 102(1) generates VS 104(1), sensor 102(2) generates VS 104(2), and so forth through sensor 102(N) generating VS 104(N).
An aggregator 106 may be configured to combine and consolidate VSs 104 from many sensors 102 into an Aggregated Verifiable Synopsis (“AVS”) 108. In one implementation, aggregator 106 is a computer server comprising a processor coupled to a memory and communication interface. As illustrated, aggregator 106(1) accepts VSs 104(1) . . . (N) from sensors 102(1) . . . (N). Similarly, aggregator 106(N) may accept VSs from other sensors, which for clarity are not illustrated here. In another implementation, sensors 102 may provide data to a proxy or other subaggregation device, which in turn would provide a VS of that data to aggregator 106.
While a single aggregator may be sufficient, in larger sensor networks a hierarchy of aggregators may be desirable for speed, load distribution, or other purposes. In this case, each aggregator 106 may provide an AVS 108 to a parent aggregator 110. Parent aggregator 110 may then in turn provide an AVS 108 to portal 112.
In one implementation, portal 112 is a computer server comprising a processor coupled to a memory and communication interface. Portal 112 may evaluate the AVS, verify the data, and produce verified data 114 to a requestor 116. Requestor 116 may be an individual, computing device, set of instruction executing on a processor, etc.
FIG. 2 is a schematic diagram 200 of an illustrative VS 104 generated by a sensor 102. A VS may comprise sensor data 202, an inflationfree proof (“IFP”) 204, and a selfauthenticating value (SEAL) 206. The presence of an IFP 204 and SEAL 206 in the VS results from a decomposition of security requirements into two parts: preventing inflation and preventing deflation. The security requirement of preventing inflation is met by the IFP, while the requirement to prevent deflation is addressed by the DFP, as described later.
At 202, the sensor data v_{i }comprises the value being reported by sensor i. In one embodiment, v_{i }may be reported as an integer. Several methods for representing noninteger values as integers are available and may be used.
At 204, the IFP s_{i} ^{+} may comprise identification of the sensor i, sensor data v_{i}, and a message authentication code (“MAC”). A MAC algorithm may be configured to accept as input a secret symmetric key and an arbitrarylength message, and output a MAC. The MAC value protects both a message's data integrity as well as its authenticity, by allowing a verifier with the secret symmetric key to detect changes in the message content.
In one implementation, the MAC secret symmetric key may be a key associated with that particular sensor K_{i }and shared with portal 112. The MAC may use as parameters v_{i }and time T which may be concatenated, as indicated by the “∥” symbol in the following expression: s^{+} _{i}={i, v_{i}, MAC_{Ki}(v_{i}∥T)}. Time T may comprise a time value, such as that relative to a given epoch. The MAC may utilize a full domain hash. This provides an inflation free proof, as the MAC key is available to the sensor 102 and the portal 112, not aggregator 106. Thus, inflation of v_{i }at the aggregator would be discovered by portal 112.
While the IFP 204 prevents inflating a reported value, it has traditionally been difficult to prove that deflation has not taken place. Stated another way, it is useful to verify that an aggregator 106 has not thrown away a true maximum value v_{m}. Constructing oneway chains of selfauthenticating values (SEALs) using a deflationfree proof (“DFP”) 206 prevents this. The DFP s_{i} ^{−} comprises a MAC using K_{i }and a parameter of time T, as shown in this expression: s^{−} _{i}={MAC_{Ki}(T)}. An illustrative oneway chain of SEALs built using the DFP as a seed is described next.
FIG. 3 is a schematic diagram of an illustrative oneway chain 300. Arrow 302 indicates a path of computational feasibility directed along oneway chain 304, also known as a “hash chain.” This represents the mathematical nature of a oneway chain in that the function is considered computationally infeasible to inverting. Stated another way, a oneway function is computationally “easy” when applying the function, but is computationally “difficult” to undo. A seed value 306 is indicated. In one embodiment, the seed value 306 comprises DFP s_{i} ^{−}. A oneway function F( ) may be applied 308 to the seed 306, resulting in a SEAL. As used in this application, the superscript for the function indicates the number of iterations 312 performed by function F. For example, F^{3}(Seed) indicates that the oneway function F( ) has been applied to the seed in three iterations, and is thus equivalent to F(F(F(Seed))).
Oneway function F( ) may comprise an algorithm such as MessageDigest algorithm 5 (“MD5”), the RSA algorithm described by Ron Rivest, Adi Shamir, and Leonard Adleman (“RSA”), and the like. As described later, there are further advantages to using the RSA or other homomorphic oneway functions, such as facilitating folded rolling.
FIG. 4 is a schematic diagram of an illustrative environment 400 of secure outsourced aggregation via oneway chains. Sensor 102, aggregator 106, and portal 112 may each comprise a processor, memory, and communications interface, which are not shown for clarity. Where appropriate, the following elements, data, or instructions for execution are stored in the memory.
In one embodiment, sensor 102 may comprise the following: A MAC module 402, configured to generate the MAC as described above with respect to FIG. 2. MAC module 402 may include a key 404, which in one implementation, comprises a secret shared between the sensor 102 and portal 112, but unavailable to the aggregator(s) 106.
Sensor data 406 may comprise data resulting from measurements or other inputs received by sensor 102 and stored in sensor 102's memory. Sensor attributes 408 may be stored in sensor 102's memory and may include an identifier for the particular sensor, information about the instrumentation of the sensor, sensor status, and so forth. A seed 410 may be stored in sensor 102's memory for use in a SEAL. On one implementation, this seed may be generated as described above with respect to FIG. 2 is illustrated. Sensor 102 may also comprise a oneway function module 412, which incorporates the oneway function F( ) as described above with respect to FIG. 3.
Aggregator 106 may comprise a oneway function module 412, a aggregation module 414, and a folding module 416. Aggregation module 414 determines the maximum value v_{m }of values v_{i }received from sensor 102. Folding module 416 may roll SEAL chains forward and fold together. Folding may comprise an XOR function where the oneway function F( ) comprises MD5, or a modulo multiplication where the oneway function F( ) comprises RSA. Because one purpose of the SEALs is to prevent deflation by an aggregator, the aggregator can fold, but not create, SEALS. The generation of SEALs and folding for a secure max is described below with respect to FIG. 5. Aggregator 106 may also comprise a sensor status module 418, which maintains a list of sensors which are out of service. For clarity, this diagram omits the parent aggregator 110 shown in FIG. 1, however parent aggregator 110 may include the same elements as aggregator 106.
Portal 112 may comprise a sensor metadata storage module 420, a MAC module 402, a oneway function module 412, an aggregation module 414, a folding module 416, and a request service module 422. Sensor metadata storage module 420 may comprise sensor keys 404, sensor attributes 408, sensor status, and so forth. For example, sensor status may include whether a sensor is unavailable or offline. Sensors indicated as being offline may be probed by the portal to verify status, again providing a process of confirming the aggregator is truthfully reporting failures. Request service module 422 may be configured to provide verified data to requestor 116. Note that portal 112 includes modules found at both the sensor 102 and aggregator 106. As described below in more depth below, this is because the portal produces reference synopses (“RS”) to compare with the VS.
Generating SEALS and a Secure Maximum
FIG. 5 is a schematic diagram 500 illustrating generation and folding of selfauthenticating values (SEALs) for a secure maximum via oneway chains. Three sensors are illustrated as listed in the following table:

TABLE 1 



Sensor 
Sensor Data 
Seed 
SEAL at Sensor 



102(1) 
v_{1 }= 1 
s_{1} ^{−} 
F^{1}(s_{1} ^{−}) 

102(2) 
v_{2 }= 3 
s_{2} ^{−} 
F^{3}(s_{2} ^{−}) 

102(3) 
v_{3 }= 2 
s_{3} ^{−} 
F^{2}(s_{3} ^{−}) 


Recall that applying oneway function F( ) v_{i }times to a seed generates a SEAL. Sensor 102(1) reports sensor data value v_{1}=1, and so oneway function module 412(1) applies oneway function F( ) once against the seed s_{1} ^{−}, resulting in F^{1}(s_{1} ^{−}). Similarly, sensor 102(2) reports sensor data value v_{2}=3, and iterates its seed s_{2} ^{−} three times, resulting in F^{3}(s_{2} ^{−}). Likewise, sensor 102(3) reports sensor data value v_{3}=2 and iterates its seed twice, resulting in F^{2}(s_{3} ^{−}). A SEAL results from applying oneway function F( ) to a seed, and iterating F( ) v_{i }times as shown at 502.
Folding of oneway chains is facilitated when the oneway chains are of equal length. In the illustration of FIG. 5, the longest SEAL chain is that of sensor 102(2), with a length of 3, representing value v_{2}=3. The two shorter SEAL chains of sensor 102(1) and 102(3) are rolled forward at aggregator 106 to be equal in length with the SEAL chain of 102(2). Thus, at 504 F^{1}(s_{1} ^{−}) from sensor 102(1) is rolled forward twice to produce F^{3}(s_{1} ^{−}). Similarly, at 506 F^{2}(s_{3} ^{−}) from sensor 102(3) is rolled forward once to produce F^{3}(s_{3} ^{−}).
Now of equal length, the SEAL chains F^{3}(s_{1} ^{−}), F^{3}(s_{2} ^{−}), and F^{3}(s_{3} ^{−}) may be folded as shown at 506. At 508, F^{3}(s_{1} ^{−}) and F^{3}(s_{2} ^{−}) are folded. The results of this first fold are then folded at 510 with F^{3}(s_{3} ^{−}), resulting in a folded SEAL 512.
Note that folding does not require knowledge of the secret key K_{i}. Additionally, the folded SEAL has the same size as an individual SEAL and it can be used to verify all SEALs together. Folded SEALs are also secure, in that an adversary cannot produce a folded SEAL without knowing all the individual SEALs. Thus, the SEAL provides a deflationfree proof for reported sensor data.
FIG. 6 is a schematic diagram 600 illustrating aggregation of SEALs from multiple aggregators. As described above with respect to FIG. 1, folded SEALs may be received from several aggregators at one parent aggregator 110. In this way, a hierarchy of aggregators may be implemented for load balancing, speed, and so forth. As illustrated, aggregators 106(1) . . . 106(N) provide folded seals 512(2) . . . 512(N) to parent aggregator 110. The smallest folded SEALs are rolled forward at 602 until the two chains are of equal length using a oneway function module 412. Once the length of the SEAL chains are the same, they may be folded together at 604 using a folding module 416. Once folding is complete, a single folded SEAL 606 results.
The homomorphic nature of the oneway function is leveraged in this scenario of multiple aggregators. This is because, in one implementation, such hierarchical aggregation requires that oneway chains be rolled forward even after they have been previously folded. A suitable oneway function F is homomorphic with respect to the folding ⊙ both in domain and range. In other words, F(x_{1 }⊙ x_{2}))=F(x_{1}) ⊙ F(x_{2}), where x_{1 }and x_{2 }are inputs to F. One suitable oneway function F( ) is RSA, which is homomorphic with respect to the folding operator modulo multiplication. RSA encryption is performed by exponentiating the plaintext by e, modulo some large composite number m which is the product of two large primes. Hence, E(x_{1}·x_{2})=(x_{1}·x_{2})^{e }mod m=(x_{1} ^{e }mod m)·(x_{2} ^{e }mod m)=E(x_{1})·E(x_{2}). Therefore, RSA encryption may be used as F( ) and module m multiplication as the folding function ⊙. The hardness of the RSA decryption suffices to provide onewayness for F( ), and as long as it is insured that seeds are relatively prime to m (e.g., no 0 seeds), folding with multiplication modulo m preserves randomness.
Generating VS, AVS, and Evaluating
FIG. 7 is a flow diagram of an illustrative process of generating a verifiable synopsis (“VS”) that may, but need not, be implemented using the architectures shown in FIGS. 16. The process 700 will be described in the context of the architecture of FIGS. 16 for convenience and clarity. In some variations, the process 700 may be used to implement the secure outsourced aggregation shown and described with reference to FIG. 1. In one implementation, the following process may take place at a sensor.
At 702, sensor i generates data of value v_{i }and time epoch T. As described above, in some implementations v_{i }may be expressed as an integer value. In some implementations, T may also be expressed as an integer value.
At 704, an IFP is generated as discussed in FIG. 2 above. IFP s_{i} ^{+} results from executing a full domain hash MAC with key K_{i }with parameters of v_{i }and T. This full domain hash is the RSA based signature scheme which involves hashing a message using a function whose image size equals the size of the RSA modulus, and then raising the result to the secret RSA exponent. This provides an inflation free proof, as the MAC key K_{i }is available to the sensor and the portal, but not aggregator. Thus, inflation of v_{i }at the aggregator would be discovered by portal.
At 706, a SEAL is generated. At 708, a seed is generated by executing the full domain hash MAC with key K_{i }and using parameter T. At 710, the SEAL is generated by performing iterations of oneway function F( ) on the seed. The number of iterations of function F( ) corresponds to the integer value of v_{i}. As described in more depth below with respect to folding, use of a homomorphic function, such as RSA, permits folding of multiple SEALs using modulo multiplication.
At 712, a verifiable synopsis (“VS”) including sensor data v_{i}, IFP, and SEAL is generated. This VS may then be provided to an aggregator.
FIG. 8 is a flow diagram of an illustrative process of generating aggregated verifiable synopses (“AVS”) incorporating a max function that may, but need not, be implemented using the architectures shown in FIGS. 16. The process 800 will be described in the context of the architecture of FIGS. 16 for convenience and clarity. In some variations, the process 800 may be used to implement the secure outsourced aggregation shown and described with reference to FIG. 1. In one implementation, the following process may take place at an aggregator.
At 802, a plurality of VSs are received, the VSs comprising SEALS. These may be VSs directly from sensors, or aggregated VS provided by other aggregators. At 804, the maximum value v_{m }is determined. At 806, each SEAL with hash position v_{i}<v_{m }is rolled forward by iterating until each SEAL reaches position v_{m }in its hash chain. At 808, the SEAL chains of equal length are folded into a single SEAL. At 810, an aggregated VS (“AVS”) is generated, including a single SEAL, sensor data, and IFP.
FIG. 9 is a flow diagram of an illustrative process of evaluating an AVS that may, but need not, be implemented using the architectures shown in FIGS. 16. The process 900 will be described in the context of the architecture of FIGS. 16 for convenience and clarity. In some variations, the process 900 may be used to implement the secure outsourced aggregation shown and described with reference to FIG. 1. In one implementation, the following process may take place at a portal.
At 902, an AVS is received from an aggregator at a portal. The portal may now begin to validate the data provided in the AVS. At 904, an IFP is computed for the sensor reporting the max value v_{m }to be incorporated into a reference synopsis (“RS”), in essence repeating what has been done at a sensor. At 906, all individual SEALs from relevant sensors are computed and folded together to produce a single SEAL for the RS. This repeats what was done at the aggregator(s). At 908, a RS is generated using v_{m}, IFP for the sensor reporting the max value v_{m}, and the single folded SEAL. At 910, the RS is compared with the AVS, and when equal, the data in the AVS is determined to be valid because the results reported by the aggregator match those replicated by the portal.
This assertion of validity results from several aspects: First, the portal is aware of the reporting schedule for each sensor, and thus can use the proper epoch number as the T value when generating its version of the IFP and SEAL. Second, the portal and the sensors share a secret key, which the aggregators lack. Third, the list of offline sensors available to the portal allows the portal to check that active sensors have not been incorrectly indicated as being offline.
Rolling and Folding SEALS
FIG. 10 is a schematic diagram 1000 illustrating simple rolling of SEALs. Shown in this example are three SEAL chains, 1002, 1004, and 1006. SEALs which have been rolled forward using oneway function F( ) at the sensor are indicated with the crosshatching indicated at 1008. The length of SEAL chains 1002, 1004, and 1006 as rolled forward at the sensor are 2, 3, and 5 respectively. SEALS which have been rolled forward at an aggregator are indicated without crosshatching at 1010. Simple folding rolls all SEAL chains forward using F( ) until they are the same length, whereupon the SEAL chains are folded together. For example, in this diagram SEAL chain 1002 is rolled forward three times at the aggregator to bring it to length 5. Similarly, SEAL chain 1004 is rolled forward two times to bring it to length 5. Thus, a total of five forward rolling operations were executed in this example.
In this schematic, the SEALS which now all of equal length after rolling forward at the aggregator, are folded 1012 together and result in a single folded seal 1014. Simple rolling is straightforward to implement, however the requirement that all chains be brought to the same length before folding may result in significant computational overhead. However, it is possible to greatly reduce this overhead through folded rolling, described next.
FIG. 11 is a schematic diagram 1100 illustrating folded rolling of SEALs. As in FIG. 10, SEAL chains 1002, 1004, and 1006 are shown in this figure. Folded rolling utilizes the homomorphic properties of F( ) by sorting SEAL chains by length, and rolling a SEAL chain forward (if necessary) until its length equals the adjacent SEAL chain in the sorted list, whereupon the two may be folded together. This is repeated until only a single folded SEAL remains. This significantly reduces forward rolling requirements.
For example, SEAL chain 1002 of length 2 is closest in length to SEAL chain 1004 of length 3. SEAL chain 1002 is rolled forward once to equal the length of SEAL chain 1004. Once of equal length, SEAL chains 1002 and 1004 may be folded together as shown at 1102. The resulting intermediate folded single SEAL 1104 is then compared with SEAL chain 1006 of length 5. Intermediate SEAL chain 1106 comprising intermediate folded single SEAL 1104 is rolled forward twice until its length matches that of SEAL chain 1006. Once the lengths of the SEAL chains are matched, the SEALS are folded 1108, with a resulting folded single seal 1014. Due to the homomorphic properties of the oneway function, the folded single SEAL 1014 from the simple rolling of FIG. 10 and the folded rolling of FIG. 11 are equivalent.
Given that RSA is considered more computationally intensive than traditional hashing, it is not at first apparent how use of RSA reduces computational overhead. In such a case, it is useful to look at the entire processing load. A comparison of the simple rolling of FIG. 10 with folded rolling FIG. 11 demonstrates a significant reduction in the required amount of forward rolling. In FIG. 10, five executions of the function F( ) were required to roll the SEAL chains forward to enable folding. In contrast, FIG. 11 only required three executions of function F( ) on an aggregator or portal. Thus, using a oneway function such as RSA in conjunction with folded rolling results in less overhead than when conventional hashing is used.
Folded rolling is also effective in reducing overhead in a Count protocol (a secure protocol for answering Count queries, based on our secure Max protocol). Suppose the Count protocol uses the count algorithm by Alon, Matias, and Szegedy (AMS). The approximation error of the AMS algorithm can be reduced by using multiple instances of it simultaneously. Let J represent the number of instances of an AMS count algorithm, N represent the total number of sensors, and C represent the number of “child” sensors of an aggregator. Then, each AMS algorithm needs to invoke log N instances of Max algorithm. First, for each of the J instances of the Count protocol, an aggregator needs to use the F( ) function to aggregate all of the VSs received from children of the aggregator. Doing so naively would incur up to J·C·log N executions of F( ). Folded rolling reduces this number to J·log N, making it independent of C.
Second, when a portal receives the J VSs (that is, one VS for each instance) from a root aggregrator, the portal needs to verify each of those VSs. To enable folded rolling, J instances may be designed to use the same RSA encryption function (i.e., with the same encryption key) to construct their oneway SEAL chains. For the jth instance, a sensor i will generate its DFP as s^{−} _{i,j}={MAC_{Ki}(T∥j)}. s^{−} _{i,j }is then used as the seed for the oneway chain for sensor I in the instance j. Let the folded SEAL in the VS submitted to the portal for the jth instance be x_{j}, such that x_{j }should be ⊙_{i}F^{Vm}(s^{−} _{i,j}) where v_{m }is the maximum for this instance and when the aggregators are honest in their reporting. For the jth instance, with folded rolling, the portal may create the RS by first folding all s^{−} _{i,j}'s (for the given j) together, and then rolling forward to v_{m}. Doing so reduces the total number of executions of F( ) from J·N·log N to J·log N executions.
Folded rolling may also be applied across the J instances described above. Let w be the maximum across all the J maximums reported int eh J instances, which is roughly log N. Instead of verifying x_{j}'s individually, the portal may roll (actually or conceptually) the x_{j}'s to position w, then fold together. By applying folded rolling, the total number of executions of F( ) is ≦log N. With respect to the RS, the portal may (actually or conceptually) roll all of the s^{−} _{i,j}'s forward to w and fold them. Again, folded rolling enables this to be done with no more than log N executions of F( ). This aggressive optimization helps reduce the number of F( ) executions on a portal to 2 log N per verification, which is completely independent of J.
Finally, a parent aggregator may actually fold all of the x_{j}'s at identical positions (on the oneway chains) together before sending the data along to the portal. Since there may be at most log N distinct positions for all x_{j}'s, the total number of SEALs sent from the parent aggregator to the portal will be no more than log N. For example, where N=100,000 and 1024bit SEALs, this will be less than 2 kilobytes. For the J IFP s^{+} _{i,j}, the parent aggregator may also fold them together before sending to the portal.
Folded rolling only helps to reduce the number of rolling operations. For each query, the portal still needs to generate an RS which takes up to J·N folding operations (modulo multiplication) to fold all the s^{−} _{i,j}'s together. Queries may have range predicates that cover sensors with continuous id ranges. For these queries, the portal can create a binary tree (or a B+tree or an RTree) at the beginning of each time epoch. The leaves of the tree are all the s^{−} _{i,j}'s, ordered by i from left to right. Each internal node of the tree is the modulo multiplication of its children. Constructing such a tree still takes J·N folding operations, but this only needs to be done once per epoch.
Regardless of the id range required by the query, it is possible to always find no more than 2 log N disjoint subtrees, such that the set of all the leaves of these subtrees is exactly the set of sensors falling within that range. Roots of these subtrees can be found with a preorder traversal of the tree. Multiplying all the root of these subtrees then yields the folding result needed. Doing so thus reduces the number of multiplications from J·N to 2 log N. It is trivial to generalize such technique to dealing with range predicates based on other static attributes of the sensors. One can simply build one tree for each static attribute.
FIG. 12 is a flow diagram of an illustrative process 1200 of folded rolling that may, but need not, be implemented using the architectures shown in FIGS. 16. The process 1200 will be described in the context of the architecture of FIGS. 16 for convenience and clarity. In some variations, the process 1200 may be used to implement the secure outsourced aggregation shown and described with reference to FIG. 1. In one implementation, the following process may take place at an aggregator, parent aggregator, or portal.
At 1202, SEAL chains are ordered by length. At 1204, a determination is made as to whether the first two adjacent SEAL chains are of equal length. When 1204 determines the first two adjacent SEAL chains to be of equal length, at 1206 the first SEAL chain and second SEAL chain are folded together. At 1208, a determination is made as to whether there is only a single SEAL remaining. When only a single SEAL remains as determined at 1208, at 1210 a single SEAL is output.
Returning to 1204, when adjacent SEAL chains are not of equal length, at 1212 the shortest first SEAL chain is rolled forward to match the length of the adjacent next shortest SEAL chain. At 1206, the first SEAL chain and second SEAL chain, now of equal length, are folded together. This process continues until, as described above, at 1208 it is determined that only a single SEAL remains.
Determining Top “k” Values
FIG. 13 is a schematic diagram 1300 illustrating a topk query, where k=3. Illustrated are sensors 13011304 which report to aggregator 1310, and sensors 13051308 which report to aggregator 1312. Aggregators 1310 and 1312 in turn report to parent aggregator 1314. For this illustration, the sensors report the following values:
TABLE 2 



Reports to 
Sensor # 
Data value 
Aggregator 

1301 
80 
1310 
1302 
12 
1310 
1303 
10 
1310 
1304 
61 
1310 
1305 
26 
1312 
1306 
20 
1312 
1307 
18 
1312 
1308 
75 
1312 

Without loss of generality, it may be assumed that sensor values are all distinct (e.g., by appending the id of a sensor to its reading). In one implementation, a Top k query may be satisfied by invoking the Max protocol sequentially for k times. Namely, the first invocation will return the largest value together with which sensor i_{1 }generated this Max. The second invocation of the protocol will simply exclude sensor i_{1}, and then compute the Max again. To exclude sensor i_{1}, the parent aggregator (after the first invocation and after knowing i_{1}) needs to potentially broadcast i_{1 }to all the aggregators, so that they can exclude sensor i_{1 }in the protocol. The second invocation will then produce the second largest value as well as which sensor i_{2 }generated this second largest value. More precisely, for the second largest value, the VS submitted to the portal will be (v_{i2}, s^{+} _{i2}, ⊙_{i≠i1}F^{vi2}(s_{i} ^{−})). Invoking the Max protocol in this way sequentially for k times can then answer the Top k query.
However, invoking Max sequentially for k times may incur unnecessary delay. This is particularly true when using a topk query to obtain k random samples, where k may be as large as several hundreds. It is possible to mimic the above process via k parallel invocations of the Max protocol. This parallel invocation requires addressing several complexities: For example, for the ith largest value, it may be necessary to produce folded s_{i} ^{−}'s of all sensors excluding those generating the top i−1 values. The challenge is that each aggregator, when performing the aggregation, does not yet know which sensors generated the globally top i−1 values.
Consider the example in FIG. 13 where k=3. VS α contains the top three values known by aggregator 1310. Similarly, VS β contains the top three values known by aggregator 1310. For discussion purposes, the sensor number is enclosed in parenthesis, thus 80(1301) denotes sensor 1301 reporting value 80.
It is easy to include similar verification information in α as before in the Max protocol. For example, to prove that 61 is the maximum reading seen so far excluding the reading from sensor 1301, α may include F^{61}(s_{2} ^{−}) ⊙ F^{61}(s_{3} ^{−}) ⊙ F^{61}(s_{4} ^{−}). β covers sensors 1305 through 1308 and the Top3 values observed so far are 75(1308), 26(1305), and 20(1306). It is thus possible to take the Topk values of a union when merging two synopses. Thus the new Top3 values after aggregation should be 80(1301), 75(1308), and 61(1304).
In the new VS, the verification information for 61 needs to be the folded s_{i} ^{−}'s of sensors 1302 through 1307, since 61 is the third largest value and it becomes worthwhile to exclude sensors 1301 and 1308 which generated the top two values. Notice that for the value 61, α only contains the folded s_{i} ^{−}'s of sensors 1302, 1303, and 1304 (i.e., F^{61}(s_{2} ^{−}) ⊙ F^{61}(s_{3} ^{−}) ⊙ F^{61}(s_{4} ^{−})). At this point F^{61}(s_{5} ^{−}), F^{61}(s_{6} ^{−}), or F^{61}(s_{7} ^{−}) are not known. Fortunately, the verification information for 26(1305) in β should contain the folded signatures from sensors 1305, 1306, and 1307 (i.e., F^{26}(s_{5} ^{−}) ⊙ F^{26}(s_{6} ^{−}) ⊙ F^{26}(s_{7} ^{−})). Since 61>26, it is possible to roll this folded signature forward and then fold it with the one from α.
The above includes several subtleties: For example, if β only contained F^{20}(s_{6} ^{−}) ⊙ F^{20}(s_{7} ^{−}) and F^{75}(s_{5} ^{−}) ⊙ F^{75}(s_{6} ^{−}) ⊙ F^{75}(s_{7} ^{−}) ⊙ F^{75}(s_{8} ^{−}), it may not be possible to generate the verification information for 61. However, as demonstrated later, it is always possible to generate the verification information for 61 by finding the largest value in β that is smaller than 61, and use its corresponding verification information. This means that the previous problematic scenario will never occur.
A protocol for a topk query may be implemented in the following fashion. For any given aggregator in the aggregation tree, its coverset is defined as the set of all sensors in its subtree. For Topk query, the VS sent by an aggregator with coverset U has the form of: {VS_{i1}, VS_{i2}, . . . , VS_{ik},} where VS_{i} _{ j }=(v_{i} _{ j },s_{i} _{ j } ^{−},⊙_{iεS{i} _{ 1 } _{, i} _{ 2 } _{, . . . , i} _{ j−1 } _{}} F^{v} ^{ ij }(s_{i} ^{−})), and
v _{i} _{ 1 } >v _{i} _{ 2 } > . . . >v _{i} _{ k },
The value of k′ is within [1, k]. Roughly speaking, VS_{i1 }through VS_{ik′} contains the topk′ values observed so far, and these values are from sensors i_{1 }through i_{k′}. The value k′ may be smaller than k initially (i.e., when observing less than k values).
A sensor i with reading v_{i }generates: {(v_{i}, s_{i} ^{+},F^{vi}(s_{i} ^{−})}. Let α={α_{i1}, α_{i2}, . . . } and β={β_{i1}, β_{i2}, . . . }. An aggregator may aggregate α and β into γ={γ_{i1}, γ_{i2}, . . . }. Here, γ_{i1}, γ_{i2}, . . . correspond to the Topk values among α_{i1}, α_{i2}, . . . , and β_{i1}, β_{i2}, . . . . Without loss of generality, consider some α_{x}=(v_{s},s_{x} ^{+},f_{x}) in α that is one of the new Topk values, where it becomes worthwhile to construct a corresponding γ_{x }in γ. Let v_{y }be the largest value in β (i.e., among v_{j1}, v_{j2}, . . . ) such that v_{x}>v_{y}.
If v_{y }does exist, let the element βy=(v_{y}, s_{y} ^{+}, f_{y}). γ_{x }may be constructed as follows:
γ_{x}=(v _{x} ,s _{x} ^{+} ,f _{x} ⊙F ^{(v} ^{ x } ^{−v} ^{ y } ^{)}(f _{y})
To understand why doing so is correct, suppose α covers U_{α} and β covers U_{β}. Then f_{x }covers all sensors in Uα except those sensors with readings larger than v_{x}. Similarly, f_{y }covers all sensors in Uβ except those sensors with readings larger than v_{y}. But because v_{x}>v_{y }and U_{β} does not contain any sensor with a reading between v_{x }and v_{y}, f_{y }actually covers all sensors in _{U}β except those sensors with readings larger than v_{x}. As a result, f_{x}=⊙F^{(v} ^{ x } ^{−v} ^{ y } ^{)}(f_{y}) exactly covers all sensors in U_{α} ∪ U_{β} except those sensors with readings larger than v_{x}.
If all values in β are larger than v_{x}, then v_{y }does not exist and γ_{x }may be set to γ_{x}=α_{x}. In such a case, β must have less than k values, since otherwise v_{x }can never be among the new Topk. Let U_{β} be the set of sensors covered by β. Then all sensors in U_{β} have readings larger than v_{x}. As a result, it is not necessary to fold additional s_{i} ^{−}'s from any sensor in U_{β}.
With the above in mind, synopsis evaluation becomes trivial. Namely, the portal may verify the largest value as before for Max, then verifies the second largest value as the Max excluding the largest value, and so on.
To reduce the overhead of verification when k is large, the portal may verify the VS_{ik}, . . . VS_{i2}, VS_{i1 }according to that order. After constructing the RS of ρ_{k}=⊙_{iε{i} _{ 1 } _{, i} _{ 2 } _{, . . . , i} _{ k−1 } _{} F} ^{ v } ^{i} ^{ k }(s_{i} ^{−}) for VS_{ik}, the portal may generate the RS for VS_{ik }as ρ_{k−1}=F^{ v } ^{i} ^{ k−1 } ^{−v} ^{ ik }(ρ_{k}⊙(s_{i} _{ k−1 } ^{−}). Doing so will make the number of F( ) operations independent of k.
It is also worthwhile to note that a Uniform Samples query may be be readily reduced to a Topk query, by having each sensor generate a uniformly random number in (0, 1) and by returning the sensors with the Top k numbers. k^{th }statistical moments, quantiles, and median may all be computed from uniform samples, and thus may be securely computed using this protocol for topk query.
FIG. 14 is a flow diagram of an illustrative process 1400 of determining topk values at an aggregator, where k is predetermined. At 1402, a k number of top values to return from a set of values is configured. This may be from user input, parameter determined by software, and so forth. At 1404, a first max value in the set folded over all values is determined and stored. At 1406, the first max value is removed from the set, and the remaining values are folded. At 1408, a next max value is determined from the set, and stored. At 1410, the next max value is removed from the set, and the remaining values are folded. At 1412, if k has been reached those topk values, at 1414 the topk values are output. Otherwise, at 1412 k has not been reached, the process returns to 1408 and continues until the topk values have been reached.
CONCLUSION
Although specific details of illustrative methods are described with regard to the figures and other flow diagrams presented herein, it should be understood that certain acts shown in the figures need not be performed in the order described, and may be modified, and/or may be omitted entirely, depending on the circumstances. As described in this application, modules and engines may be implemented using software, hardware, firmware, or a combination of these. Moreover, the acts and methods described may be implemented by a computer, processor or other computing device based on instructions stored on memory, the memory comprising one or more computerreadable storage media (CRSM).
The CRSM may be any available physical media accessible by a computing device to implement the instructions stored thereon. CRSM may include, but is not limited to, random access memory (RAM), readonly memory (ROM), electrically erasable programmable readonly memory (EEPROM), flash memory or other solidstate memory technology, compact disk readonly memory (CDROM), digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by a computing device.