Generative Adversarial Networks for Black-Box API Attacks with Limited Training Data

TL;DR

This paper explores adversarial attacks on online machine learning APIs with limited query budgets, proposing a GAN-based method to generate synthetic data that enhances attack effectiveness and demonstrates practical stealth attack strategies.

Contribution

It introduces a GAN-based approach to generate synthetic training data from limited samples, enabling more effective adversarial attacks under API rate constraints.

Findings

Limited data hampers reliable classifier inference.

GAN-generated data improves attack success rates.

Stealth attacks are feasible with small API call footprints.

Abstract

As online systems based on machine learning are offered to public or paid subscribers via application programming interfaces (APIs), they become vulnerable to frequent exploits and attacks. This paper studies adversarial machine learning in the practical case when there are rate limitations on API calls. The adversary launches an exploratory (inference) attack by querying the API of an online machine learning system (in particular, a classifier) with input data samples, collecting returned labels to build up the training data, and training an adversarial classifier that is functionally equivalent and statistically close to the target classifier. The exploratory attack with limited training data is shown to fail to reliably infer the target classifier of a real text classifier API that is available online to the public. In return, a generative adversarial network (GAN) based on deep learning is built to generate synthetic training data from a limited number of real training data samples, thereby extending the training data and improving the performance of the inferred classifier. The exploratory attack provides the basis to launch the causative attack (that aims to poison the training process) and evasion attack (that aims to fool the classifier into making wrong decisions) by selecting training and test data samples, respectively, based on the confidence scores obtained from the inferred classifier. These stealth attacks with small footprint (using a small number of API calls) make adversarial machine learning practical under the realistic case with limited training data available to the adversary.

Figures

Tables

Table 1. TABLE I: Performance (difference between labels returned by T 𝑇 T and T ^ ^ 𝑇 \hat{T} ) with real and synthetic training data.

Training data size	Number of	Number of	Performance
(total number of samples)	real samples ($N_r$)	synthetic samples ($N_s$)	$d_1(\hat{T},T)$	$d_2(\hat{T},T)$	$d(\hat{T},T)$
$100$	$100$	$0$	$44.59\%$	$45.64\%$	$45.00\%$
$150$	$100$	$50$	$32.79\%$	$28.72\%$	$31.20\%$
$200$	$100$	$100$	$27.21\%$	$27.69\%$	$27.40\%$
$250$	$100$	$150$	$30.49\%$	$26.67\%$	$29.00\%$
$300$	$100$	$200$	$28.52\%$	$28.21\%$	$28.40\%$
$400$	$100$	$300$	$31.48\%$	$32.31\%$	$31.80\%$

Equations

$$\underset{G}{\min }\underset{D}{\max }$$

$$\underset{G}{\max }{\mathbb{E}}_{\mathbf{z}\sim p_{\mathbf{z}}}[\log (D(G(\mathbf{z})))].$$

Full text

• I Introduction

Artificial intelligence (AI) finds diverse and far-reaching applications ranging from cyber security and intelligence analysis to Internet of Things (IoT) and autonomous driving. To support AI, machine learning provides computational resources with the ability to learn without being explicitly programmed. Enabled by hardware accelerations for computing, the next generation machine learning systems such as those based on deep learning are effectively used for different classification, detection, estimation, tracking, and prediction tasks.

Machine learning applications often involve sensitive and proprietary information such as training data, machine learning algorithm and its hyperparameters, and functionality of underlying tasks. As such applications become more ubiquitous, machine learning itself becomes subject to various exploits and attacks that expose the underlying tasks to unprecedented threats. Adversarial machine learning is an emerging field that studies machine learning in the presence of an adversary [1]. In one prominent example adversarial images were generated by slightly perturbing images to fool a state-of-the-art image classifier, e.g., a perturbed panda image was recognized as a gibbon by the classifier [2].

