Jpdcs1(data lekage detection)

IEEE TRANSACTIONS ON KNOWLEDGE AND DATA ENGINEERING, VOL. 23, NO. 1, JANUARY 2011 51

Data Leakage Detection
Panagiotis Papadimitriou, Student Member, IEEE, and Hector Garcia-Molina, Member, IEEE

Abstract—We study the following problem: A data distributor has given sensitive data to a set of supposedly trusted agents (third
parties). Some of the data are leaked and found in an unauthorized place (e.g., on the web or somebody’s laptop). The distributor must
assess the likelihood that the leaked data came from one or more agents, as opposed to having been independently gathered by other
means. We propose data allocation strategies (across the agents) that improve the probability of identifying leakages. These methods
do not rely on alterations of the released data (e.g., watermarks). In some cases, we can also inject “realistic but fake” data records to
further improve our chances of detecting leakage and identifying the guilty party.

Index Terms—Allocation strategies, data leakage, data privacy, fake records, leakage model.

Ç

1 INTRODUCTION

I N the course of doing business, sometimes sensitive data
must be handed over to supposedly trusted third parties.
For example, a hospital may give patient records to
we study the following scenario: After giving a set of objects
to agents, the distributor discovers some of those same
objects in an unauthorized place. (For example, the data
researchers who will devise new treatments. Similarly, a may be found on a website, or may be obtained through a
company may have partnerships with other companies that legal discovery process.) At this point, the distributor can
require sharing customer data. Another enterprise may assess the likelihood that the leaked data came from one or
outsource its data processing, so data must be given to more agents, as opposed to having been independently
various other companies. We call the owner of the data the gathered by other means. Using an analogy with cookies
distributor and the supposedly trusted third parties the stolen from a cookie jar, if we catch Freddie with a single
agents. Our goal is to detect when the distributor’s sensitive cookie, he can argue that a friend gave him the cookie. But if
data have been leaked by agents, and if possible to identify we catch Freddie with five cookies, it will be much harder
the agent that leaked the data. for him to argue that his hands were not in the cookie jar. If
We consider applications where the original sensitive the distributor sees “enough evidence” that an agent leaked
data, he may stop doing business with him, or may initiate
data cannot be perturbed. Perturbation is a very useful
legal proceedings.
technique where the data are modified and made “less
In this paper, we develop a model for assessing the
sensitive” before being handed to agents. For example, one
“guilt” of agents. We also present algorithms for distribut-
can add random noise to certain attributes, or one can
ing objects to agents, in a way that improves our chances of
replace exact values by ranges [18]. However, in some cases, identifying a leaker. Finally, we also consider the option of
it is important not to alter the original distributor’s data. For adding “fake” objects to the distributed set. Such objects do
example, if an outsourcer is doing our payroll, he must have not correspond to real entities but appear realistic to the
the exact salary and customer bank account numbers. If agents. In a sense, the fake objects act as a type of
medical researchers will be treating patients (as opposed to watermark for the entire set, without modifying any
simply computing statistics), they may need accurate data individual members. If it turns out that an agent was given
for the patients. one or more fake objects that were leaked, then the
Traditionally, leakage detection is handled by water- distributor can be more confident that agent was guilty.
marking, e.g., a unique code is embedded in each distributed We start in Section 2 by introducing our problem setup
copy. If that copy is later discovered in the hands of an and the notation we use. In Sections 4 and 5, we present a
unauthorized party, the leaker can be identified. Watermarks model for calculating “guilt” probabilities in cases of data
can be very useful in some cases, but again, involve some leakage. Then, in Sections 6 and 7, we present strategies for
modification of the original data. Furthermore, watermarks data allocation to agents. Finally, in Section 8, we evaluate
can sometimes be destroyed if the data recipient is malicious. the strategies in different data leakage scenarios, and check
In this paper, we study unobtrusive techniques for whether they indeed help us to identify a leaker.
detecting leakage of a set of objects or records. Specifically,

2 PROBLEM SETUP AND NOTATION
. The authors are with the Department of Computer Science, Stanford
University, Gates Hall 4A, Stanford, CA 94305-9040.
2.1 Entities and Agents
E-mail: papadimitriou@stanford.edu, hector@cs.stanford.edu. A distributor owns a set T ¼ ft1 ; . . . ; tm g of valuable data
Manuscript received 23 Oct. 2008; revised 14 Dec. 2009; accepted 17 Dec. objects. The distributor wants to share some of the objects
2009; published online 11 June 2010. with a set of agents U1 ; U2 ; . . . ; Un , but does not wish the
Recommended for acceptance by B.C. Ooi. objects be leaked to other third parties. The objects in T could
For information on obtaining reprints of this article, please send e-mail to:
tkde@computer.org, and reference IEEECS Log Number TKDE-2008-10-0558. be of any type and size, e.g., they could be tuples in a
Digital Object Identifier no. 10.1109/TKDE.2010.100. relation, or relations in a database.
1041-4347/11/$26.00 ß 2011 IEEE Published by the IEEE Computer Society

52 IEEE TRANSACTIONS ON KNOWLEDGE AND DATA ENGINEERING, VOL. 23, NO. 1, JANUARY 2011

An agent Ui receives a subset of objects Ri T , 3 RELATED WORK
determined either by a sample request or an explicit request:
The guilt detection approach we present is related to the
. Sample request Ri ¼ SAMPLEðT ; mi Þ: Any subset of data provenance problem [3]: tracing the lineage of
mi records from T can be given to Ui . S objects implies essentially the detection of the guilty
. Explicit request Ri ¼ EXPLICITðT ; condi Þ: Agent Ui agents. Tutorial [4] provides a good overview on the
receives all T objects that satisfy condi . research conducted in this field. Suggested solutions are
domain specific, such as lineage tracing for data ware-
houses [5], and assume some prior knowledge on the way a
Example. Say that T contains customer records for a given
data view is created out of data sources. Our problem
company A. Company A hires a marketing agency U1 to
formulation with objects and sets is more general and
do an online survey of customers. Since any customers
simplifies lineage tracing, since we do not consider any data
will do for the survey, U1 requests a sample of
transformation from Ri sets to S.
1,000 customer records. At the same time, company A As far as the data allocation strategies are concerned, our
subcontracts with agent U2 to handle billing for all work is mostly relevant to watermarking that is used as a
California customers. Thus, U2 receives all T records that means of establishing original ownership of distributed
satisfy the condition “state is California.” objects. Watermarks were initially used in images [16], video
[8], and audio data [6] whose digital representation includes
Although we do not discuss it here, our model can be considerable redundancy. Recently, [1], [17], [10], [7], and
easily extended to requests for a sample of objects that other works have also studied marks insertion to relational
satisfy a condition (e.g., an agent wants any 100 California data. Our approach and watermarking are similar in the
customer records). Also note that we do not concern sense of providing agents with some kind of receiver
ourselves with the randomness of a sample. (We assume identifying information. However, by its very nature, a
that if a random sample is required, there are enough T watermark modifies the item being watermarked. If the
records so that the to-be-presented object selection schemes object to be watermarked cannot be modified, then a
can pick random records from T .) watermark cannot be inserted. In such cases, methods that
2.2 Guilty Agents attach watermarks to the distributed data are not applicable.
Finally, there are also lots of other works on mechan-
Suppose that after giving objects to agents, the distributor
isms that allow only authorized users to access sensitive
discovers that a set S T has leaked. This means that some
data through access control policies [9], [2]. Such ap-
third party, called the target, has been caught in possession
proaches prevent in some sense data leakage by sharing
of S. For example, this target may be displaying S on its
information only with trusted parties. However, these
website, or perhaps as part of a legal discovery process, the
policies are restrictive and may make it impossible to
target turned over S to the distributor.
satisfy agents’ requests.
Since the agents U1 ; . . . ; Un have some of the data, it is
reasonable to suspect them leaking the data. However, the
agents can argue that they are innocent, and that the S data 4 AGENT GUILT MODEL
were obtained by the target through other means. For To compute this P rfGi jSg, we need an estimate for the
example, say that one of the objects in S represents a probability that values in S can be “guessed” by the target.
customer X. Perhaps X is also a customer of some other For instance, say that some of the objects in S are e-mails of
company, and that company provided the data to the target. individuals. We can conduct an experiment and ask a
Or perhaps X can be reconstructed from various publicly person with approximately the expertise and resources of
available sources on the web. the target to find the e-mail of, say, 100 individuals. If this
Our goal is to estimate the likelihood that the leaked data person can find, say, 90 e-mails, then we can reasonably
came from the agents as opposed to other sources. guess that the probability of finding one e-mail is 0.9. On
Intuitively, the more data in S, the harder it is for the the other hand, if the objects in question are bank account
agents to argue they did not leak anything. Similarly, the numbers, the person may only discover, say, 20, leading to
“rarer” the objects, the harder it is to argue that the target an estimate of 0.2. We call this estimate pt , the probability
obtained them through other means. Not only do we want that object t can be guessed by the target.
to estimate the likelihood the agents leaked data, but we Probability pt is analogous to the probabilities used in
would also like to find out if one of them, in particular, was designing fault-tolerant systems. That is, to estimate how
more likely to be the leaker. For instance, if one of the likely it is that a system will be operational throughout a
S objects was only given to agent U1 , while the other objects given period, we need the probabilities that individual
were given to all agents, we may suspect U1 more. The components will or will not fail. A component failure in our
model we present next captures this intuition. case is the event that the target guesses an object of S. The
We say an agent Ui is guilty and if it contributes one or component failure is used to compute the overall system
more objects to the target. We denote the event that agent Ui reliability, while we use the probability of guessing to
is guilty by Gi and the event that agent Ui is guilty for a identify agents that have leaked information. The compo-
given leaked set S by Gi jS. Our next step is to estimate nent failure probabilities are estimated based on experi-
P rfGi jSg, i.e., the probability that agent Ui is guilty given ments, just as we propose to estimate the pt s. Similarly, the
evidence S. component probabilities are usually conservative estimates,

