def launch_targeted_attack(type=1, tab=1, anon="no_anon"):
"""
Params :
'type' is the attack variety among noise-exploitation family
'tab' referes to the targeted table
'anon' refers to the anonymization method
"""
# specify target configuration
# set anonymization algorithm
config['anonTypes'][0] = anon_types_all[anon]
# set target table
config['tables'][0] = tables_all[tab]
# set attack type
if attack_type == 1:
attack_type = "differential"
config['basic'][
'attackType'] = "Differential noise-exploitation Attack"
# set appropriate specific parameters
#scheme = get_database_scheme(params, verbose)
elif attack_type == 2:
attack_type = "cloning"
config['basic']['attackType'] = "Cloning noise-exploitation Attack"
elif attack_type == 3:
attack_type = "greedy"
config['basic']['attackType'] = "Greedy cloning Attack"
# set general configuration parameters
paramsList = setupGdaAttackParameters(config)
params = paramsList[0]
# launch attack
print(f"\nInfo >>> Launching {attack_type} attack ...")
print(
f"... targeting {config['tables'][0]} anonymized with {config['anonTypes'][0]}\n"
)
noise_exploitation_attack(attack_type, params, verbose)
def differential_automatic():
attack_type = "differential"
config['basic']['attackType'] = "Differential noise-exploitation Attack"
for tab in tables_all:
config['tables'][0] = tab
for anon in anon_types_all:
config['anonTypes'][0] = anon
# set general configuration parameters
paramsList = setupGdaAttackParameters(config)
params = paramsList[0]
# get scheme and gather specific parameters first
print(f"Info >>> Getting schema for {config['tables']} ...\n")
scheme = get_database_scheme(params, verbose)
spec_params = [scheme[1].keys()]
for c in scheme[0].keys():
spec_params.append(c)
# launch attack
print(f"\nInfo >>> Launching {attack_type} attack ...")
print(
f"... targeting {config['tables'][0]} anonymized with {config['anonTypes'][0]}"
)
print(f"... targeting column {c}\n")
noise_exploitation_attack(attack_type, params, verbose,
spec_params)
#"criteria": "linkability"
},
'anonTypes': [
#["no_anon"],
#["pseudonymization", "latest"],
#["diffix","latest"],
#["diffix","v19_1_0"],
#["k_anonymization","naive","k_2"],
#["k_anonymization","naive","k_5"],
#["pseudonymization","colSuppression"], # problem to investigate
["pseudonymization", "kanon", "k_2"],
#["pseudonymization","kanon","k_5"]
],
'tables': [
#['banking','accounts'],
#['banking','loans'],
#['banking','transactions'],
#['taxi','rides'],
#['census','persons'],
['scihub', 'downloads']
]
}
# set general configuration parameters
paramsList = setupGdaAttackParameters(config)
params = paramsList[0]
# launch attack
verbose = False
distance_attack(params, verbose)
# ------------------- Scores Phase ----------------------------
attackResult = attack.getResults()
sc = gdaScores(attackResult)
score = sc.getScores()
if v: pp.pprint(score)
attack.cleanUp()
final = finishGdaAttack(params, score)
pp.pprint(final)
# This reads in the attack parameters and checks to see if the
# attack has already been run and completed
verbose = False
v = verbose
paramsList = setupGdaAttackParameters(
sys.argv,
criteria="linkability",
attackType="Simple List Linkability Attack")
for params in paramsList:
params['verbose'] = doVerbose
if params['finished'] == True:
print("The following attack has been previously completed:")
print(f"Results may be found at {params['resultsPath']}")
continue
print("Running attack with following parameters:")
pp.pprint(params)
dumb_list_linkability_attack(params)
numRows = reply['answer'][0][0]
if v: print("-------------------- Explore reply:")
if v: pp.pprint(reply)
susValue = numRows / totalRows
sc.assignColumnSusceptibility(guessedCol, susValue)
# Get average score (default behavior)
score = sc.getScores()
if v: pp.pprint(score)
score = sc.getScores(numColumns=1)
if v: pp.pprint(score)
attack.cleanUp(cleanUpCache=False)
final = finishGdaAttack(params, score)
pp.pprint(final)
# This reads in the attack parameters and checks to see if the
# attack has already been run and completed
paramsList = setupGdaAttackParameters(
sys.argv, criteria="inference", attackType="Inference Attack on Diffix 1")
for params in paramsList:
if params['finished'] == True:
print("The following attack has been previously completed:")
pp.pprint(params)
print(f"Results may be found at {params['resultsPath']}")
continue
print("Running attack with following parameters:")
pp.pprint(params)
diffix_infer_1_attack(params)
import sys
from gdascore.gdaTools import setupGdaAttackParameters
from utility.gdaUtility import gdaUtility
import pprint
pp = pprint.PrettyPrinter(indent=4)
gdaUtilityObj = gdaUtility()
paramsList = setupGdaAttackParameters(sys.argv)
print(f" param list:")
pp.pprint(paramsList)
for param in paramsList:
print("Start next param")
if param['finished'] == True:
print("The following Utility measure has been previously completed:")
pp.pprint(param)
print(f"Results may be found at {param['resultsPath']}")
continue
res = gdaUtilityObj.distinctUidUtilityMeasureSingleAndDoubleColumn(param)
if res is None:
print("Unable to complete.")
pp.pprint(param)
continue
print("Finish up")
gdaUtilityObj.finishGdaUtility(param)
doQueryErrorAndExit(reply,attack)
numRows = reply['answer'][0][0]
if v: print("-------------------- Explore reply:")
if v: pp.pprint(reply)
susValue = numRows / totalRows
sc.assignColumnSusceptibility(guessedCol,susValue)
score = sc.getScores()
if v: pp.pprint(score)
final = finishGdaAttack(params,score)
attack.cleanUp()
pp.pprint(final)
# This reads in the attack parameters and checks to see if the
# attack has already been run and completed
verbose = False
v = verbose
paramsList = setupGdaAttackParameters(sys.argv, criteria="inference",
attackType = "Simple List Inference Attack")
for params in paramsList:
params['verbose'] = doVerbose
if params['finished'] == True:
print("The following attack has been previously completed:")
pp.pprint(params)
print(f"Results may be found at {params['resultsPath']}")
continue
print("Running attack with following parameters:")
pp.pprint(params)
dumb_list_inference_attack(params)