Machine learning systems are typically offered to public or paid subscribers via an application programming interface (API), e.g., Google Cloud Vision [3], provide cloud-based machine learning tools to build and train machine learning models. This online service paradigm makes machine learning vulnerable to exploratory (or inference) attacks [4, 5, 6, 7, 8, 9, 10] that aim to understand how the underlying machine learning algorithm works. An exploratory attack can be launched as a black-box attack [5, 6, 7] without any prior knowledge on the machine learning algorithm and the training data. In this attack, the adversary calls the target classifier $T$ with a large number of samples, collects the labels, and then uses this data to train a deep learning classifier $\hat{T}$ that is functionally equivalent (i.e., statistically similar) to the target classifier $T$. This attack infers the full functionality of the classifier and implicitly steals its underlying training data, machine learning algorithm, and hyperparameter selection.

After an adversary infers $\hat{T}$, it can launch further attacks such as causative attacks [11, 12, 13] and evasion attacks [13, 14, 15, 16]. In a causative attack, the adversary provides the target classifier with incorrect information as additional training data to reduce the reliability of the retrained classifier. In particular, the adversary runs some samples through the inferred classifier $\hat{T}$. If their deep learning scores (likelihood of labels) are far away from the decision boundary, the adversary changes their labels and sends these mislabeled samples as training data to the target classifier $T$. In an evasion attack, the adversary provides the target classifier with test data that will result in incorrect labels (e.g., the classifier is fooled into accepting an adversary as legitimate). In particular, the adversary runs some samples through the inferred classifier $\hat{T}$. If their deep learning scores are confined within the decision region for label $j$ and are close to the decision region for the other label $i$, the adversary feeds those samples to the target classifier $T$ that is more likely to classify their labels to $j$ instead of $i$.

One major limitation of exploratory attacks that has been overlooked so far is the extent to which training data can be collected from the target application. Usually, APIs have strict rate limitations on how many application samples can be collected over a time period (ranging from a limited number samples per second to per day). We consider the realistic case that the number of calls is limited due to various reasons, e.g., the target classifier $T$ may limit the number of calls that a user can make, or identify a large number of calls as malicious by a defense mechanism.

In this paper, we select a real online text analysis API, DatumBox [17], as the target classifier $T$. The underlying machine learning algorithm is unknown to the adversary that treats $T$ as a black box. First, we show that as the API call rate is limited, the adversary cannot reliably infer $T$ using the exploratory attack. Second, we present an approach to enhance the training process of the exploratory attack. This approach is based on the generative adversarial network (GAN) [18] to augment training data with synthetic samples. We show that the exploratory attack with the GAN is successful even with a small number of training samples (acquired from the API of the target classifier $T$) and the inferred classifier $\hat{T}$ based on the deep neural network is statistically close to $T$. The GAN consists of a generator $G$ and a discriminator $D$ playing a minimax game. $G$ aims to generate realistic data (with labels), while $D$ aims to distinguish data generated by $G$ as real or synthetic. By playing a game between $G$ and $D$, the GAN generates additional training data without further calls to $T$. With this additional training data, $\hat{T}$ is better trained. We show that the proposed approach significantly improves the performance of $\hat{T}$, which is measured as the statistical difference of classification results, i.e., labels returned, by $T$ and $\hat{T}$.

Adversarial machine learning with limited training data was studied in [6] from a different perspective, where the adversary first infers the target classifier with limited real training data and then generates synthetic data samples in an evasion attack by adding adversarial perturbations to real data that are gradually improved with labels queried from the target classifier. Our setting is different in several aspects. First, the size of training data used in [6] (6,400 samples) is much larger than ours (100 samples). Second, we select real samples that the target will misclassify, instead of altering real samples. Third, we consider a text classifier as the target classifier, whereas [6] considered an image classifier. Fourth, we improve the inferred classifier (not the adversarial samples) that is used later to provide an arbitrary number of selected samples to evasion or causative attacks without further querying the target classifier.