PAPADIMITRIOU AND GARCIA-MOLINA: DATA LEAKAGE DETECTION 53

rather than exact numbers. For example, say that we use a Similarly, we find that agent U1 leaked t2 to S with
component failure probability that is higher than the actual probability 1 À p since he is the only agent that has t2 .
probability, and we design our system to provide a desired Given these values, the probability that agent U1 is not
high level of reliability. Then we will know that the actual guilty, namely that U1 did not leak either object, is
system will have at least that level of reliability, but possibly

P rfG1 jSg ¼ ð1 À ð1 À pÞ=2Þ Â ð1 À ð1 À pÞÞ; ð1Þ
higher. In the same way, if we use pt s that are higher than
the true values, we will know that the agents will be guilty and the probability that U1 is guilty is
with at least the computed probabilities.
To simplify the formulas that we present in the rest of the
P rfG1 jSg ¼ 1 À P rfG1 g: ð2Þ
paper, we assume that all T objects have the same pt , which
Note that if Assumption 2 did not hold, our analysis would
we call p. Our equations can be easily generalized to diverse
pt s though they become cumbersome to display. be more complex because we would need to consider joint
Next, we make two assumptions regarding the relation- events, e.g., the target guesses t1 , and at the same time, one
ship among the various leakage events. The first assump- or two agents leak the value. In our simplified analysis, we
tion simply states that an agent’s decision to leak an object is say that an agent is not guilty when the object can be
not related to other objects. In [14], we study a scenario guessed, regardless of whether the agent leaked the value.
where the actions for different objects are related, and we Since we are “not counting” instances when an agent leaks
study how our results are impacted by the different information, the simplified analysis yields conservative
independence assumptions. values (smaller probabilities).
In the general case (with our assumptions), to find the
Assumption 1. For all t; t0 2 S such that t 6¼ t0 , the provenance
probability that an agent Ui is guilty given a set S, first, we
of t is independent of the provenance of t0 .
compute the probability that he leaks a single object t to S.
To compute this, we define the set of agents Vt ¼ fUi jt 2 Ri g
The term “provenance” in this assumption statement
that have t in their data sets. Then, using Assumption 2 and
refers to the source of a value t that appears in the leaked
known probability p, we have the following:
set. The source can be any of the agents who have t in their
sets or the target itself (guessing). P rfsome agent leaked t to Sg ¼ 1 À p: ð3Þ
To simplify our formulas, the following assumption
states that joint events have a negligible probability. As we Assuming that all agents that belong to Vt can leak t to S
argue in the example below, this assumption gives us more with equal probability and using Assumption 2, we obtain
conservative estimates for the guilt of agents, which is 1Àp
; if Ui 2 Vt ;
consistent with our goals. P rfUi leaked t to Sg ¼ jVt j ð4Þ
0; otherwise:
Assumption 2. An object t 2 S can only be obtained by the
target in one of the two ways as follows: Given that agent Ui is guilty if he leaks at least one value
to S, with Assumption 1 and (4), we can compute the
. A single agent Ui leaked t from its own Ri set. probability P rfGi jSg that agent Ui is guilty:
. The target guessed (or obtained through other means) t
Y 1Àp

without the help of any of the n agents. P rfGi jSg ¼ 1 À 1À : ð5Þ
In other words, for all t 2 S, the event that the target guesses t t2SR
jVt j
i

and the events that agent Ui (i ¼ 1; . . . ; n) leaks object t are
disjoint.
5 GUILT MODEL ANALYSIS
Before we present the general formula for computing the In order to see how our model parameters interact and to
probability P rfGi jSg that an agent Ui is guilty, we provide a check if the interactions match our intuition, in this
simple example. Assume that the distributor set T , the section, we study two simple scenarios. In each scenario,
agent sets Rs, and the target set S are: we have a target that has obtained all the distributor’s
objects, i.e., T ¼ S.
T ¼ ft1 ; t2 ; t3 g; R1 ¼ ft1 ; t2 g; R2 ¼ ft1 ; t3 g; S ¼ ft1 ; t2 ; t3 g:
5.1 Impact of Probability p
In this case, all three of the distributor’s objects have been
leaked and appear in S. Let us first consider how the target In our first scenario, T contains 16 objects: all of them are
may have obtained object t1 , which was given to both given to agent U1 and only eight are given to a second
agents. From Assumption 2, the target either guessed t1 or agent U2 . We calculate the probabilities P rfG1 jSg and
one of U1 or U2 leaked it. We know that the probability of P rfG2 jSg for p in the range [0, 1] and we present the results
the former event is p, so assuming that probability that each in Fig. 1a. The dashed line shows P rfG1 jSg and the solid
of the two agents leaked t1 is the same, we have the line shows P rfG2 jSg.
following cases: As p approaches 0, it becomes more and more unlikely
that the target guessed all 16 values. Each agent has enough
. the target guessed t1 with probability p, of the leaked data that its individual guilt approaches 1.
. agent U1 leaked t1 to S with probability ð1 À pÞ=2, However, as p increases in value, the probability that U2 is
and guilty decreases significantly: all of U2 ’s eight objects were
. agent U2 leaked t1 to S with probability ð1 À pÞ=2. also given to U1 , so it gets harder to blame U2 for the leaks.


Fig. 1. Guilt probability as a function of the guessing probability p (a) and the overlap between S and R2 (b)-(d). In all scenarios, it holds that
R1 S ¼ S and jSj ¼ 16. (a) jRjSj ¼ 0:5, (b) p ¼ 0:2, (c) p ¼ 0:5, and (d) p ¼ 0:9.
2 Sj

