{'fraction_non_alphanumeric': 0.04552976430072901, 'fraction_numerical': 0.010465584328458339, 'mean_word_length': 3.9966480446927375, 'pattern_counts': {'":': 0, '<': 3, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 32, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Optimizing Affine Maximizer Auctions via Linear Programming: an Application to Revenue Maximizing Mechanism Design for Zero-Day Exploits Markets

Optimizing within the affine maximizer auctions (AMA) is an effective approach for revenue maximizing mechanism design. The AMA mechanisms are strategy-proof and individually rational (if the agents' valuations for the outcomes are nonnegative). Every AMA mechanism is characterized by a list of parameters. By focusing on the AMA mechanisms, we turn mechanism design into a value optimization problem, where we only need to adjust the parameters. We propose a linear programming based heuristic for optimizing within the AMA family. We apply our technique to revenue maximizing mechanism design for zero-day exploit markets. We show that due to the nature of the zero-day exploit markets, if there are only two agents (one offender and one defender), then our technique generally produces a near optimal mechanism: the mechanism's expected revenue is close to the optimal revenue achieved by the optimal strategy-proof and individually rational mechanism (not necessarily an AMA mechanism).


Introduction
Revenue maximizing mechanism design is a fundamental topic in algorithmic game theory. Myerson [17] solved for the revenue maximizing mechanism for selling a single item, subject to a technical condition called the monotone hazard rate condition. Myerson's optimal auction is surprisingly elegant. For example, if every agent's type is drawn from an identical and independent distribution, then the optimal mechanism is simply the Vickrey auction [20] with a reserve price. Unfortunately, Myerson's technique does not generalize to more complex settings. For example, when it comes to combinatorial auctions (auctions where multiple items are for sale, and the agents bid on bundles of items), revenue maximizing mechanism design remains an open problem. Another notable application domain of revenue maximizing mechanism design is the sponsored search auctions [13], where the search engines sell advertisement slots to advertisers, aiming to maximize revenue besides other objectives. Even though no optimal mechanisms have been derived for general combinatorial auctions or sponsored search auctions, for restricted domains, well performing mechanisms have been obtained based on a variety of revenue-boosting techniques [6,10,11,15,16].
There are several general revenue-boosting techniques. For example, we may artificially increase the winning chance of lower bidders, in order to drive up the competition faced by the higher bidders. As another example, we may artificially discourage or outright ban certain outcomes, in order to prevent low-revenue outcomes or force the agents to pay more to achieve the discouraged outcomes. The above techniques form the basis of a family of mechanisms called the affine maximizer auctions (AMA). Lavi et al. [14] conjectured that a combinatorial auction is truthful if and only if it is an AMA mechanism, subject to technical conditions. Likhodedov and Sandholm [15,16] studied revenue maximizing combinatorial auction design by optimizing within the family of AMA mechanisms. The idea of optimizing within the AMA family is a general approach that can be applied to many different mechanism design settings, because generally the AMA mechanisms are well defined and the family contains a large number of mechanisms. By optimizing within the AMA family, there is a good chance of reaching a well-performing mechanism in terms of revenue. However, the issue with optimizing within the AMA family is that every AMA mechanism is characterized by |O| + n parameters, where |O| is the size of the outcome space O, and n is the number of agents. For combinatorial auctions, |O| is exponential in the number of items, which makes it computationally impractical to optimize within the AMA family for this setting. Due to this, Likhodedov and Sandholm only studied the AMA family for the case of selling two items. When there are only two items, the number of parameters is small enough for the authors to conduct optimization via grid-based gradient descent. 3 In this paper, we propose a linear programming based technique for optimizing within the AMA family. Every outcome corresponds to one variable in our LP model. As a result, our technique can handle reasonably large number of outcomes. For example, let us consider the case where |O| is a few hundred. Running a LP with a few hundred variables is computationally tractable. On the other hand, methods such as grid-based gradient descent are impractical.
We apply our new technique to a specific mechanism design problem. Our paper focuses on revenue maximizing mechanism design for zero-day exploit markets [12]. Zero-day exploits refer to software vulnerabilities that are not known to the software vendor. Trading zero-day exploits as legitimate business is a recent trend in the security industry [5]. According to a price list collected by Greenberg [9], the price of a zero-day exploit is between $5000 to $250,000. There are venture capital backed security consulting companies whose business model is selling zero-day exploits [7]. One of the companies mentioned in [7] even offered one point five million US dollars for one new iOS exploit. The reason an exploit can be priced so high is that generally it can stay alive for a long period of time [2]. Unless the software vendor is informed about an exploit, there is very low chance for an exploit to be discovered independently. To remedy this, software vendors often run bug bounty programs, which are markets where the software vendors buy exploits from security researchers [1,19].
Guo et al. [12] proposed a formal mechanism design model for zero-day exploit markets. In the authors' model, one exploit is being sold to multiple buyers over a period of time [0, 1]. The model is different from the classic single-item auction for the following reasons: -There are two categories of buyers. The defenders buy exploits to fix them.
Typically there is only one defender, which is the software vendor. The offenders buy exploits to utilize them. National security agencies and police are example offenders. For example, Zerodium [7] is a consulting company that buys zero-day exploits and resells them to mostly government agencies. The offenders wish to utilize an exploit for as long as possible. Once an exploit is obtained by a defender, the exploit becomes worthless. Using mechanism design terminologies, the buyers have externalities.
-The item being sold is an informational item, which means that we can sell the same item multiple times (e.g., to multiple offenders). Of course, once an exploit is sold to a defender, we cannot sell it to any offenders afterwards, because it has become worthless.
-Because the item being sold is a piece of information, we cannot simply describe it in full details to the buyers without some kind of payment enforcing mechanism, because otherwise the buyers can walk away with the exploit for free. Furthermore, we cannot ask the buyers to bid on an exploit that carries no description, because the buyers cannot come up with their private valuations if no description is given.
Guo et al. [12] proposed a mechanism property called straight-forwardness: a mechanism is straight-forward if it describes the exploit in full details to the offenders, before they submit their bids. This is required because typically offenders already have many exploits in their arsenals. With full description, they can evaluate whether the exploit being sold is original, and to what extent the exploit helps them. Straight-forwardness does not require the mechanism to describe the exploit to the defenders before they bid (otherwise, the exploit gets fixed). Straight-forwardness only describes to the defenders how severe the exploit is: e.g., this exploit allows anyone to remotely control an iOS device. From the perspective of a defender, every exploit is new (otherwise, it wouldn't be an exploit). We ask the defenders to come up with their private valuations based on the exploit's severity, which is exactly how bug bounty markets operate (in bug bounty markets, bugs are priced according to their severity levels [19]).
Guo et al. [12] showed that if straightforwardness is required together with strategy-proofness and individual rationality, then one revenue-maximizing mechanism must work as follows: we describe the exploit in full details to all offenders at time 0. We also describe the exploit's severity level to the defenders at time 0. The offenders and defenders submit their bids. The offenders bid to keep the exploit alive for as long as possible. The defenders bid to kill off the exploit as early as possible. In some sense, the model is similar to the cake-cutting problem [3,4] and the single facility location problem [8,18]. 4 For this model, the authors proposed one heuristic-based randomized AMA mechanism.
In this paper, for the above model, we use our new technique to optimize within the AMA family. We also show that if there are only two agents (one offender and one defender), and if the defender's valuation is much lower than the offender's (typically true for zero-day exploit markets), the optimal AMA mechanism's revenue is close to the optimal revenue. For demonstrating this result, we propose and study a family of mechanisms called the posted-price mechanisms for our model.

Model Description
We use O to denote the outcome space. We use Θ i to denote agent i's type space.
For the zero-day exploit mechanism design model proposed in Guo et al. [12], the outcome space is [0, 1]. An outcome o ∈ [0, 1] represents when the exploit is killed off (revealed to the defenders). 5 In order to run the technique proposed in this paper, we require the outcome space to be finite. So for this technical reason, we set the outcome space to be {0, 1 k , 2 k , . . . , 1}. That is, we will only reveal the exploit at these discrete moments. The size of the outcome space |O| = k + 1.
The family of AMA mechanisms is defined as follows: -Given a type profile θ, the outcome picked is the following: In the above description, the u i and the a o are constant parameters. u i ≥ 1 for all i. The a o are unrestricted. In total, there are n + |O| parameters. Every AMA mechanism is characterized by these many parameters. For any assignments of the parameters, the corresponding AMA mechanism is strategy-proof. However, not every AMA mechanism is individually rational. If we further assume that ∀i, θ i , o, v i (θ i , o) ≥ 0, then every AMA mechanism is individually rational. To show this, we only need to show that an agent's valuation is always at least her payment. That is, The right-hand side is less than or equal to the left-hand side if every agent's valuation for every outcome is nonnegative. In our model, an outcome represents when the exploit is killed off. For presentation purpose, we sometimes use t to refer to an outcome.
An offender's valuation is defined as: An offender "enjoys" the exploit from time 0 to t, and a defender values the safe period from time t to 1. f θi (x) represents agent i's instantaneous value (nonnegative) at time x, when her type is θ i . Based on the above definitions of the agents' valuations, we have that every AMA mechanism is individually rational for our model.

Optimizing Affine Maximizer Auctions
We recall that an AMA mechanism is characterized by n + |O| parameters (u i for every agent i, and a o for every outcome o). For presentation purpose, we define Z = n + |O| and use p 1 , p 2 , . . . , p Z to refer to the parameters. Let M (p 1 , p 2 , . . . , p Z ) be the AMA mechanism characterized by p 1 to p Z . The task of optimizing within the AMA family is simply to optimize over the parameters: max p1,p2,...,pZ ER(M (p 1 , p 2 , . . . , p Z )) Here, ER(M ) represents mechanism M 's expected revenue. We have analytical characterization of the AMA payments, so the revenue of M given a specific type profile can be calculated accordingly. Unfortunately, there is no known short-cut for calculating the expected revenue. Given a prior distribution of the θ i , we need to draw large amount of sample profiles to calculate the expected revenue. For example, if for every agent i, we draw 100 samples for θ i , then altogether the number of type profiles is 100 n . For this reason, in this paper, we focus on cases where n is small. 6 Likhodedov and Sandholm [15,16] used a grid-based gradient descent approach for optimizing the parameters. Under this approach, suppose we start from a grid point (p 1 , p 2 , . . . , p Z ), we have to examine all neighbouring points (p 1 + δ 1 h, p 2 + δ 2 h, . . . , p Z + δ Z h), where δ i ∈ {−1, 0, 1} and h is the grid size. We need to examine 3 Z points. So this approach requires that both n and |O| be tiny. For example, if Z = 100, then the approach is impractical. For our technique, Z is allowed to be large: our technique involves a LP model with Z variables, which takes polynomial time in Z.
A high-level description of our optimizing technique is as follows: -We initialize the algorithm with an AMA mechanism: e.g., one based on random parameters, or the VCG mechanism. -Given M 0 characterized by p 0 1 , p 0 2 , . . . , p 0 Z , we use a heuristic to approximate the optimal AMA mechanism near this starting point, using a linear program. A mechanism M (characterized by p 1 , p 2 , . . . , p Z ) is near M 0 if max i |p i − p 0 i | ≤ ǫ for a threshold ǫ. We repeat this step using the new mechanism as the starting point.
The above algorithm may end with a locally optimal mechanism, which means that we may need to repeat the algorithm using different initial points. Now we present the details of the linear program. We index the outcomes using 0, 1, . . . , k. We denote the initial mechanism as M (u 0 1 , u 0 2 , . . . , u 0 n , a 0 0 , a 0 1 , . . . , a 0 k ). The following optimization model solves for the optimal AMA mechanism near this starting point:

Model 1
Variables: u 1 , u 2 , . . . , u n , a 0 , a 1 , . . . , a k Maximize: ER(M (u 1 , u 2 , . . . , u n , a 0 , a 1 , . . . , a k )) Subject to: Of course, the above model is not a linear program, as ER(M ) is not a linear combination of the variables. We will approximate ER(M ) using a linear combination of the variables.
Let S be a large set of type profiles, we will approximate ER(M ) as follows: Here, C i (M, θ) is agent i's payment under M when the type profile is θ. One way to pick S is to discretize the type space and let S be the set of all grid points. Now what remains to be done is to approximate C i (M, θ) using a linear combination of the variables.
Here, o * is defined as We use the following heuristic to approximate C i (M, θ): because the u i and the a o are close to the u 0 i and the a 0 o , we will use the u 0 i and the a 0 o to calculate the outcomes mentioned in the above expressions. That is, we assume that for most type profiles, small perturbation in the parameters will not change the mechanism outcomes.
We replace o * and o using o * 0 and o 0 , we have that We use c j to denote v j (θ j , o 0 ) and c * j to denote v j (θ j , o * 0 ). Both the c j and the c * j are constants.
We then observe that for any x, The first term is a linear combination of the variables, as u 0 i , the c j , and the c * j are all constants.
The second term can be approximated as follows: The above is a linear function involving one variable (u i ).
Using the above heuristic method, we are able to turn Model 1 into a linear program involving n + |O| variables. The number of constraints is n + |O| + |S|. Therefore, we can afford reasonable large n and |O|, as long as |S| is not too large.

Zero-Day Exploit Mechanism Design Model
In this section, we focus on a specific mechanism design setting for the zero-day exploit model: there are only two agents: one offender and one defender.
We use EP O(M ) to denote the offender's expected payment under mechanism M . We use EP D(M ) to denote the defender's expected payment under mechanism M .
Let F be the set of all strategy-proof and individually rational mechanisms. Let M * be the optimal mechanism that maximizes the expected revenue. We recall that ER(M ) denotes M 's expected revenue. We introduce the following posted-price mechanisms. These mechanisms allow only one agent to make decisions.
-Every outcome o is associated with a price a o .
-One agent picks the outcome that maximizes her own utility. For zero-day exploit market, typically the defender has much lower valuation than the offender. For example, according to [9], an exploit that attacks the Chrome browser sells between 80k and 200k for offensive clients (USD). According to Google's official bug bounty reward program for the Chrome browser [19], a serious exploit is priced between 0.5k and 15k. Therefore, EP D(M D * ) is generally much smaller than EP O(M O * ).
We use P P (a 0 , a 1 , . . . , a k ) to denote the posted-price mechanism with the parameters a 0 to a k . We use M (u O , u D , a 0 , a 1 , . . . , a k ) to denote the AMA mechanism with the parameters u O (for offender), u D (for defender), and the a t . If the deciding agent under P P (a 0 , a 1 , . . . , a k ) is the offender, then P P (a 0 , a 1 , . . . , a k ) approaches M (u O , 1, 0, −a 1 u O , . . . , −a k u O ), when u O approaches infinity. If the deciding agent under P P (a 0 , a 1 , . . . , a k ) is the defender, then P P (a 0 , a 1 , . . . , a k ) approaches M (1, u D , −a 0 u D , . . . , −a k−1 u D , 0), when u D approaches infinity. For any posted-price mechanism, there exists an AMA mechanism whose expected performance is arbitrary close to it. That is, the optimal AMA mechanism's expected revenue is at least the optimal expected revenue of posted-price mechanisms.
We solve for the optimal posted-price mechanism for the offender, denoted as P P * . Because the optimal AMA mechanism outperforms P P * (or they have the same expected revenue), when EP D(M D * ) is small, we have that the optimal AMA mechanism's expected revenue is close to the expected revenue of the optimal mechanism M * .

Optimal Posted-Price Mechanism
In this subsection, we discuss how to solve for the optimal posted-price mechanism.
First of all, we focus on the single-parameter setting [12]. For presentation purpose, we focus on solving for the optimal posted-price mechanism where the offender makes decisions.
In a single-parameter setting, an offender's valuation is defined as follows, assuming her type is is a fixed function that characterizes the instantaneous valuation of the exploit by the agent. At time x, the instantaneous valuation is θ O c(x).
We use Myerson's standard technique. We assume θ O ∈ [0, H], where H is a fixed upper bound. We assume θ O 's pdf and cdf are f and F , respectively. We also assume the following expression is monotone nondecreasing. This is called the monotone hazard rate condition, which is satisfied by many common distributions.
It turns out that if the above all hold, then the optimal post-price mechanism simply sells the whole time interval [0, 1] as a bundle, with a fixed take-it-orleave-it price p. If the agent is willing to afford p to buy the whole interval, then she gets it. Otherwise, she gets nothing and pays nothing. The optimal mechanism P P * = P P (0, ∞, ∞, . . . , ∞, p).
When k is small, we have another algorithm for solving for the optimal posted-price mechanism, and under this algorithm, we can drop the singleparameter assumption.
Let P P (a 0 , a 1 , . . . , a k ) be the optimal posted-price mechanism. It is without loss of generality to assume that for any i < j, if both a i and a j are finite, then a i < a j . Otherwise, the outcome i is never chosen, and we can set a i to be infinite. It is also without loss of generality to assume that for any a i , either it is infinite (meaning that this outcome is not allowed), or it must satisfy the following condition: Here, v(t, θ O ) is the offender's valuation for outcome t when her type is θ O . The above condition basically says that there exists a type for the offender, if we increase a i just a bit, then it would force the offender to choose an earlier outcome than i. If the condition is not true, then we can safely increase a j . By doing so, we can charge more for those types that choose j. We can also charge more if under some types, the offender chooses a later outcome, which also means that more payment will be collected.
Based on the above condition, if we know the a j for j < i and θ O , then we can calculate a i . We already know that a 0 = 0. To calculate a 1 , we can go over all θ O , possibly by discretizing the offender's type space. Then, to calculate a 2 , we can go over all θ O again. We do this for every i. Let N be the number of types in Θ O after the discretization. The total number of iterations is then N k .

Evaluation
As mentioned earlier, according to [9], an exploit that attacks the Chrome browser sells for at most 200k for offensive clients (USD). According to Google's official bug bounty reward program for the Chrome browser [19], a serious exploit is priced for at most 15k.
We start with the following setting, which is based on the numbers above. There are two agents. The offender's valuation function is Therefore, ER(M * ) is at most 53.75. We pick k = 10 and ǫ = 0.01. We use the VCG mechanism as the initial solution. The VCG mechanism's expected revenue is 6.9, which is very far away from the upper bound. Our technique starts from the VCG mechanism, and at the end produces a mechanism whose expected revenue equals 50.6, which is very close to the upper bound 53.75. That is, in this case, the optimal AMA mechanism's expected revenue is close to the optimal mechanism's expected revenue.
As demonstrated in our analysis, we have the above phenomenon if the defender's valuation is insignificant compared to the valuation of the offender. We then investigate an example where the defender's valuation is much higher. We change it so that the defender's type is drawn from U (0, 150) instead of U (0, 15). Now the upper bound for ER(M * ) is 87.5. Our technique produces a mechanism whose expected revenue equals 57.9. This time, the achieved value is not close to the upper bound.