Data augmentation with the GAN was studied for the low-data regime, where synthetic data samples were generated for image applications in [19] and wireless communications in [20] and [21]. In this paper, we used the GAN to support attacks by augmenting the training data for an adversary that operates with strict rate limitations on the API calls made to a target text classifier. A similar setting was considered in [22]. Instead of adding synthetic data samples, [22] used active learning to reduce the number of API calls needed to obtain the labels of real data samples. The rest of the paper is organized as follows. Section II studies the exploratory attack on an online classifier with a large number of API calls. Training data augmentation with the GAN is presented in Section III to launch the exploratory attack with a limited number of API calls. The subsequent causative and evasion attacks are studied in Section IV. Section V concludes the paper.

II Black-Box Exploratory Attack

The system model is shown in Fig. 1. There are various online APIs for machine learning services with either free subscriptions or paid licenses. For example, DatumBox provides a number of machine learning APIs for text analysis [17]. A user can write its own code to call these APIs, specify some input text data, and obtain the returned labels, e.g., subjective or objective. These services are often based on sophisticated algorithms (e.g., machine learning) and tuned by a large amount of training data, which requires a significant effort. The number of calls made by a user depends on the license and is limited in general, e.g., 1000 calls per day for free license of DatumBox. The adversary launches a black-box exploratory attack. The target classifier $T$ is based on an algorithm (e.g., Naive Bayes or Support Vector Machine (SVM) or a more sophisticated neural network) that is unknown to the adversary. In addition, the adversary does not know the training data that has been used to train the target classifier $T$. The adversary pursues the following steps:

The adversary sends a set $S$ of samples to the target classifier $T$ and receives the label $T(s)$ returned by $T$ for each sample $s\in S$. 2. 2.

The adversary trains a deep neural network using the training data from Step 1 and builds its own inferred classifier $\hat{T}$.

The adversary applies deep learning (based on a multi-layered neural network) to infer $T$. Deep learning refers to training a deep neural network for computing some function. Neural network consists of neurons that are joined by weighted connections (synapses). In a feedforward neural network (FNN) architecture, neurons are arranged in layers. A signal $x_{k}$ at the input of synapse $k$ is connected to neuron $j$ and multiplied by the synaptic weight $w_{jk}$. An adder sums these weighted multiplications and inputs the sum to an activation function denoted by $\sigma(\cdot)$. The bias $b_{j}$ of the $j$th layer increases or decreases the sum that is input of the activation function. These operations can be expressed as ${y}_{j}=\sigma\left(\sum_{k=1}^{m}{w}_{jk}{x}_{k}+b_{j}\right)$. The operation of an FNN is illustrated in Fig. 2 for one of the layers with $m$ neurons. The weights and biases are determined by the backpropagation algorithm.

We consider an exploratory attack on a real online classifier, namely the text subjectivity analysis API of DatumBox [17]. The adversary builds training data by calling this API with different text samples and collecting the returned labels (subjective or objective). There are two types of labels. Label $1$ includes subjective text and label $2$ includes objective text. A user is allowed to make 1000 calls per day with a free license, i.e., one can collect 1000 samples with labels per day. The Twitter API is used to collect random tweets. These tweets are first preprocessed by removing the stop words, web links (e.g., http and https links), and punctuations. Then, word tokens are created from the cleaned tweets. The word count frequencies of top 20 words that the adversary prepares are presented in Fig. 3. Each token is represented by a $k$-dimensional feature vector.

The inferred classier is built with deep learning that requires significantly more data compared to standard machine learning algorithms (e.g., Naive Bayes and SVM). To train a deep neural network, the weights and biases of the multi-layered neural network are selected. In the meantime, its hyperparameters such as the number of layers and the number of neurons per layer are tuned. To build a set of features as inputs for each text sample, the adversary first obtains a list of words, sorted by their frequencies of occurrence in text such that $W=(w_{1},w_{2},\cdots)$, where the frequency of occurrence for word $w_{i}$ is $p_{i}$ and $p_{1}\geq p_{2}\geq\cdots$. Then, for each sample of text, the adversary counts the number of occurrence $o_{i}$ for each word $w_{i}$ and builds a set of features $(o_{1},o_{2},\cdots)$. Overall, 1000 features are obtained by considering distributions of top 1000 words. These features are used by the adversary to train the deep learning classifier $\hat{T}$.