On the other hand, U2 ’s probability of guilt remains close to As shown in Fig. 2, we represent our four problem
1 as p increases, since U1 has eight objects not seen by the instances with the names EF , EF , SF , and SF , where E
other agent. At the extreme, as p approaches 1, it is very stands for explicit requests, S for sample requests, F for the
possible that the target guessed all 16 values, so the agent’s use of fake objects, and F for the case where fake objects are
probability of guilt goes to 0. not allowed.
Note that, for simplicity, we are assuming that in the E
5.2 Impact of Overlap between Ri and S problem instances, all agents make explicit requests, while
In this section, we again study two agents, one receiving all in the S instances, all agents make sample requests. Our
the T ¼ S data and the second one receiving a varying results can be extended to handle mixed cases, with some
fraction of the data. Fig. 1b shows the probability of guilt for explicit and some sample requests. We provide here a small
both agents, as a function of the fraction of the objects example to illustrate how mixed requests can be handled,
owned by U2 , i.e., as a function of jR2 Sj=jSj. In this case, p but then do not elaborate further. Assume that we have
has a low value of 0.2, and U1 continues to have all 16S two agents with requests R1 ¼ EXPLICITðT ; cond1 Þ and
objects. Note that in our previous scenario, U2 has 50 percent
R2 ¼ SAMPLEðT 0 ; 1Þ, w h e r e T 0 ¼ EXPLICITðT ; cond2 Þ.
of the S objects.
Further, say that cond1 is “state ¼ CA” (objects have a state
We see that when objects are rare (p ¼ 0:2), it does not
field). If agent U2 has the same condition cond2 ¼ cond1 , we
take many leaked objects before we can say that U2 is guilty
can create an equivalent problem with sample data requests
with high confidence. This result matches our intuition: an
on set T 0 . That is, our problem will be how to distribute the
agent that owns even a small number of incriminating
CA objects to two agents, with R1 ¼ SAMPLEðT 0 ; jT 0 jÞ
objects is clearly suspicious.
and R2 ¼ SAMPLEðT 0 ; 1Þ. If instead U2 uses condition
Figs. 1c and 1d show the same scenario, except for values
“state ¼ NY,” we can solve two different problems for sets
of p equal to 0.5 and 0.9. We see clearly that the rate of
T 0 and T À T 0 . In each problem, we will have only
increase of the guilt probability decreases as p increases.
This observation again matches our intuition: As the objects one agent. Finally, if the conditions partially overlap,
become easier to guess, it takes more and more evidence of R1 T 0 6¼ ;, but R1 6¼ T 0 , we can solve three different
leakage (more leaked objects owned by U2 ) before we can problems for sets R1 À T 0 , R1 T 0 , and T 0 À R1 .
have high confidence that U2 is guilty. 6.1 Fake Objects
In [14], we study an additional scenario that shows how
the sharing of S objects by agents affects the probabilities The distributor may be able to add fake objects to the
that they are guilty. The scenario conclusion matches our distributed data in order to improve his effectiveness in
intuition: with more agents holding the replicated leaked detecting guilty agents. However, fake objects may impact
data, it is harder to lay the blame on any one agent. the correctness of what agents do, so they may not always
be allowable.
The idea of perturbing data to detect leakage is not new,
6 DATA ALLOCATION PROBLEM e.g., [1]. However, in most cases, individual objects are
The main focus of this paper is the data allocation problem: perturbed, e.g., by adding random noise to sensitive
how can the distributor “intelligently” give data to agents in salaries, or adding a watermark to an image. In our case,
order to improve the chances of detecting a guilty agent? As we are perturbing the set of distributor objects by adding
illustrated in Fig. 2, there are four instances of this problem
we address, depending on the type of data requests made
by agents and whether “fake objects” are allowed.
The two types of requests we handle were defined in
Section 2: sample and explicit. Fake objects are objects
generated by the distributor that are not in set T . The objects
are designed to look like real objects, and are distributed to
agents together with T objects, in order to increase the
chances of detecting agents that leak data. We discuss fake
objects in more detail in Section 6.1. Fig. 2. Leakage problem instances.


fake elements. In some applications, fake objects may cause the Ri and Fi tables, respectively, and the intersection of the
fewer problems that perturbing real objects. For example, conditions condi s.
say that the distributed data objects are medical records and Although we do not deal with the implementation of
the agents are hospitals. In this case, even small modifica- CREATEFAKEOBJECT(), we note that there are two main
tions to the records of actual patients may be undesirable. design options. The function can either produce a fake
However, the addition of some fake medical records may be object on demand every time it is called or it can return an
acceptable, since no patient matches these records, and appropriate object from a pool of objects created in advance.
hence, no one will ever be treated based on fake records.
6.2 Optimization Problem
Our use of fake objects is inspired by the use of “trace”
records in mailing lists. In this case, company A sells to The distributor’s data allocation to agents has one constraint
company B a mailing list to be used once (e.g., to send and one objective. The distributor’s constraint is to satisfy
agents’ requests, by providing them with the number of
advertisements). Company A adds trace records that
objects they request or with all available objects that satisfy
contain addresses owned by company A. Thus, each time
their conditions. His objective is to be able to detect an agent
company B uses the purchased mailing list, A receives
who leaks any portion of his data.
copies of the mailing. These records are a type of fake
We consider the constraint as strict. The distributor may
objects that help identify improper use of data.
not deny serving an agent request as in [13] and may not
The distributor creates and adds fake objects to the data
provide agents with different perturbed versions of the
that he distributes to agents. We let Fi Ri be the subset of
same objects as in [1]. We consider fake object distribution
fake objects that agent Ui receives. As discussed below, fake
as the only possible constraint relaxation.
objects must be created carefully so that agents cannot
Our detection objective is ideal and intractable. Detection
distinguish them from real objects.
would be assured only if the distributor gave no data object
In many cases, the distributor may be limited in how
to any agent (Mungamuru and Garcia-Molina [11] discuss
many fake objects he can create. For example, objects may
that to attain “perfect” privacy and security, we have to
contain e-mail addresses, and each fake e-mail address may sacrifice utility). We use instead the following objective:
require the creation of an actual inbox (otherwise, the agent maximize the chances of detecting a guilty agent that leaks
may discover that the object is fake). The inboxes can all his data objects.
actually be monitored by the distributor: if e-mail is We now introduce some notation to state formally the
received from someone other than the agent who was distributor’s objective. Recall that P rfGj jS ¼ Ri g or simply
given the address, it is evident that the address was leaked. P rfGj jRi g is the probability that agent Uj is guilty if the
Since creating and monitoring e-mail accounts consumes distributor discovers a leaked table S that contains all
resources, the distributor may have a limit of fake objects. If Ri objects. We define the difference functions Áði; jÞ as
there is a limit, we denote it by B fake objects.
Similarly, the distributor may want to limit the number Áði; jÞ ¼ P rfGi jRi g À P rfGj jRi g i; j ¼ 1; . . . ; n: ð6Þ
of fake objects received by each agent so as to not arouse Note that differences Á have nonnegative values: given that
suspicions and to not adversely impact the agents’ activ- set Ri contains all the leaked objects, agent Ui is at least as
ities. Thus, we say that the distributor can send up to bi fake likely to be guilty as any other agent. Difference Áði; jÞ is
objects to agent Ui . positive for any agent Uj , whose set Rj does not contain all
Creation. The creation of fake but real-looking objects is a data of S. It is zero if Ri Rj . In this case, the distributor
nontrivial problem whose thorough investigation is beyond will consider both agents Ui and Uj equally guilty since they
the scope of this paper. Here, we model the creation of a fake have both received all the leaked objects. The larger a Áði; jÞ
object for agent Ui as a black box function CREATEFAKEOB- value is, the easier it is to identify Ui as the leaking agent.
JECT ðRi ; Fi ; condi Þ that takes as input the set of all objects Ri , Thus, we want to distribute data so that Á values are large.
the subset of fake objects Fi that Ui has received so far, and
Problem Definition. Let the distributor have data requests from
condi , and returns a new fake object. This function needs
n agents. The distributor wants to give tables R1 ; . . . ; Rn to
condi to produce a valid object that satisfies Ui ’s condition.
agents U1 ; . . . ; Un , respectively, so that
Set Ri is needed as input so that the created fake object is not
only valid but also indistinguishable from other real objects. . he satisfies agents’ requests, and
For example, the creation function of a fake payroll record . he maximizes the guilt probability differences Áði; jÞ
that includes an employee rank and a salary attribute may for all i; j ¼ 1; . . . ; n and i 6¼ j.
take into account the distribution of employee ranks, the Assuming that the Ri sets satisfy the agents’ requests, we
distribution of salaries, as well as the correlation between the can express the problem as a multicriterion optimization
two attributes. Ensuring that key statistics do not change by problem:
the introduction of fake objects is important if the agents will
be using such statistics in their work. Finally, function maximize ð. . . ; Áði; jÞ; . . .Þ i 6¼ j: ð7Þ
ðover R1 ;...;Rn Þ
CREATEFAKEOBJECT() has to be aware of the fake objects Fi
added so far, again to ensure proper statistics. If the optimization problem has an optimal solution, it
The distributor can also use function CREATEFAKEOB- means that there exists an allocation DÃ ¼ fRÃ ; . . . ; RÃ g such
1 n
JECT() when it wants to send the same fake object to a set of that any other feasible allocation D ¼ fR1 ; . . . ; Rn g yields
agents. In this case, the function arguments are the union of Áði; jÞ ! ÁÃ ði; jÞ for all i; j. This means that allocation DÃ


