def test_save_model(self):
X, y, _ = datasets.csv2numpy(config.get('RandomForest_test', 'traindata'))
self.rf.fit(X, y)
newX, _, _ = datasets.csv2numpy(config.get('RandomForest_test', 'noveldata'))
self.assertTrue(len(self.rf.predict(newX)) == 20)
self.rf.save_model(config.get('RandomForest_test', 'modelfile'))
os.remove(config.get('RandomForest_test', 'modelfile'))
def test_save_model(self):
X, y, _ = datasets.csv2numpy(config.get('sklearn_SVC_test', 'traindata'))
self.svc.fit(X, y)
newX, _, _ = datasets.csv2numpy(config.get('sklearn_SVC_test', 'noveldata'))
self.assertTrue(len(self.svc.predict(newX)) == 20)
self.svc.save_model(config.get('sklearn_SVC_test', 'modelfile'))
os.remove(config.get('sklearn_SVC_test', 'modelfile'))
def test_predict(self):
X, y, _ = datasets.csv2numpy(
config.get('RandomForest_test', 'traindata'))
self.rf.fit(X, y)
newX, _, _ = datasets.csv2numpy(
config.get('RandomForest_test', 'noveldata'))
self.assertTrue(len(self.rf.predict(newX)) == 20)
def test_decision_function(self):
X, y, _ = datasets.csv2numpy(
config.get('RandomForest_test', 'traindata'))
self.rf.fit(X, y)
newX, _, _ = datasets.csv2numpy(
config.get('RandomForest_test', 'noveldata'))
self.assertTrue(len(self.rf.decision_function(newX)) == 20)
def main():
random.seed(0)
parser = ArgumentParser()
parser.add_argument('--plot',
help='Where to save plot (file name)',
default=False)
parser.add_argument('--show',
help='Show plot in a window',
default=False,
action='store_true')
args = parser.parse_args()
print 'Loading training data from CSV...'
tr_data, tr_labels, _ = csv2numpy(config.get('datasets', 'contagio'))
print 'Loading test data from CSV...'
te_data, te_labels, te_fnames = csv2numpy(
config.get('datasets', 'contagio_test'))
print 'Evaluating...'
scores = fig9(tr_data, tr_labels, te_data, te_labels, te_fnames)
if not (args.plot or args.show):
return 0
# Plot
feat_points, file_points = zip(*scores)
fig = pyplot.figure()
pyplot.plot(feat_points,
label='Feature space',
marker='o',
color='k',
linewidth=2)
pyplot.plot(file_points,
label='Problem space',
marker='^',
color='k',
linewidth=2,
linestyle='--')
axes = fig.gca()
# Set up axes and labels
axes.yaxis.set_ticks([r / 10.0 for r in range(11)])
axes.yaxis.grid()
axes.set_ylim(0, 1)
axes.set_ylabel('Accuracy')
xticklabels = [common.top_feats[0]
] + ['(+) ' + name for name in common.top_feats[1:]]
axes.set_xticklabels(xticklabels, rotation=60, ha='right')
fig.subplots_adjust(bottom=0.34, top=0.95, left=0.11, right=0.98)
pyplot.legend(loc='lower left')
if args.show:
pyplot.show()
if args.plot:
pyplot.savefig(args.plot, dpi=300, bbox_inches='tight')
return 0
def test_load_model(self):
X, y, _ = datasets.csv2numpy(config.get('sklearn_SVC_test', 'traindata'))
self.svc.fit(X, y)
newX, _, _ = datasets.csv2numpy(config.get('sklearn_SVC_test', 'noveldata'))
prediction = self.svc.predict(newX)
self.svc.save_model(config.get('sklearn_SVC_test', 'modelfile'))
newsvc = sklearn_SVC()
newsvc.load_model(config.get('sklearn_SVC_test', 'modelfile'))
self.assertTrue(numpy.array_equal(prediction, newsvc.predict(newX)))
os.remove(config.get('sklearn_SVC_test', 'modelfile'))
def test_load_model(self):
X, y, _ = datasets.csv2numpy(config.get('RandomForest_test', 'traindata'))
self.rf.fit(X, y)
newX, _, _ = datasets.csv2numpy(config.get('RandomForest_test', 'noveldata'))
prediction = self.rf.predict(newX)
self.rf.save_model(config.get('RandomForest_test', 'modelfile'))
newrf = RandomForest()
newrf.load_model(config.get('RandomForest_test', 'modelfile'))
self.assertTrue(numpy.array_equal(prediction, newrf.predict(newX)))
os.remove(config.get('RandomForest_test', 'modelfile'))
def main():
random.seed(0)
parser = ArgumentParser()
parser.add_argument('--plot',
help='Where to save plot (file name)',
default=False)
parser.add_argument('--show', help='Show plot in a window', default=False)
args = parser.parse_args()
print 'Loading training data from CSV...'
tr_data, tr_labels, tr_fnames = csv2numpy(
config.get('datasets', 'contagio'))
print 'Loading test data from CSV...'
te_data, te_labels, _ = csv2numpy(config.get('datasets', 'contagio_test'))
print 'Evaluating...'
scores = fig11(tr_data, tr_labels, te_data, te_labels, tr_fnames)
if not (args.plot or args.show):
return 0
# Plot
original, our_mimicry = zip(*scores)
fig = pyplot.figure()
pyplot.plot(original,
label='Clean data',
marker='o',
color='k',
linewidth=2)
pyplot.plot(our_mimicry,
label='Our mimicry',
marker='+',
color='k',
linewidth=2,
linestyle=':')
axes = fig.gca()
# Set up axes and labels
axes.yaxis.set_ticks([r / 10.0 for r in range(11)])
axes.yaxis.grid()
axes.set_ylim(0, 1)
axes.set_ylabel('Accuracy')
xticklabels = ['0', '0.05', '0.1', '0.5', '1', '5', '10', '50', '100']
axes.set_xticklabels(xticklabels, rotation=0)
axes.set_xlabel('Training set perturbation (%)')
fig.subplots_adjust(bottom=0.13, top=0.95, left=0.11, right=0.96)
pyplot.legend(loc='lower right')
if args.show:
pyplot.show()
if args.plot:
pyplot.savefig(args.plot, dpi=300, bbox_inches='tight')
return 0
def test_load_model(self):
X, y, _ = datasets.csv2numpy(
config.get('RandomForest_test', 'traindata'))
self.rf.fit(X, y)
newX, _, _ = datasets.csv2numpy(
config.get('RandomForest_test', 'noveldata'))
prediction = self.rf.predict(newX)
self.rf.save_model(config.get('RandomForest_test', 'modelfile'))
newrf = RandomForest()
newrf.load_model(config.get('RandomForest_test', 'modelfile'))
self.assertTrue(numpy.array_equal(prediction, newrf.predict(newX)))
os.remove(config.get('RandomForest_test', 'modelfile'))
def main():
random.seed(0)
parser = ArgumentParser()
parser.add_argument('--plot', help='Where to save plot (file name)',
default=False)
parser.add_argument('--show', help='Show plot in a window', default=False,
action='store_true')
args = parser.parse_args()
print 'Loading training data from CSV...'
tr_data, tr_labels, _ = csv2numpy(config.get('datasets', 'contagio'))
print 'Loading test data from CSV...'
te_data, te_labels, te_fnames = csv2numpy(config.get('datasets',
'contagio_test'))
print 'Evaluating...'
scores = fig9(tr_data, tr_labels, te_data, te_labels, te_fnames)
if not (args.plot or args.show):
return 0
# Plot
feat_points, file_points = zip(*scores)
fig = pyplot.figure()
pyplot.plot(feat_points, label='Feature space',
marker='o', color='k', linewidth=2)
pyplot.plot(file_points, label='Problem space',
marker='^', color='k', linewidth=2, linestyle='--')
axes = fig.gca()
# Set up axes and labels
axes.yaxis.set_ticks([r / 10.0 for r in range(11)])
axes.yaxis.grid()
axes.set_ylim(0, 1)
axes.set_ylabel('Accuracy')
xticklabels = [common.top_feats[0]] + ['(+) ' + name
for name in common.top_feats[1:]]
axes.set_xticklabels(xticklabels, rotation=60, ha='right')
fig.subplots_adjust(bottom=0.34, top=0.95, left=0.11, right=0.98)
pyplot.legend(loc='lower left')
if args.show:
pyplot.show()
if args.plot:
pyplot.savefig(args.plot, dpi=300, bbox_inches='tight')
return 0
def _learn_model(scenario_name):
'''
Learns a classifier model for the specified scenario if one does
not already exist.
'''
scenario = _scenarios[scenario_name]
if path.exists(scenario['model']):
return
print 'Training the model for scenario {}...'.format(scenario_name)
# Decide on classifier
classifier = 0
if scenario['classifier'] == 'rf':
classifier = RandomForest()
sys.stdout.write('TRAINING RANDOM FOREST\n')
cutoff = [c * 0.1 for c in range(1, 10)]
elif scenario['classifier'] == 'svm':
classifier = sklearn_SVC(kernel='rbf', C=10, gamma=0.01)
sys.stdout.write('TRAINING SVM\n')
cutoff = [0.0]
# Load the required dataset and train the model
X, y, _ = datasets.csv2numpy(scenario['training'])
classifier.fit(X, y)
# Evaluate the model on the training dataset
y_pred = classifier.decision_function(X)
sys.stdout.write('Performance on training data:\n')
utility.print_stats_cutoff(y, y_pred, cutoff)
# Save the model in the corresponding file
classifier.save_model(scenario['model'])
def _learn_model(scenario_name):
'''
Learns a classifier model for the specified scenario if one does
not already exist.
'''
scenario = _scenarios[scenario_name]
if path.exists(scenario['model']):
return
print 'Training the model for scenario {}...'.format(scenario_name)
# Decide on classifier
classifier = 0
if scenario['classifier'] == 'rf':
classifier = RandomForest()
sys.stdout.write('TRAINING RANDOM FOREST\n')
cutoff = [c * 0.1 for c in range(1, 10)]
elif scenario['classifier'] == 'svm':
classifier = sklearn_SVC(kernel='rbf', C=10, gamma=0.01)
sys.stdout.write('TRAINING SVM\n')
cutoff = [0.0]
# Load the required dataset and train the model
X, y, _ = datasets.csv2numpy(scenario['training'])
classifier.fit(X, y)
# Evaluate the model on the training dataset
y_pred = classifier.decision_function(X)
sys.stdout.write('Performance on training data:\n')
utility.print_stats_cutoff(y, y_pred, cutoff)
# Save the model in the corresponding file
classifier.save_model(scenario['model'])
def main():
random.seed(0)
parser = ArgumentParser()
parser.add_argument("--plot", help="Where to save plot (file name)", default=False)
parser.add_argument("--show", help="Show plot in a window", default=False)
args = parser.parse_args()
print "Loading training data from CSV..."
tr_data, tr_labels, tr_fnames = csv2numpy(config.get("datasets", "contagio"))
print "Loading test data from CSV..."
te_data, te_labels, _ = csv2numpy(config.get("datasets", "contagio_test"))
print "Evaluating..."
scores = fig11(tr_data, tr_labels, te_data, te_labels, tr_fnames)
if not (args.plot or args.show):
return 0
# Plot
original, our_mimicry = zip(*scores)
fig = pyplot.figure()
pyplot.plot(original, label="Clean data", marker="o", color="k", linewidth=2)
pyplot.plot(our_mimicry, label="Our mimicry", marker="+", color="k", linewidth=2, linestyle=":")
axes = fig.gca()
# Set up axes and labels
axes.yaxis.set_ticks([r / 10.0 for r in range(11)])
axes.yaxis.grid()
axes.set_ylim(0, 1)
axes.set_ylabel("Accuracy")
xticklabels = ["0", "0.05", "0.1", "0.5", "1", "5", "10", "50", "100"]
axes.set_xticklabels(xticklabels, rotation=0)
axes.set_xlabel("Training set perturbation (%)")
fig.subplots_adjust(bottom=0.13, top=0.95, left=0.11, right=0.96)
pyplot.legend(loc="lower right")
if args.show:
pyplot.show()
if args.plot:
pyplot.savefig(args.plot, dpi=300, bbox_inches="tight")
return 0
def test_fit(self):
X, y, _ = datasets.csv2numpy(
config.get('RandomForest_test', 'traindata'))
self.rf.fit(X, y)
def attack_mimicry(scenario_name, plot=False):
'''
Invokes the mimcry attack for the given scenario and saves the
resulting attack files in the location specified by the
configuration file. If plot evaluates to True, saves the resulting
plot into the specified file, otherwise shows the plot in a window.
'''
# Configuration (should be mofified here)
target_files = "replace with the path to the .csv of the pdfrateR benign files in the training data (without standardizartion)"
is_binary = "set it to be true if pdfrateB is to be evaluated"
scaler_path = "replaced with the path to the scaler"
training_data_path = "replaced with the path to .csv of the standardized training data of pdfrateR"
X_train, y_train, _ = datasets.csv2numpy(training_data_path)
test_data_path = "replaced with the path to .csv of the standardized training data of pdfrateB"
X_test, y_test, _ = datasets.csv2numpy(test_data_path)
n_trial = 30
model_path = "Replaced with the path to the model to be evaluated"
print 'Running the mimicry attack...'
#print("First train and test the target classifier")
#classifier = SVC(kernel='rbf', C=10, gamma=0.01)
#classifier.fit(X_train, y_train)
#y_pred = classifier.predict(X_test)
#print(confusion_matrix(y_pred, y_test))
print("First load the classifier")
classifier = pickle.load(open(model_path, 'r'))
scenario = _scenarios[scenario_name]
output_dir = config.get('results', '{}_mimicry'.format(scenario_name))
# Make results reproducible
random.seed(0)
# Get the most 30 benign files
ben_file_paths = target_files
X_ben, y_ben, ben_paths = datasets.csv2numpy(ben_file_paths)
scaler = pickle.load(open(scaler_path))
X_ben_copy = copy.deepcopy(X_ben)
X_ben_scaled = scaler.transform(X_ben)
y_score_ben = classifier.decision_function(X_ben_scaled)
most_ben_ind = y_score_ben.argsort()[:n_trial]
y_score_most_ben = y_score_ben[most_ben_ind]
print(most_ben_ind)
print("The ave score of the most 30 benign: {}".format(
numpy.mean(y_score_most_ben)))
print("The ave score of the benign: {}".format(numpy.mean(y_score_ben)))
target_vectors = X_ben_copy[most_ben_ind]
target_paths = list(numpy.array(ben_paths)[most_ben_ind])
# Load benign files
print("Loading the most benign files as targets")
#print 'Loading attack targets from file "{}"'.format(target_files)
#target_vectors, _, target_paths = datasets.csv2numpy(target_files)
targets = zip(target_paths, target_vectors)
# Load malicious files
wolves = config.get('experiments', 'contagio_attack_pdfs')
if not path.exists(wolves):
_attack_files_missing(wolves)
print 'Loading attack samples from file "{}"'.format(wolves)
malicious = sorted(utility.get_pdfs(wolves))
if not malicious:
_attack_files_missing(wolves)
# Standardize data points if necessary
scaler = None
if 'scaled' in scenario['model']:
scaler = pickle.load(open(scaler_path))
print 'Using scaler'
# Set up multiprocessing
pool = multiprocessing.Pool()
pargs = [(mal, targets, classifier, scaler, is_binary)
for mal in malicious]
print 'Running the attack...'
for wolf_path, res in zip(malicious, pool.imap(_mimicry_wrap, pargs)):
if isinstance(res, Exception):
print res
continue
(target_path, mimic_path, mimic_score, wolf_score) = res
'''
print 'Modifying {p} [{s}]:'.format(p=wolf_path, s=wolf_score)
print ' BEST: {p} [{s}]'.format(p=target_path, s=mimic_score)
if path.dirname(mimic_path) != output_dir:
print ' Moving best to {}\n'.format(path.join(output_dir,
path.basename(mimic_path)))
shutil.move(mimic_path, output_dir)
'''
print 'Saved resulting attack files to {}'.format(output_dir)
def test_decision_function(self):
X, y, _ = datasets.csv2numpy(config.get('RandomForest_test', 'traindata'))
self.rf.fit(X, y)
newX, _, _ = datasets.csv2numpy(config.get('RandomForest_test', 'noveldata'))
self.assertTrue(len(self.rf.decision_function(newX)) == 20)
def attack_mimicry(scenario_name, plot=False):
'''
Invokes the mimcry attack for the given scenario and saves the
resulting attack files in the location specified by the
configuration file. If plot evaluates to True, saves the resulting
plot into the specified file, otherwise shows the plot in a window.
'''
print 'Running the mimicry attack...'
_initialize()
scenario = _scenarios[scenario_name]
output_dir = config.get('results', '{}_mimicry'.format(scenario_name))
# Make results reproducible
random.seed(0)
# Load benign files
print 'Loading attack targets from file "{}"'.format(scenario['targets'])
target_vectors, _, target_paths = datasets.csv2numpy(scenario['targets'])
targets = zip(target_paths, target_vectors)
# Load malicious files
wolves = config.get('experiments', 'contagio_attack_pdfs')
if not path.exists(wolves):
_attack_files_missing(wolves)
print 'Loading attack samples from file "{}"'.format(wolves)
malicious = sorted(utility.get_pdfs(wolves))
if not malicious:
_attack_files_missing(wolves)
# Set up classifier
classifier = 0
if scenario['classifier'] == 'rf':
classifier = RandomForest()
print 'ATTACKING RANDOM FOREST'
elif scenario['classifier'] == 'svm':
classifier = sklearn_SVC()
print 'ATTACKING SVM'
print 'Loading model from "{}"'.format(scenario['model'])
classifier.load_model(scenario['model'])
# Standardize data points if necessary
scaler = None
if 'scaled' in scenario['model']:
scaler = pickle.load(open(config.get('datasets', 'contagio_scaler')))
print 'Using scaler'
# Set up multiprocessing
pool = multiprocessing.Pool()
pargs = [(mal, targets, classifier, scaler) for mal in malicious]
if plot:
pyplot.figure(1)
print 'Running the attack...'
for wolf_path, res in zip(malicious, pool.imap(_mimicry_wrap, pargs)):
if isinstance(res, Exception):
print res
continue
(target_path, mimic_path, mimic_score, wolf_score) = res
print 'Modifying {p} [{s}]:'.format(p=wolf_path, s=wolf_score)
print ' BEST: {p} [{s}]'.format(p=target_path, s=mimic_score)
if path.dirname(mimic_path) != output_dir:
print ' Moving best to {}\n'.format(path.join(output_dir,
path.basename(mimic_path)))
shutil.move(mimic_path, output_dir)
if plot:
pyplot.plot([wolf_score, mimic_score])
print 'Saved resulting attack files to {}'.format(output_dir)
if plot:
pyplot.title('Mimicry attack')
axes = pyplot.axes()
axes.set_xlabel('Iterations')
axes.set_ylabel('Classifier score')
axes.yaxis.grid()
fig = pyplot.gcf()
fig.set_size_inches(6, 4.5)
fig.subplots_adjust(bottom=0.1, top=0.92, left=0.1, right=0.96)
if plot == 'show':
pyplot.show()
else:
pyplot.savefig(plot, dpi=300)
print 'Saved plot to file {}'.format(plot)
def attack_gdkde(scenario_name, plot=False):
'''
Invokes the GD-KDE attack for the given scenario and saves the
resulting attack files in the location specified by the
configuration file. If plot evaluates to True, saves the resulting
plot into the specified file, otherwise shows the plot in a window.
'''
print 'Running the GD-KDE attack...'
_initialize()
scenario = _scenarios[scenario_name]
output_dir = config.get('results', '{}_gdkde'.format(scenario_name))
# Make results reproducible
random.seed(0)
# Load and print malicious files
wolves = config.get('experiments', 'contagio_attack_pdfs')
if not path.exists(wolves):
_attack_files_missing(wolves)
print 'Loading attack samples from "{}"'.format(wolves)
malicious = utility.get_pdfs(wolves)
if not malicious:
_attack_files_missing(wolves)
# Load an SVM trained with scaled data
scaler = pickle.load(open(
config.get('datasets', 'contagio_scaler')))
print 'Using scaler'
svm = sklearn_SVC()
print 'Loading model from "{}"'.format(scenario['model'])
svm.load_model(scenario['model'])
# Load the training data used for kernel density estimation
print 'Loading dataset from file "{}"'.format(scenario['training'])
X_train, y_train, _ = datasets.csv2numpy(scenario['training'])
# Subsample for faster execution
ind_sample = random.sample(range(len(y_train)), 500)
X_train = X_train[ind_sample, :]
y_train = y_train[ind_sample]
# Set parameters
kde_reg = 10
kde_width = 50
step = 1
max_iter = 50
# Set up multiprocessing
pool = multiprocessing.Pool()
pargs = [(svm, fname, scaler, X_train, y_train, kde_reg,
kde_width, step, max_iter, False) for fname in malicious]
if plot:
pyplot.figure(1)
print 'Running the attack...'
for res, oldf in zip(pool.imap(_gdkde_wrapper, pargs), malicious):
if isinstance(res, Exception):
print res
continue
(_, fseq, _, _, attack_file) = res
print 'Processing file "{}":'.format(oldf)
print ' scores: {}'.format(', '.join([str(s) for s in fseq]))
print 'Result: "{}"'.format(attack_file)
if path.dirname(attack_file) != output_dir:
shutil.move(attack_file, output_dir)
if plot:
pyplot.plot(fseq, label=oldf)
print 'Saved resulting attack files to {}'.format(output_dir)
if plot:
pyplot.title('GD-KDE attack')
axes = pyplot.axes()
axes.set_xlabel('Iterations')
axes.set_xlim(0, max_iter + 1)
axes.set_ylabel('SVM score')
axes.yaxis.grid()
fig = pyplot.gcf()
fig.set_size_inches(6, 4.5)
fig.subplots_adjust(bottom=0.1, top=0.92, left=0.1, right=0.96)
if plot == 'show':
pyplot.show()
else:
pyplot.savefig(plot, dpi=300)
print 'Saved plot to file {}'.format(plot)
if model_name == '1':
model = Model1()
save_model_name = './Model1.h5'
elif model_name == '2':
model = Model2()
save_model_name = './Model2.h5'
elif model_name == '3':
model = Model3()
save_model_name = './Model3.h5'
else:
print(bcolors.FAIL + 'invalid model name, must one of 1, 2 or 3' +
bcolors.ENDC)
# the data, shuffled and split between train and test sets
X_train, y_train, _ = datasets.csv2numpy('./dataset/train.csv')
X_test, y_test, _ = datasets.csv2numpy('./dataset/test.csv')
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
y_train = y_train.astype('int')
y_test = y_test.astype('int')
y_train = to_categorical(y_train, 2)
y_test = to_categorical(y_test, 2)
# trainig
model.fit(X_train,
y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
validation_data=(X_test, y_test),
def test_fit(self):
X, y, _ = datasets.csv2numpy(config.get('RandomForest_test', 'traindata'))
self.rf.fit(X, y)
def test_predict(self):
X, y, _ = datasets.csv2numpy(config.get('RandomForest_test', 'traindata'))
self.rf.fit(X, y)
newX, _, _ = datasets.csv2numpy(config.get('RandomForest_test', 'noveldata'))
self.assertTrue(len(self.rf.predict(newX)) == 20)
def test_decision_function(self):
X, y, _ = datasets.csv2numpy(config.get('sklearn_SVC_test', 'traindata'))
self.svc.fit(X, y)
newX, _, _ = datasets.csv2numpy(config.get('sklearn_SVC_test', 'noveldata'))
self.assertTrue(len(self.svc.decision_function(newX)) == 20)
def attack_gdkde(scenario_name, plot=False):
'''
Invokes the GD-KDE attack for the given scenario and saves the
resulting attack files in the location specified by the
configuration file. If plot evaluates to True, saves the resulting
plot into the specified file, otherwise shows the plot in a window.
'''
print 'Running the GD-KDE attack...'
_initialize()
scenario = _scenarios[scenario_name]
output_dir = config.get('results', '{}_gdkde'.format(scenario_name))
# Make results reproducible
random.seed(0)
# Load and print malicious files
wolves = config.get('experiments', 'contagio_attack_pdfs')
if not path.exists(wolves):
_attack_files_missing(wolves)
print 'Loading attack samples from "{}"'.format(wolves)
malicious = utility.get_pdfs(wolves)
if not malicious:
_attack_files_missing(wolves)
# Load an SVM trained with scaled data
scaler = pickle.load(open(config.get('datasets', 'contagio_scaler')))
print 'Using scaler'
svm = sklearn_SVC()
print 'Loading model from "{}"'.format(scenario['model'])
svm.load_model(scenario['model'])
# Load the training data used for kernel density estimation
print 'Loading dataset from file "{}"'.format(scenario['training'])
X_train, y_train, _ = datasets.csv2numpy(scenario['training'])
# Subsample for faster execution
ind_sample = random.sample(range(len(y_train)), 500)
X_train = X_train[ind_sample, :]
y_train = y_train[ind_sample]
# Set parameters
kde_reg = 10
kde_width = 50
step = 1
max_iter = 50
# Set up multiprocessing
pool = multiprocessing.Pool()
pargs = [(svm, fname, scaler, X_train, y_train, kde_reg, kde_width, step,
max_iter, False) for fname in malicious]
if plot:
pyplot.figure(1)
print 'Running the attack...'
for res, oldf in zip(pool.imap(_gdkde_wrapper, pargs), malicious):
if isinstance(res, Exception):
print res
continue
(_, fseq, _, _, attack_file) = res
print 'Processing file "{}":'.format(oldf)
print ' scores: {}'.format(', '.join([str(s) for s in fseq]))
print 'Result: "{}"'.format(attack_file)
if path.dirname(attack_file) != output_dir:
shutil.move(attack_file, output_dir)
if plot:
pyplot.plot(fseq, label=oldf)
print 'Saved resulting attack files to {}'.format(output_dir)
if plot:
pyplot.title('GD-KDE attack')
axes = pyplot.axes()
axes.set_xlabel('Iterations')
axes.set_xlim(0, max_iter + 1)
axes.set_ylabel('SVM score')
axes.yaxis.grid()
fig = pyplot.gcf()
fig.set_size_inches(6, 4.5)
fig.subplots_adjust(bottom=0.1, top=0.92, left=0.1, right=0.96)
if plot == 'show':
pyplot.show()
else:
pyplot.savefig(plot, dpi=300)
print 'Saved plot to file {}'.format(plot)
def attack_mimicry(scenario_name, plot=False):
'''
Invokes the mimcry attack for the given scenario and saves the
resulting attack files in the location specified by the
configuration file. If plot evaluates to True, saves the resulting
plot into the specified file, otherwise shows the plot in a window.
'''
print 'Running the mimicry attack...'
_initialize()
scenario = _scenarios[scenario_name]
output_dir = config.get('results', '{}_mimicry'.format(scenario_name))
# Make results reproducible
random.seed(0)
# Load benign files
print 'Loading attack targets from file "{}"'.format(scenario['targets'])
target_vectors, _, target_paths = datasets.csv2numpy(scenario['targets'])
targets = zip(target_paths, target_vectors)
# Load malicious files
wolves = config.get('experiments', 'contagio_attack_pdfs')
if not path.exists(wolves):
_attack_files_missing(wolves)
print 'Loading attack samples from file "{}"'.format(wolves)
malicious = sorted(utility.get_pdfs(wolves))
if not malicious:
_attack_files_missing(wolves)
# Set up classifier
classifier = 0
if scenario['classifier'] == 'rf':
classifier = RandomForest()
print 'ATTACKING RANDOM FOREST'
elif scenario['classifier'] == 'svm':
classifier = sklearn_SVC()
print 'ATTACKING SVM'
print 'Loading model from "{}"'.format(scenario['model'])
classifier.load_model(scenario['model'])
# Standardize data points if necessary
scaler = None
if 'scaled' in scenario['model']:
scaler = pickle.load(open(config.get('datasets', 'contagio_scaler')))
print 'Using scaler'
# Set up multiprocessing
pool = multiprocessing.Pool()
pargs = [(mal, targets, classifier, scaler) for mal in malicious]
if plot:
pyplot.figure(1)
print 'Running the attack...'
for wolf_path, res in zip(malicious, pool.imap(_mimicry_wrap, pargs)):
if isinstance(res, Exception):
print res
continue
(target_path, mimic_path, mimic_score, wolf_score) = res
print 'Modifying {p} [{s}]:'.format(p=wolf_path, s=wolf_score)
print ' BEST: {p} [{s}]'.format(p=target_path, s=mimic_score)
if path.dirname(mimic_path) != output_dir:
print ' Moving best to {}\n'.format(
path.join(output_dir, path.basename(wolf_path)))
shutil.move(mimic_path,
path.join(output_dir, path.basename(wolf_path)))
if plot:
pyplot.plot([wolf_score, mimic_score])
print 'Saved resulting attack files to {}'.format(output_dir)
if plot:
pyplot.title('Mimicry attack')
axes = pyplot.axes()
axes.set_xlabel('Iterations')
axes.set_ylabel('Classifier score')
axes.yaxis.grid()
fig = pyplot.gcf()
fig.set_size_inches(6, 4.5)
fig.subplots_adjust(bottom=0.1, top=0.92, left=0.1, right=0.96)
if plot == 'show':
pyplot.show()
else:
pyplot.savefig(plot, dpi=300)
print 'Saved plot to file {}'.format(plot)
def test_fit(self):
X, y, _ = datasets.csv2numpy(config.get('sklearn_SVC_test', 'traindata'))
self.svc.fit(X, y)