The following two differences between $\hat{T}$ and $T$ are computed. The difference $d_{1}(\hat{T},T)$ between $\hat{T}$ and $T$ on label $1$ is the number of samples with ${\hat{T}}(s)=2$ and $T(s)=1$ divided by the number of samples with label $1$ in test data, and the difference $d_{2}(\hat{T},T)$ between $\hat{T}$ and $T$ on label $2$ is the number of samples with ${\hat{T}}(s)=1$ and $T(s)=2$ divided by the number of samples with label $2$ in test data.

The adversary builds the optimal $\hat{T}$ by selecting hyperparameters (e.g., the number of layers and the number of neurons per layer) to minimize $d_{\max}(\hat{T},T)=\max\{d_{1}(\hat{T},T),d_{2}(\hat{T},T)\}$ based on the training data, thereby balancing the false alarm and misdetection errors. We used the Microsoft Cognitive Toolkit (CNTK) to train the FNN and developed the Python code for hyperparameter optimization. The adversary collects 6000 samples over time and uses half of them as training data and half of them as test data to train a classifier $\hat{T}$. We optimize the hyperparameters of the deep neural network as follows:

• –

The number of hidden layers is 2.

• –

The number of neurons per layer is 30.

• –

The loss function is cross entropy.

• –

The activation function in hidden layers is sigmoid.

• –

The activation function in output layer is softmax.

• –

All weights and biases are not initially scaled.

• –

Input values are unit normalized in the first training pass.

• –

The minibatch size is 20.

• –

The momentum coefficient to update the gradient is 0.9.

• –

The number of epochs per time slot is 10.

The difference between labels returned by $T$ and $\hat{T}$ is found as $d_{1}(\hat{T},T)=25.66\%$, $d_{2}(\hat{T},T)=26.04\%$, and $d(\hat{T},T)=25.80\%$. The difference can be further reduced with more data collected over additional days.

In this attack, the adversary needs to collect training data by calling the target classifier many times over multiple days (with 1000 samples per day). First, such an attack incurs significant delay. Second, a simple mechanism that limits the number of allowed calls would force this attack to take over a long time. Such a long-term attack can be detected over time and identified as malicious behavior, and the adversary can be blocked. Therefore, it is essential that the adversary performs the exploratory attack with a limited number of API calls. In the next section, we will present a novel approach to enable a successful exploratory attack with a limited number of training data samples.

III Training Data Augmentation with the GAN

Consider the adversarial deep learning system model in Fig. 4, which extends the exploratory attack in Section II by utilizing a GAN to generate synthetic data samples and augment the training data set to train the classifier better without additional calls. Data augmentation can be performed by using neural networks, e.g., generating a new sample by injecting noise to the input of a neural network and dropout layers without changing the labels. Recently, the GAN [18] was proposed to generate synthetic data and was shown to outperform prior methods due to the better quality of generated synthetic data that cannot be reliably distinguished from real data [18, 24, 23]. An example of the GAN is illustrated in Fig. 5. In a GAN, there are two neural networks, namely the generator and the discriminator, playing a minimax game:

[TABLE]

where $\bm{z}$ is a noise input to generator $G$ with a model distribution of $p_{\bm{z}}$ and $G(\bm{z})$ is the generator output. Input data $\bm{x}$ has distribution $p_{data}$ and discriminator $D$ distinguishes between the real and generated samples. Both $G$ and $D$ are trained with backpropagation of error. However, when the generator is trained with the objective in (1), the gradients of the generator rapidly vanish that makes the training of the GAN very difficult. To address the vanishing gradient problem, the following objective function at the generator [23] is used:

[TABLE]

Thus, in the first step, we have the discriminator $D$ trained to distinguish between the real and synthetic data. Then generator $G$ takes random noise as input and maximizes the probability of $D$ making a mistake and fools $D$ by creating samples that resemble the real data in the second step. The conditional GAN extends the GAN concept such that the generator can generate synthetic data samples with labels [24]. The objective function in the conditional GAN is similar to the one of a regular GAN, but as illustrated in Fig. 6, the terms $D(\bm{x})$ and $D(G(\bm{z}))$ are replaced by $D(\bm{x},\bm{y})$ and $D(G(\bm{z},\bm{y}))$, respectively, to accommodate the labels $\bm{y}$ as conditions. We assume that the adversary uses the conditional GAN.