allows the distributor to discern any guilty agent with The max-objective yields the solution that guarantees that
higher confidence than any other allocation, since it the distributor will detect the guilty agent with a certain
maximizes the probability P rfGi jRi g with respect to any confidence in the worst case. Such guarantee may adversely
other probability P rfGi jRj g with j 6¼ i. impact the average performance of the distribution.
Even if there is no optimal allocation DÃ , a multicriterion
problem has Pareto optimal allocations. If Dpo ¼ 7 ALLOCATION STRATEGIES
fRpo ; . . . ; Rpo g is a Pareto optimal allocation, it means that
1 n
there is no other allocation that yields Áði; jÞ ! Ápo ði; jÞ for In this section, we describe allocation strategies that solve
exactly or approximately the scalar versions of (8) for the
all i; j. In other words, if an allocation yields Áði; jÞ !
different instances presented in Fig. 2. We resort to
Ápo ði; jÞ for some i; j, then there is some i0 ; j0 such that
approximate solutions in cases where it is inefficient to
Áði0 ; j0 Þ Ápo ði0 ; j0 Þ. The choice among all the Pareto optimal solve accurately the optimization problem.
allocations implicitly selects the agent(s) we want to identify. In Section 7.1, we deal with problems with explicit data
6.3 Objective Approximation requests, and in Section 7.2, with problems with sample
data requests.
We can approximate the objective of (7) with (8) that does not The proofs of theorems that are stated in the following
depend on agents’ guilt probabilities, and therefore, on p: sections are available in [14].

jRi Rj j 7.1 Explicit Data Requests
maximize . . . ; ;... i 6¼ j: ð8Þ
ðover R1 ;...;Rn Þ jRi j
In problems of class EF , the distributor is not allowed to
This approximation is valid if minimizing the relative add fake objects to the distributed data. So, the data
jRi R j
overlap jRi j j maximizes Áði; jÞ. The intuitive argument for allocation is fully defined by the agents’ data requests.
Therefore, there is nothing to optimize.
this approximation is that the fewer leaked objects set Rj
In EF problems, objective values are initialized by
contains, the less guilty agent Uj will appear compared to Ui agents’ data requests. Say, for example, that T ¼ ft1 ; t2 g
(since S ¼ Ri ). The example of Section 5.2 supports our and there are two agents with explicit data requests such
approximation. In Fig. 1, we see that if S ¼ R1 , the that R1 ¼ ft1 ; t2 g and R2 ¼ ft1 g. The value of the sum-
difference P rfG1 jSg À P rfG2 jSg decreases as the relative objective is in this case
overlap jRjSj increases. Theorem 1 shows that a solution to
2 Sj

X 1 X
2 2
1 1
(7) yields the solution to (8) if each T object is allocated to jRi Rj j ¼ þ ¼ 1:5:
the same number of agents, regardless of who these agents i¼1
jRi j j¼1 2 1
j6¼i
are. The proof of the theorem is in [14].
The distributor cannot remove or alter the R1 or R2 data to
Theorem 1. If a distribution D ¼ fR1 ; . . . ; Rn g that satisfies
jRi R j decrease the overlap R1 R2 . However, say that the
agents’ requests minimizes jRi j j and jVt j ¼ jVt0 j for all t; t0 2
distributor can create one fake object (B ¼ 1) and both
T , then D maximizes Áði; jÞ.
agents can receive one fake object (b1 ¼ b2 ¼ 1). In this case,
The approximate optimization problem has still multiple
the distributor can add one fake object to either R1 or R2 to
criteria and it can yield either an optimal or multiple Pareto
optimal solutions. Pareto optimal solutions let us detect a increase the corresponding denominator of the summation
guilty agent Ui with high confidence, at the expense of an term. Assume that the distributor creates a fake object f and
inability to detect some other guilty agent or agents. Since he gives it to agent R1 . Agent U1 has now R1 ¼ ft1 ; t2 ; fg
the distributor has no a priori information for the agents’ and F1 ¼ ffg and the value of the sum-objective decreases
intention to leak their data, he has no reason to bias the to 1 þ 1 ¼ 1:33 1:5.
3 1
object allocation against a particular agent. Therefore, we If the distributor is able to create more fake objects, he
can scalarize the problem objective by assigning the same could further improve the objective. We present in
weights to all vector objectives. We present two different Algorithms 1 and 2 a strategy for randomly allocating fake
scalar versions of our problem in (9a) and (9b). In the rest of objects. Algorithm 1 is a general “driver” that will be used
the paper, we will refer to objective (9a) as the sum-objective by other strategies, while Algorithm 2 actually performs
and to objective (9b) as the max-objective: the random selection. We denote the combination of
Algorithm 1 with 2 as e-random. We use e-random as our
X 1 X
n n baseline in our comparisons with other algorithms for
maximize jRi Rj j; ð9aÞ explicit data requests.
ðover R1 ;...;Rn Þ
i¼1
jRi j j¼1
j6¼i
Algorithm 1. Allocation for Explicit Data Requests (EF )
jRi Rj j
maximize max : ð9bÞ Input: R1 ; . . . ; Rn , cond1 ; . . . ; condn , b1 ; . . . ; bn , B
ðover R1 ;...;Rn Þ i;j¼1;...;n
j6¼i
jRi j Output: R1 ; . . . ; Rn , F1 ; . . . ; Fn
Both scalar optimization problems yield the optimal 1: R ; . Agents that can receive fake objects
solution of the problem of (8), if such solution exists. If 2: for i ¼ 1; . . . ; n do
there is no global optimal solution, the sum-objective yields 3: if bi 0 then
the Pareto optimal solution that allows the distributor to 4: R R [ fig
detect the guilty agent, on average (over all different 5: Fi ;
agents), with higher confidence than any other distribution. 6: while B 0 do


7: i SELECTAGENTðR; R1 ; . . . ; Rn Þ 7.2 Sample Data Requests
8: f CREATEFAKEOBJECTðRi ; Fi ; condi Þ With sample data requests, each agent Ui may receive any T
Q
9: Ri Ri [ ffg subset out of ðjT ijÞ different ones. Hence, there are n ðjT ijÞ
m i¼1 m
10: Fi Fi [ ffg different object allocations. In every allocation, the dis-
11: bi bi À 1 tributor can permute T objects and keep the same chances
12: if bi ¼ 0then of guilty agent detection. The reason is that the guilt
13: R RnfRi g probability depends only on which agents have received the
14: B BÀ1 leaked objects and not on the identity of the leaked objects.
Therefore, from the distributor’s perspective, there are
Algorithm 2. Agent Selection for e-random Qn jT j
1: function SELECTAGENT (R; R1 ; . . . ; Rn ) i¼1 ð mi Þ
2: i select at random an agent from R jT j!
3: return i
different allocations. The distributor’s problem is to pick
In lines 1-5, Algorithm 1 finds agents that are eligible to one out so that he optimizes his objective. In [14], we
receiving fake objects in OðnÞ time. Then, in the main loop formulate the problem as a nonconvex QIP that is NP-hard
in lines 6-14, the algorithm creates one fake object in every to solve [15].
iteration and allocates it to random agent. The main loop Note that the distributor can increase the number of
takes OðBÞ time. Hence, the running time of the algorithm possible allocations by adding fake objects (and increasing
is Oðn þ BÞ. jT j) but the problem is essentially the same. So, in the rest of
P
If B ! n bi , the algorithm minimizes every term of the
i¼1
this section, we will only deal with problems of class SF ,
objective summation by adding the maximum number bi of but our algorithms are applicable to SF problems as well.
fake objects to every set Ri , yielding the optimal solution.
P 7.2.1 Random
Otherwise, if B n bi (as in our example where
i¼1
B ¼ 1 b1 þ b2 ¼ 2), the algorithm just selects at random An object allocation that satisfies requests and ignores the
distributor’s objective is to give each agent Ui a randomly
the agents that are provided with fake objects. We return
selected subset of T of size mi . We denote this algorithm by
back to our example and see how the objective would
s-random and we use it as our baseline. We present s-random
change if the distributor adds fake object f to R2 instead of
in two parts: Algorithm 4 is a general allocation algorithm
R1 . In this case, the sum-objective would be 1 þ 1 ¼ 1 1:33.
2 2 that is used by other algorithms in this section. In line 6 of
The reason why we got a greater improvement is that the Algorithm 4, there is a call to function SELECTOBJECT()
addition of a fake object to R2 has greater impact on the whose implementation differentiates algorithms that rely on
corresponding summation terms, since Algorithm 4. Algorithm 5 shows function SELECTOBJECT()
1 1 1 1 1 1 for s-random.
À ¼ À ¼ :
jR1 j jR1 j þ 1 6 jR2 j jR2 j þ 1 2 Algorithm 4. Allocation for Sample Data Requests (SF )
The left-hand side of the inequality corresponds to the Input: m1 ; . . . ; mn , jT j . Assuming mi jT j
objective improvement after the addition of a fake object to Output: R1 ; . . . ; Rn
1: a 0jT j . a½kŠ:number of agents who have
R1 and the right-hand side to R2 . We can use this
received object tk
observation to improve Algorithm 1 with the use of
2: R1 ;; . . . ; Rn ;
procedure SELECTAGENT() of Algorithm 3. We denote the Pn
3: remaining i¼1 mi
combination of Algorithms 1 and 3 by e-optimal.
4: while remaining 0 do
Algorithm 3. Agent Selection for e-optimal 5: for all i ¼ 1; . . . ; n : jRi j mi do
1: function SELECTAGENT (R; R1 ; . . . ; Rn ) 6: k SELECTOBJECTði; Ri Þ . May also use
X additional parameters
1 1
2: i argmax À jRi0 Rj j 7: Ri Ri [ ftk g
i0 :Ri0 2R jRi0 j jRi0 j þ 1 j 8: a½kŠ a½kŠ þ 1
3: return i 9: remaining remaining À 1
Algorithm 3 makes a greedy choice by selecting the agent
Algorithm 5. Object Selection for s-random
that will yield the greatest improvement in the sum-
1: function SELECTOBJECTði; Ri Þ
objective. The cost of this greedy choice is Oðn2 Þ in every
2: k select at random an element from set
iteration. The overall running time of e-optimal is fk0 j tk0 62 Ri g
Oðn þ n2 BÞ ¼ Oðn2 BÞ. Theorem 2 shows that this greedy 3: return k
approach finds an optimal distribution with respect to both
In s-random, we introduce vector a 2 N jT j that shows the
N
optimization objectives defined in (9).
object sharing distribution. In particular, element a½kŠ shows
Theorem 2. Algorithm e-optimal yields an object allocation that the number of agents who receive object tk .
minimizes both sum- and max-objective in problem instances Algorithm s-random allocates objects to agents in a
of class EF . round-robin fashion. After the initialization of vectors d and


P
a in lines 1 and 2 of Algorithm 4, the main loop in lines 4-9 the sum of overlaps, i.e., nj¼1 jRi Rj j. If requests are all
i; j6¼i
is executed while there are still data objects (remaining 0) of the same size (m1 ¼ Á Á Á ¼ mn ), then s-overlap minimizes
to be allocated to agents. In each iteration of this loop the sum-objective.
(lines 5-9), the algorithm uses function SELECTOBJECT() to
find a random object to allocate to agent Ui . This loop To illustrate that s-overlap does not minimize the sum-
iterates over all agents who have not received the number of objective, assume that set T has four objects and there are
data objects they have requested. P four agents requesting samples with sizes m1 ¼ m2 ¼ 2 and
The running time of the algorithm is Oð n mi Þ and
i¼1 m3 ¼ m4 ¼ 1. A possible data allocation from s-overlap is
depends on the running time of the object selection
function SELECTOBJECT(). In case of random selection, we R1 ¼ ft1 ; t2 g; R2 ¼ ft3 ; t4 g; R3 ¼ ft1 g; R4 ¼ ft3 g:
can have ¼ Oð1Þ by keeping in memory a set fk0 j tk0 62 Ri g ð10Þ
for each agent Ui .
Allocation (10) yields:
Algorithm s-random may yield a poor data allocation.
Say, for example, that the distributor set T has three objects X 1 X
4 4
1 1 1 1
and there are three agents who request one object each. It is jRi Rj j ¼ þ þ þ ¼ 3:
jRi j j¼1 2 2 1 1
possible that s-random provides all three agents with the i¼1
j6¼i

same object. Such an allocation maximizes both objectives
(9a) and (9b) instead of minimizing them. With this allocation, we see that if agent U3 leaks his data,
we will equally suspect agents U1 and U3 . Moreover, if
7.2.2 Overlap Minimization agent U1 leaks his data, we will suspect U3 with high
In the last example, the distributor can minimize both probability, since he has half of the leaked data. The
objectives by allocating distinct sets to all three agents. Such situation is similar for agents U2 and U4 .
an optimal allocation is possible, since agents request in However, the following object allocation
total fewer objects than the distributor has.
R1 ¼ ft1 ; t2 g; R2 ¼ ft1 ; t2 g; R3 ¼ ft3 g; R4 ¼ ft4 g ð11Þ
We can achieve such an allocation by using Algorithm 4
and SELECTOBJECT() of Algorithm 6. We denote the yields a sum-objective equal to 2 þ 2 þ 0 þ 0 ¼ 2 3, which
2 2
resulting algorithm by s-overlap. Using Algorithm 6, in shows that the first allocation is not optimal. With this
each iteration of Algorithm 4, we provide agent Ui with an allocation, we will equally suspect agents U1 and U2 if either
object that has been given to the smallest number of agents. of them leaks his data. However, if either U3 or U4 leaks his
So, if agents ask for fewer objects than jT j, Algorithm 6 will data, we will detect him with high confidence. Hence, with
return in every iteration an object that no agent has received the second allocation we have, on average, better chances of
so far. Thus, every agent will receive a data set with objects detecting a guilty agent.
that no other agent has.
7.2.3 Approximate Sum-Objective Minimization
Algorithm 6. Object Selection for s-overlap The last example showed that we can minimize the sum-
1: function SELECTOBJECT (i; Ri ; a) objective, and therefore, increase the chances of detecting a
2: K fk j k ¼ argmin a½k0 Šg guilty agent, on average, by providing agents who have
k0 small requests with the objects shared among the fewest
3: k select at random an element from set agents. This way, we improve our chances of detecting
fk0 j k0 2 K ^ tk0 62 Ri g guilty agents with small data requests, at the expense of
4: return k reducing our chances of detecting guilty agents with large
data requests. However, this expense is small, since the
The running time of Algorithm 6 is Oð1Þ if we keep in probability to detect a guilty agent with many objects is less
memory the set fkjk ¼ argmink0 a½k0 Šg. This set contains affected by the fact that other agents have also received his
initially all indices f1; . . . ; jT jg, since a½kŠ ¼ 0 for all data (see Section 5.2). In [14], we provide an algorithm that
k ¼ 1; . . . ; jT j. After every Algorithm 4 main loop iteration, implements this intuition and we denote it by s-sum.
we remove from this set the index of the object that we give Although we evaluate this algorithm in Section 8, we do not
to an agent. After jT j iterations, this set becomes empty and present the pseudocode here due to the space limitations.
we have to reset it again to f1; . . . ; jT jg, since at this point, 7.2.4 Approximate Max-Objective Minimization
a½kŠ ¼ 1 for all k ¼ 1; . . . ; jT j. The total running time of Algorithm s-overlap is optimal for the max-objective
P P
algorithm s-random is thus Oð n mi Þ.
Pn i¼1 optimization only if n mi jT j. Note also that s-sum as
i
Let M ¼ i¼1 mi . If M jT j, algorithm s-overlap yields well as s-random ignore this objective. Say, for example, that
disjoint data sets and is optimal for both objectives (9a) and set T contains for objects and there are four agents, each
(9b). If M jT j, it can be shown that algorithm s-random requesting a sample of two data objects. The aforementioned
yields an object sharing distribution such that: algorithms may produce the following data allocation:

M Ä jT j þ 1 for M mod jT j entries of vector a; R1 ¼ ft1 ; t2 g; R2 ¼ ft1 ; t2 g; R3 ¼ ft3 ; t4 g; and
a½kŠ ¼
M Ä jT j for the rest: R4 ¼ ft3 ; t4 g:
Theorem 3. In general, Algorithm s-overlap does not Although such an allocation minimizes the sum-objective, it
minimize sum-objective. However, s-overlap does minimize allocates identical sets to two agent pairs. Consequently, if


an agent leaks his values, he will be equally guilty with an optimization problem of (7). In this section, we evaluate the
innocent agent. presented algorithms with respect to the original problem.
To improve the worst-case behavior, we present a new In this way, we measure not only the algorithm perfor-
algorithm that builds upon Algorithm 4 that we used in mance, but also we implicitly evaluate how effective the
s-random and s-overlap. We define a new SELECTOBJECT() approximation is.
procedure in Algorithm 7. We denote the new algorithm by The objectives in (7) are the Á difference functions. Note
s-max. In this algorithm, we allocate to an agent the object that there are nðn À 1Þ objectives, since for each agent Ui ,
that yields the minimum increase of the maximum relative there are n À 1 differences Áði; jÞ for j ¼ 1; . . . ; n and j 6¼ i.
overlap among any pair of agents. If we apply s-max to the We evaluate a given allocation with the following objective
example above, after the first five main loop iterations in
scalarizations as metrics:
Algorithm 4, the Ri sets are:
P
i;j¼1;...;n Áði; jÞ
R1 ¼ ft1 ; t2 g; R2 ¼ ft2 g; R3 ¼ ft3 g; and R4 ¼ ft4 g: Á :¼ i6¼j
; ð12aÞ
nðn À 1Þ
In the next iteration, function SELECTOBJECT() must decide
min Á :¼ min Áði; jÞ: ð12bÞ
which object to allocate to agent U2 . We see that only objects i;j¼1;...;n
i6¼j
t3 and t4 are good candidates, since allocating t1 to U2 will
yield a full overlap of R1 and R2 . Function SELECTOBJECT() Metric Á is the average of Áði; jÞ values for a given
of s-max returns indeed t3 or t4 . allocation and it shows how successful the guilt detection is,
on average, for this allocation. For example, if Á ¼ 0:4, then,
Algorithm 7. Object Selection for s-max
on average, the probability P rfGi jRi g for the actual guilty
1: function SELECTOBJECT (i; R1 ; . . . ; Rn ; m1 ; . . . ; mn )
agent will be 0.4 higher than the probabilities of nonguilty
2: min overlap 1 . the minimum out of the
agents. Note that this scalar version of the original problem
maximum relative overlaps that the allocations of
objective is analogous to the sum-objective scalarization of
different objects to Ui yield the problem of (8). Hence, we expect that an algorithm that
3: for k 2 fk0 j tk0 62 Ri g do is designed to minimize the sum-objective will maximize Á.
4: max rel ov 0 . the maximum relative overlap Metric min Á is the minimum Áði; jÞ value and it
between Ri and any set Rj that the allocation of tk to Ui corresponds to the case where agent Ui has leaked his data
yields and both Ui and another agent Uj have very similar guilt
5: for all j ¼ 1; . . . ; n : j 6¼ i and tk 2 Rj do probabilities. If min Á is small, then we will be unable to
6: abs ov jRi Rj j þ 1 identify Ui as the leaker, versus Uj . If min Á is large, say, 0.4,
7: rel ov abs ov=minðmi ; mj Þ then no matter which agent leaks his data, the probability
8: max rel ov Maxðmax rel ov; rel ovÞ that he is guilty will be 0.4 higher than any other nonguilty
9: if max rel ov min overlap then agent. This metric is analogous to the max-objective
10: min overlap max rel ov scalarization of the approximate optimization problem.
11: ret k k The values for these metrics that are considered
12: return ret k acceptable will of course depend on the application. In
particular, they depend on what might be considered high
The running time of SELECTOBJECT() is OðjT jnÞ, since the
confidence that an agent is guilty. For instance, say that
external loop in lines 3-12 iterates over all objects that
agent Ui has not received and the internal loop in lines 5-8 P rfGi jRi g ¼ 0:9 is enough to arouse our suspicion that
over all agents. This running time calculation implies that agent Ui leaked data. Furthermore, say that the difference
we keep the overlap sizes Ri Rj for all agents in a two- between P rfGi jRi g and any other P rfGj jRi g is at least 0.3.
dimensional array that we update after every object In other words, the guilty agent is ð0:9 À 0:6Þ=0:6 Â 100% ¼
allocation. 50% more likely to be guilty compared to the other agents.
It can be shown that algorithm s-max is optimal for the In this case, we may be willing to take action against Ui (e.g.,
sum-objective and the max-objective in problems where stop doing business with him, or prosecute him). In the rest
M jT j. It is also optimal for the max-objective if jT j of this section, we will use value 0.3 as an example of what
M 2jT j or m1 ¼ m2 ¼ Á Á Á ¼ mn . might be desired in Á values.
To calculate the guilt probabilities and Á differences, we
use throughout this section p ¼ 0:5. Although not reported
8 EXPERIMENTAL RESULTS here, we experimented with other p values and observed
We implemented the presented allocation algorithms in that the relative performance of our algorithms and our
Python and we conducted experiments with simulated main conclusions do not change. If p approaches to 0, it
data leakage problems to evaluate their performance. In becomes easier to find guilty agents and algorithm
Section 8.1, we present the metrics we use for the performance converges. On the other hand, if p approaches
algorithm evaluation, and in Sections 8.2 and 8.3, we 1, the relative differences among algorithms grow since
present the evaluation for sample requests and explicit more evidence is needed to find an agent guilty.
data requests, respectively.
8.2 Explicit Requests
8.1 Metrics In the first place, the goal of these experiments was to see
In Section 7, we presented algorithms to optimize the whether fake objects in the distributed data sets yield
problem of (8) that is an approximation to the original significant improvement in our chances of detecting a


Fig. 3. Evaluation of explicit data request algorithms. (a) Average Á. (b) Average minÁ.

guilty agent. In the second place, we wanted to evaluate improves Á further, since the e-optimal curve is consistently
our e-optimal algorithm relative to a random allocation. over the 95 percent confidence intervals of e-random. The
We focus on scenarios with a few objects that are shared performance difference between the two algorithms would
among multiple agents. These are the most interesting be greater if the agents did not request the same number of
scenarios, since object sharing makes it difficult to distin- objects, since this symmetry allows nonsmart fake object
guish a guilty from nonguilty agents. Scenarios with more allocations to be more effective than in asymmetric
objects to distribute or scenarios with objects shared among scenarios. However, we do not study more this issue here,
fewer agents are obviously easier to handle. As far as since the advantages of e-optimal become obvious when we
scenarios with many objects to distribute and many over- look at our second metric.
lapping agent requests are concerned, they are similar to the Fig. 3b shows the value of min Á, as a function of the
scenarios we study, since we can map them to the fraction of fake objects. The plot shows that random
distribution of many small subsets. allocation will yield an insignificant improvement in our
In our scenarios, we have a set of jT j ¼ 10 objects for chances of detecting a guilty agent in the worst-case
which there are requests by n ¼ 10 different agents. We scenario. This was expected, since e-random does not take
assume that each agent requests eight particular objects out into consideration which agents “must” receive a fake
of these 10. Hence, each object is shared, on average, among object to differentiate their requests from other agents. On
Pn the contrary, algorithm e-optimal can yield min Á 0:3
i¼1 jRi j
¼8 with the allocation of approximately 10 percent fake
jT j
objects. This improvement is very important taking into
agents. Such scenarios yield very similar agent guilt account that without fake objects, values min Á and Á
probabilities and it is important to add fake objects. We are close to 0. This means that by allocating 10 percent of
generated a random scenario that yielded Á ¼ 0:073 and fake objects, the distributor can detect a guilty agent even
min Á ¼ 0:35 and we applied the algorithms e-random and in the worst-case leakage scenario, while without fake
e-optimal to distribute fake objects to the agents (see [14] for objects, he will be unsuccessful not only in the worst case
other randomly generated scenarios with the same para- but also in average case.
meters). We varied the number B of distributed fake objects Incidentally, the two jumps in the e-optimal curve are
from 2 to 20, and for each value of B, we ran both due to the symmetry of our scenario. Algorithm e-optimal
algorithms to allocate the fake objects to agents. We ran e- allocates almost one fake object per agent before allocating a
optimal once for each value of B, since it is a deterministic second fake object to one of them.
algorithm. Algorithm e-random is randomized and we ran The presented experiments confirmed that fake objects
it 10 times for each value of B. The results we present are can have a significant impact on our chances of detecting a
the average over the 10 runs. guilty agent. Note also that the algorithm evaluation was on
Fig. 3a shows how fake object allocation can affect Á. the original objective. Hence, the superior performance of e-
There are three curves in the plot. The solid curve is optimal (which is optimal for the approximate objective)
constant and shows the Á value for an allocation without indicates that our approximation is effective.
fake objects (totally defined by agents’ requests). The other
two curves look at algorithms e-optimal and e-random. The 8.3 Sample Requests
y-axis shows Á and the x-axis shows the ratio of the number With sample data requests, agents are not interested in
of distributed fake objects to the total number of objects that particular objects. Hence, object sharing is not explicitly
the agents explicitly request. defined by their requests. The distributor is “forced” to
We observe that distributing fake objects can signifi- allocate certain objects to multiple agents only if the number
P
cantly improve, on average, the chances of detecting a guilty of requested objects n mi exceeds the number of objects
i¼1
agent. Even the random allocation of approximately 10 to in set T . The more data objects the agents request in total,
15 percent fake objects yields Á 0:3. The use of e-optimal the more recipients, on average, an object has; and the more


Fig. 4. Evaluation of sample data request algorithms. (a) Average Á. (b) Average P rfGi jSi g. (c) Average minÁ.

objects are shared among different agents, the more difficult In Fig. 4a, we plot the values Á that we found in our
it is to detect a guilty agent. Consequently, the parameter scenarios. There are four curves, one for each algorithm.
that primarily defines the difficulty of a problem with The x-coordinate of a curve point shows the ratio of the total
sample data requests is the ratio number of requested objects to the number of T objects for
Pn the scenario. The y-coordinate shows the average value of Á
i¼1 mi over all 10 runs. Thus, the error bar around each point
:
jT j shows the 95 percent confidence interval of Á values in the
We call this ratio the load. Note also that the absolute values of 10 different runs. Note that algorithms s-overlap, s-sum,
m1 ; . . . ; mn and jT j play a less important role than the relative and s-max yield Á values that are close to 1 if agents
values mi =jT j. Say, for example, that T ¼ 99 and algorithm X request in total fewer objects than jT j. This was expected
yields a good allocation for the agents’ requests m1 ¼ 66 and since in such scenarios, all three algorithms yield disjoint set
m2 ¼ m3 ¼ 33. Note that for any jT j and m1 =jT j ¼ 2=3, allocations, which is the optimal solution. In all scenarios,
m2 =jT j ¼ m3 =jT j ¼ 1=3, the problem is essentially similar algorithm s-sum outperforms the other ones. Algorithms
and algorithm X would still yield a good allocation. s-overlap and s-max yield similar Á values that are between
In our experimental scenarios, set T has 50 objects and s-sum and s-random. All algorithms have Á around 0.5 for
we vary the load. There are two ways to vary this number: load ¼ 4:5, which we believe is an acceptable value.
1) assume that the number of agents is fixed and vary their Note that in Fig. 4a, the performances of all algorithms
sample sizes mi , and 2) vary the number of agents who appear to converge as the load increases. This is not true and
request data. The latter choice captures how a real problem we justify that using Fig. 4b, which shows the average guilt
may evolve. The distributor may act to attract more or fewer probability in each scenario for the actual guilty agent. Every
agents for his data, but he does not have control upon curve point shows the mean over all 10 algorithm runs and
agents’ requests. Moreover, increasing the number of agents we have omitted confidence intervals to make the plot easy
allows us also to increase arbitrarily the value of the load, to read. Note that the guilt probability for the random
while varying agents’ requests poses an upper bound njT j. allocation remains significantly higher than the other
Our first scenario includes two agents with requests m1 algorithms for large values of the load. For example, if
and m2 that we chose uniformly at random from the load % 5:5, algorithm s-random yields, on average, guilt
interval 6; . . . ; 15. For this scenario, we ran each of the probability 0.8 for a guilty agent and 0:8 À Á ¼ 0:35 for
algorithms s-random (baseline), s-overlap, s-sum, and nonguilty agent. Their relative difference is 0:8À0:35 % 1:3. The
0:35
s-max 10 different times, since they all include randomized corresponding probabilities that s-sum yields are 0.75 and
steps. For each run of every algorithm, we calculated Á and 0.25 with relative difference 0:75À0:25 ¼ 2. Despite the fact that
minÁ and the average over the 10 runs. The second 0:25
the absolute values of Á converge the relative differences in
scenario adds agent U3 with m3 $ U½6; 15Š to the two agents
the guilt probabilities between a guilty and nonguilty agents
of the first scenario. We repeated the 10 runs for each
are significantly higher for s-max and s-sum compared to
algorithm to allocate objects to three agents of the second
scenario and calculated the two metrics values for each run. s-random. By comparing the curves in both figures, we
We continued adding agents and creating new scenarios to conclude that s-sum outperforms other algorithms for small
reach the number of 30 different scenarios. The last one had load values. As the number of objects that the agents request
31 agents. Note that we create a new scenario by adding an increases, its performance becomes comparable to s-max. In
agent with a random request mi $ U½6; 15Š instead of such cases, both algorithms yield very good chances, on
assuming mi ¼ 10 for the new agent. We did that to avoid average, of detecting a guilty agent. Finally, algorithm
studying scenarios with equal agent sample request s-overlap is inferior to them, but it still yields a significant
sizes, where certain algorithms have particular properties, improvement with respect to the baseline.
e.g., s-overlap optimizes the sum-objective if requests are all In Fig. 4c, we show the performance of all four
the same size, but this does not hold in the general case. algorithms with respect to minÁ metric. This figure is


similar to Fig. 4a and the only change is the y-axis. ACKNOWLEDGMENTS
Algorithm s-sum now has the worst performance among
This work was supported by the US National Science
all the algorithms. It allocates all highly shared objects to
Foundation (NSF) under Grant no. CFF-0424422 and an
agents who request a large sample, and consequently, these
Onassis Foundation Scholarship. The authors would like to
agents receive the same object sets. Two agents Ui and Uj
thank Paul Heymann for his help with running the
who receive the same set have Áði; jÞ ¼ Áðj; iÞ ¼ 0. So, if
nonpolynomial guilt model detection algorithm that they
either of Ui and Uj leaks his data, we cannot distinguish
present in [14, Appendix] on a Hadoop cluster. They also
which of them is guilty. Random allocation has also poor
thank Ioannis Antonellis for fruitful discussions and his
performance, since as the number of agents increases, the
comments on earlier versions of this paper.
probability that at least two agents receive many common
objects becomes higher. Algorithm s-overlap limits the
random allocation selection among the allocations who REFERENCES
achieve the minimum absolute overlap summation. This [1] R. Agrawal and J. Kiernan, “Watermarking Relational Databases,”
fact improves, on average, the min Á values, since the Proc. 28th Int’l Conf. Very Large Data Bases (VLDB ’02), VLDB
smaller absolute overlap reduces object sharing, and Endowment, pp. 155-166, 2002.
[2] P. Bonatti, S.D.C. di Vimercati, and P. Samarati, “An Algebra for
consequently, the chances that any two agents receive sets Composing Access Control Policies,” ACM Trans. Information and
with many common objects. System Security, vol. 5, no. 1, pp. 1-35, 2002.
Algorithm s-max, which greedily allocates objects to [3] P. Buneman, S. Khanna, and W.C. Tan, “Why and Where: A
Characterization of Data Provenance,” Proc. Eighth Int’l Conf.
optimize max-objective, outperforms all other algorithms Database Theory (ICDT ’01), J.V. den Bussche and V. Vianu, eds.,
and is the only that yields min Á 0:3 for high values of
Pn pp. 316-330, Jan. 2001.
i¼1 mi . Observe that the algorithm that targets at sum-
[4] P. Buneman and W.-C. Tan, “Provenance in Databases,” Proc.
objective minimization proved to be the best for the Á ACM SIGMOD, pp. 1171-1173, 2007.
[5] Y. Cui and J. Widom, “Lineage Tracing for General Data
maximization and the algorithm that targets at max- Warehouse Transformations,” The VLDB J., vol. 12, pp. 41-58,
objective minimization was the best for minÁ maximiza- 2003.
tion. These facts confirm that the approximation of objective [6] S. Czerwinski, R. Fromm, and T. Hodes, “Digital Music Distribu-
tion and Audio Watermarking,” http://www.scientificcommons.
(7) with (8) is effective. org/43025658, 2007.
[7] F. Guo, J. Wang, Z. Zhang, X. Ye, and D. Li, “An Improved
Algorithm to Watermark Numeric Relational Data,” Information
9 CONCLUSIONS Security Applications, pp. 138-149, Springer, 2006.
[8] F. Hartung and B. Girod, “Watermarking of Uncompressed and
In a perfect world, there would be no need to hand over
Compressed Video,” Signal Processing, vol. 66, no. 3, pp. 283-301,
sensitive data to agents that may unknowingly or mal- 1998.
iciously leak it. And even if we had to hand over sensitive [9] S. Jajodia, P. Samarati, M.L. Sapino, and V.S. Subrahmanian,
data, in a perfect world, we could watermark each object so “Flexible Support for Multiple Access Control Policies,” ACM
Trans. Database Systems, vol. 26, no. 2, pp. 214-260, 2001.
that we could trace its origins with absolute certainty. [10] Y. Li, V. Swarup, and S. Jajodia, “Fingerprinting Relational
However, in many cases, we must indeed work with agents Databases: Schemes and Specialties,” IEEE Trans. Dependable and
that may not be 100 percent trusted, and we may not be Secure Computing, vol. 2, no. 1, pp. 34-45, Jan.-Mar. 2005.
certain if a leaked object came from an agent or from some [11] B. Mungamuru and H. Garcia-Molina, “Privacy, Preservation and
Performance: The 3 P’s of Distributed Data Management,”
other source, since certain data cannot admit watermarks. technical report, Stanford Univ., 2008.
In spite of these difficulties, we have shown that it is [12] V.N. Murty, “Counting the Integer Solutions of a Linear Equation
possible to assess the likelihood that an agent is responsible with Unit Coefficients,” Math. Magazine, vol. 54, no. 2, pp. 79-81,
1981.
for a leak, based on the overlap of his data with the leaked [13] S.U. Nabar, B. Marthi, K. Kenthapadi, N. Mishra, and R. Motwani,
data and the data of other agents, and based on the “Towards Robustness in Query Auditing,” Proc. 32nd Int’l Conf.
probability that objects can be “guessed” by other means. Very Large Data Bases (VLDB ’06), VLDB Endowment, pp. 151-162,
Our model is relatively simple, but we believe that it 2006.
[14] P. Papadimitriou and H. Garcia-Molina, “Data Leakage Detec-
captures the essential trade-offs. The algorithms we have tion,” technical report, Stanford Univ., 2008.
presented implement a variety of data distribution strate- [15] P.M. Pardalos and S.A. Vavasis, “Quadratic Programming with
gies that can improve the distributor’s chances of identify- One Negative Eigenvalue Is NP-Hard,” J. Global Optimization,
vol. 1, no. 1, pp. 15-22, 1991.
ing a leaker. We have shown that distributing objects [16] J.J.K.O. Ruanaidh, W.J. Dowling, and F.M. Boland, “Watermark-
judiciously can make a significant difference in identifying ing Digital Images for Copyright Protection,” IEE Proc. Vision,
guilty agents, especially in cases where there is large Signal and Image Processing, vol. 143, no. 4, pp. 250-256, 1996.
overlap in the data that agents must receive. [17] R. Sion, M. Atallah, and S. Prabhakar, “Rights Protection for
Relational Data,” Proc. ACM SIGMOD, pp. 98-109, 2003.
Our future work includes the investigation of agent [18] L. Sweeney, “Achieving K-Anonymity Privacy Protection Using
guilt models that capture leakage scenarios that are not Generalization and Suppression,” http://en.scientificcommons.
studied in this paper. For example, what is the appropriate org/43196131, 2002.
model for cases where agents can collude and identify fake
tuples? A preliminary discussion of such a model is
available in [14]. Another open problem is the extension of
our allocation strategies so that they can handle agent
requests in an online fashion (the presented strategies
assume that there is a fixed set of agents with requests
known in advance).


Panagiotis Papadimitriou received the diplo- Hector Garcia-Molina received the BS degree
ma degree in electrical and computer engi- in electrical engineering from the Instituto
neering from the National Technical University Tecnologico de Monterrey, Mexico, in 1974,
of Athens in 2006 and the MS degree in and the MS degree in electrical engineering and
electrical engineering from Stanford University the PhD degree in computer science from
in 2008. He is currently working toward the Stanford University, California, in 1975 and
PhD degree in the Department of Electrical 1979, respectively. He is the Leonard Bosack
Engineering at Stanford University, California. and Sandra Lerner professor in the Departments
His research interests include Internet adver- of Computer Science and Electrical Engineering
tising, data mining, data privacy, and web at Stanford University, California. He was the
search. He is a student member of the IEEE. chairman of the Computer Science Department from January 2001 to
December 2004. From 1997 to 2001, he was a member of the
President’s Information Technology Advisory Committee (PITAC). From
August 1994 to December 1997, he was the director of the Computer
Systems Laboratory at Stanford. From 1979 to 1991, he was in the
Faculty of the Computer Science Department at Princeton University,
New Jersey. His research interests include distributed computing
systems, digital libraries, and database systems. He holds an honorary
PhD degree from ETH Zurich in 2007. He is a fellow of the ACM and the
American Academy of Arts and Sciences and a member of the National
Academy of Engineering. He received the 1999 ACM SIGMOD
Innovations Award. He is a venture advisor for Onset Ventures and is
a member of the Board of Directors of Oracle. He is a member of the
IEEE and the IEEE Computer Society.

. For more information on this or any other computing topic,
please visit our Digital Library at www.computer.org/publications/dlib.

Jpdcs1(data lekage detection)

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to Jpdcs1(data lekage detection) (20)

More from Chaitanya Kn (15)

Recently uploaded (20)

Jpdcs1(data lekage detection)