In data augmentation, the objective of the adversary is to use $N_{r}$ real training data samples with labels, generate $N_{s}$ synthetic training data samples with labels by applying a conditional GAN, and augment the training data set to the total of $N_{aug}=N_{r}+N_{s}$ samples. The deep neural networks to build the conditional GAN are developed in TensorFlow. The generator and the discriminator are made up of FNNs with the following features.

• –

The generator $G$ takes in a noise vector $\bm{z}$ that is randomly distributed with a zero mean and unit variance of $100$ dimensions, i.e., $\bm{z}\in\mathbb{R}^{100}$, and binary labels $\bm{y}\in\mathbb{R}^{2}$ as input, and generates synthetic data $G(\bm{z}|\bm{y})$ with the same dimensions of the original data. The first two layers of $G$ have 100 and 500 neurons per layer, respectively, and they are activated by rectifying linear unit (ReLU) that performs $\max(x,0)$ operation on input $x$. The output layer of $G$ has the same dimensions as the original data and uses the hyperbolic tangent (tanh) activation function.

• –

The discriminator $D$ takes in the original data or the synthetic data generated by $G$. The first two layers of $D$ have 500 neurons each, which are ReLU activated. The last layer of $D$ has one neuron that is sigmoid activated.

Both $G$ and $D$ are trained with the Adam optimizer [25] using a learning rate of $10^{-5}$. For the exploratory attack, the adversary starts with $N_{r}=$ 100 samples in training data to build the classifier $\hat{T}$. 500 samples are used in test data. The hyperparatemers of the deep neural network used for inferring the target classifier are optimized as follows:

• –

The number of hidden layers is 3.

• –

The number of neurons per layer is 50.

• –

The loss function is cross entropy.

• –

The activation function in hidden layers is sigmoid.

• –

The activation function in output layer is softmax.

• –

All weights and biases are initially scaled by 3.

• –

Input values are unit normalized in the first training pass.

• –

The minibatch size is 25.

• –

The momentum coefficient to update the gradient is 0.1.

• –

The number of epochs per time slot is 10.

The difference between the labels returned by $T$ and $\hat{T}$ is found as $d_{1}(\hat{T},T)=44.59\%$, $d_{2}(\hat{T},T)=45.64\%$, and $d(\hat{T},T)=45.00\%$. The adversary applies the GAN to generate additional synthetic training data samples based on 100 real training data samples. Then the adversary retrains $\hat{T}$ with updated training data. The difference between labels returned by $T$ and $\hat{T}$ is shown in Table I. The GAN is trained with 500 epochs with 32 samples in each batch. In one epoch, two discriminator updates and one generator update are performed, as suggested in [18]. Fig. 7 shows the loss function of the generator and the discriminator during training.

When additional $N_{s}=$ 50 or 100 training data samples are generated by the GAN (i.e., when the total training data size is $N_{aug}=$ 150 or 200 samples), the performance of $\hat{T}$ improves significantly. However, adding more data (e.g., $N_{s}=$ 150, 200 or 300 synthetic data samples) generated by the GAN cannot further improve $\hat{T}$. While synthetic data samples generated by the GAN can provide more information to train a classifier, their labels may also incur some error (i.e., labels are different from those by $T$). Thus, adding too many additional synthetic data samples from the GAN hurts the performance of $\hat{T}$. Results in Table I show that training data augmentation with 100 real and 100 synthetic samples reduces $d(\hat{T},T)$ up to $27.40\%$, which is only $1.6\%$ different from the case when all 3000 real samples are used for training in Section II.

IV Causative and Evasion Attacks

After an exploratory attack, causative and evasion attacks are launched by using the inferred classifier $\hat{T}$.

IV-A Causative Attack

In a causative attack, the adversary provides incorrect training data such that the classifier is retained with wrong data and the accuracy of the updated classifier $\tilde{T}$ drops. In the extreme case, the adversary may change labels of all data samples. However, to avoid being detected, the adversary may not prefer switching labels of too many data samples. Thus, it is important to select the best set of data samples and switch their labels. This selection requires the knowledge of $T$, but the adversary does not know $T$’s algorithm or training data. Therefore, a successful causative attack can be performed only if the adversary has performed an exploratory attack and obtained the inferred classifier $\hat{T}$ that is similar to $T$.

The adversary applies deep learning to build $\hat{T}$, which also provides a likelihood score in $[0,1]$ on the classification of each sample. If this score is less than a threshold, this sample is identified as label $1$, otherwise it is identified as label $2$. This score measures the confidence of classification. That is, if a sample has a score close to [math] or $1$, its label assignment has a high confidence. On the other hand, if a sample has a score close to the threshold, its label assignment has a low confidence. With $\hat{T}$, an adversary can perform a causative attack by following three steps:

The adversary calls $\hat{T}$ with a number of samples to and receives their scores and labels. 2. 2.

Suppose the adversary can change the labels of for $p\%$ of samples. The adversary selects samples with top $\frac{p}{2}\%$ scores and samples with bottom $\frac{p}{2}\%$ scores. 3. 3.

The adversary switches labels of selected samples and sends all labels of samples to retrain the classifier.

We measure the impact of a causative attack by comparing the outputs of the original classifier $T$ and the updated classifier $\tilde{T}$ on samples with label $1$ or label $2$ (identified by $T$) and on all data samples. Suppose there are $n_{1}$ samples with label $1$ and $n_{2}$ samples with label $2$. Among $n_{1}$ (or $n_{2}$) samples, $m_{1}$ (or $m_{2}$) samples are classified differently by $\tilde{T}$. Thus, we have three difference measures to represent the difference of $T$ and $\hat{T}$: $d_{1}(T,\tilde{T})=\frac{m_{1}}{n_{1}},d_{2}(T,\tilde{T})=\frac{m_{2}}{n_{2}},\mbox{ and }d(T,\tilde{T})=\frac{m_{1}+m_{2}}{n_{1}+n_{2}}.$ We use 1000 samples and set $p=10$. For the classifier $\hat{T}$ built in Section III with 400 training samples, we obtain $d_{1}(T,\tilde{T})=49.52\%$, $d_{2}(T,\tilde{T})=45.41\%$, and $d(T,\tilde{T})=48\%$. This result shows that the causative attack reduces the updated classifier $\tilde{T}$’s performance significantly.

IV-B Evasion Attack

In an evasion attack, the adversary identifies a particular set of data samples that the classifier $T$ cannot reliably classify. The adversary uses the classification scores by $\hat{T}$ to perform the evasion attack. If the objective of the attack is to maximize the error, the adversary should select samples with scores close to the threshold (i.e., with low confidence on classification). If the objective is to maximize the error of misclassifying a sample with label $1$ as label $2$ (or vice versa), the adversary should select samples classified as label $2$ (or $1$) and with score close to the threshold. Although the evasion attack is performed with the inferred classifier, the evaluation of the attack’s performance requires the ground truth on labels. Since the adversary does not have access to the knowledge of ground truth, we cannot measure the performance of the evasion attack.

V Conclusion

In this paper, we addressed adversarial deep learning with limitations on the training data. We considered the exploratory attack to infer an online classifier by training deep learning with a limited number of calls to a real online API. However, with limited training data, we observed that there is a significant difference between the labels returned by the inferred classifier and the target classifier. We designed an approach using the GAN to reduce this difference and enhance the exploratory attack. Building upon the classifier inferred by the exploratory attack, we designed causative and evasion attacks to select training and test data samples, respectively, to poison the training process and fool the target classifier into making wrong decisions for these samples. Our results show that adversarial deep learning is feasible as a practical threat to online APIs even when only limited training data is used by the adversary.