def test0_read(self):
self.write(self.string1, self.tempf)
_cfg = Configuration()
self.assertRaises(ValueError, _cfg.read, self.tempf)
self.write(self.string2, self.tempf)
_cfg.clear()
self.assertEqual(None, _cfg.read(self.tempf))
def get_block(block_hash):
"""
Gets a block
:param block_hash: the block hash
:return: block
"""
if block_hash == '':
conf = Configuration()
block_hash = conf.get_conf("last_block")
return read_block(block_hash)
def get_block(block_hash):
"""
Gets a block
:param block_hash: the block hash
:return: block
"""
if block_hash == '':
conf = Configuration()
block_hash = conf.get_conf("last_block")
return read_block(block_hash)
def setUpClass(self):
print("---------------------------------------Tests---------------------------------------\nProduct Name: Visa Direct\nApi Name: Watch List Screening API")
globalConfig = GlobalConfig()
config = Configuration()
config.username = globalConfig.userName
config.password = globalConfig.password
config.cert_file = globalConfig.certificatePath
config.key_file = globalConfig.privateKeyPath
config.shared_secret = globalConfig.sharedSecret
config.api_key['apikey'] = globalConfig.apiKey
config.ssl_ca_cert = globalConfig.caCertPath
config.proxy_url = globalConfig.proxyUrl
self.api = WsApi(None)
def test2_get_config_simulation(self):
_cfg = Configuration()
_cfg.read(self.tempf)
self.assertRaises(ValueError, _cfg.get_config, "simulation")
self.string2 = re.sub(r"= mode", r"= simulation", self.string2)
self.write(self.string2, self.tempf)
_cfg.clear()
_cfg.read(self.tempf)
self.assertTrue("path" in _cfg.get_config("simulation"))
def setUpClass(self):
print(
"---------------------------------------Tests---------------------------------------\nProduct Name: Payment Account Validation\nApi Name: Payment Account Validation API"
)
globalConfig = GlobalConfig()
config = Configuration()
config.username = globalConfig.userName
config.password = globalConfig.password
config.cert_file = globalConfig.certificatePath
config.key_file = globalConfig.privateKeyPath
config.shared_secret = globalConfig.sharedSecret
config.api_key['apikey'] = globalConfig.apiKey
config.ssl_ca_cert = globalConfig.caCertPath
config.proxy_url = globalConfig.proxyUrl
self.api = PavApi(None)
def post(res, body):
h = urllib.request.Request(
Configuration()['proxy-cli.base-addr'] + res,
data = json.dumps(str(body)).encode(),
headers={'Content-Type': 'application/json'}
)
return urllib.request.urlopen(h).read()
def setUp(self):
self.stdout = sys.stdout
self.obj = Configuration()
self.tempf = "./temp.test_cfg"
self.string1 = ("[foo]\n"
"foo = bar\n")
self.string2 = self.gen_configs()
sys.stdout = cStringIO.StringIO()
def create_transaction(recipient, amount):
"""
creates a new transaction and add it to verified_transactions.json
:param recipient: public address of the recipient
:param amount: the amount of abc to be sent
:return: None
"""
# TODO: Send a success message to client
conf = Configuration()
try:
tx = Transaction()
tx.add_output(recipient, amount)
tx.unlock_inputs(get_private_key(), get_public_key("string"))
save_verified_transaction(tx.get_transaction_id(), tx.get_data())
conf.subtract_balance(tx.sum_of_outputs())
except ValueError as e:
# Will raise if insufficient utxos are found
raise ValueError("INSUFFICIENT FUNDS")
def create_transaction(recipient, amount):
"""
creates a new transaction and add it to verified_transactions.json
:param recipient: public address of the recipient
:param amount: the amount of abc to be sent
:return: None
"""
# TODO: Send a success message to client
conf = Configuration()
try:
tx = Transaction()
tx.add_output(recipient, amount)
tx.unlock_inputs(get_private_key(), get_public_key("string"))
save_verified_transaction(tx.get_transaction_id(), tx.get_data())
conf.subtract_balance(tx.sum_of_outputs())
except ValueError as e:
# Will raise if insufficient utxos are found
raise ValueError("INSUFFICIENT FUNDS")
def mine():
# config object
conf = Configuration()
# Mines block
reward_address = conf.get_conf("wallet").get("address")
reward_amount = conf.get_conf("reward")
size = 0 # TODO: fix this
# 2) bundle transactions
tnx = bundle_tnx(size, reward_amount)
b = Block(previous_hash=conf.get_conf("last_block"), transactions=tnx)
b.set_target(conf.get_conf("difficulty"))
b.mine()
save_block(b)
conf.increment_height()
conf.update_previous_hash(b.block_hash())
find_incoming_utxos(b.block_hash(), b.transactions)
def read_all_genotypes_per_generation(config_dir: str, results_dir: str,
experiment_name: str):
import os, pickle
print(f"Loading {experiment_name}")
config = Configuration.from_json(os.path.join(
config_dir, f"{experiment_name}.json"),
validation=False)
experiment_results = os.path.join(results_dir, experiment_name)
# Read all genotypes first
population = []
patterns = []
files = find_filetype_recursivly(experiment_results, filetype=".obj")
for file_path in files:
with open(file_path, "rb") as ptr:
obj = pickle.load(ptr)
if not isinstance(obj, Pattern):
population += [obj]
else:
patterns += [obj]
print(
f" - Reading files, {(len(population) + len(patterns)) / len(files) * 100:.0f}% complete"
+ "\t" * 3,
end="\r",
)
print()
# Map genotype to generation
generations = []
pattern_generations = []
directory = os.path.join(experiment_results, "generations")
gens = [
int(generation) for generation in os.listdir(directory)
if isint(generation)
]
gens.sort()
for gen in gens:
gen_dir = os.path.join(directory, str(gen))
generation = []
p_generation = []
for identifier in os.listdir(gen_dir):
identifier = identifier.strip("'")
for ind in population:
if ind.ID == identifier:
generation += [ind]
break
else:
for ind in patterns:
if ind.ID == identifier:
p_generation += [ind]
break
generations += [generation]
pattern_generations += [p_generation]
print(" - population sorted into generations")
return Simulation(config, population, generations, patterns,
pattern_generations)
def find_incoming_utxos(block_hash, transactions, isGenesis=False):
"""
Iterates through all the outputs and looks for any directed to user's wallet.
If found, save to the utxo pool
:return:
"""
myAddress = SHA256.new(get_public_key("string").encode()).hexdigest()
conf = Configuration()
for tnx_id, tnx_info in transactions.items():
# deserialize transaction
tnx_payload = tnx_info
tnx_payload["transaction_id"] = tnx_id
tnx = Transaction(payload=tnx_payload)
for index in range(len(tnx.outputs)):
if tnx.outputs[index]["address"] == myAddress and not isGenesis:
save_utxo(tnx.get_transaction_id(), index, block_hash, tnx.outputs[index]["amount"])
conf.add_balance(tnx.outputs[index]["amount"])
elif tnx.outputs[index]["address"] == myAddress and isGenesis:
save_utxo(tnx.get_transaction_id(), -1, block_hash, tnx.outputs[index]["amount"])
conf.add_balance(tnx.outputs[index]["amount"])
def mine():
# config object
conf = Configuration()
# Mines block
reward_address = conf.get_conf("wallet").get("address")
reward_amount = conf.get_conf("reward")
size = 0 # TODO: fix this
# 2) bundle transactions
tnx = bundle_tnx(size, reward_amount)
b = Block(previous_hash=conf.get_conf("last_block"), transactions=tnx)
b.set_target(conf.get_conf("difficulty"))
b.mine()
save_block(b)
conf.increment_height()
conf.update_previous_hash(b.block_hash())
find_incoming_utxos(b.block_hash(), b.transactions)
def try_finish(population: [Module], config: Configuration, moo_ops: callable) -> [Module]:
print(f"--> Possible final solution discovered. Checking...")
# Changing settings of training steps:
original_training_settings = copy.deepcopy(config.training)
config.training.use_restart = False
config.training.fixed_epochs = True
config.training.epochs = 100
# Finding the best networks:
best = population[:config.compute_capacity(maximum=False)]
# Performing training step:
best = workers.start(best, config)
# Reset settings and return:
config.training = original_training_settings
best.sort(key=weighted_overfit_score(config), reverse=True)
if any(ind.test_acc() >= config.training.acceptable_scores for ind in best):
generation_finished(best, config, "--> Found final solution:")
config.results.store_generation(best, config.generation + 1)
return best, True
else:
# A final solution was not found... Keep the best individs:
population = best + population
population = nsga_ii(
population,
moo_ops.classification_objectives(config),
moo_ops.classification_domination_operator(
moo_ops.classification_objectives(config)
),
config
)
keep = len(population) - config.population_size
population, removed = population[keep:], population[:keep]
generation_finished(population, config, "--> Leaderboards after final solution try failed:")
generation_finished(removed, config, "--> Removed after final solution try failed:")
return population, False
def test_normal(self, os_mock, date_mock):
os_mock.side_effect = self.os_environ
date_mock.utcnow.return_value = datetime(2018, 4, 21)
conf = Configuration()
eq_(conf.url, "url")
eq_(conf.icon, "icon")
eq_(conf.channel, "channel")
eq_(conf.bot_name, "name")
eq_(conf.threshold_good, 1)
eq_(conf.threshold_warn, 2)
eq_(conf.called_date, datetime(2018, 4, 21))
def test_normal_default(self, os_mock, date_mock):
os_mock.side_effect = self.os_environ_url_only
date_mock.utcnow.return_value = datetime(2018, 4, 21)
conf = Configuration()
eq_(conf.url, "url")
eq_(conf.icon, ":moneybag:")
eq_(conf.channel, None)
eq_(conf.bot_name, "aws cost report")
eq_(conf.threshold_good, 5.0)
eq_(conf.threshold_warn, 15.0)
eq_(conf.called_date, datetime(2018, 4, 21))
def setUpClass(cls):
# Create a network:
cls.patterns = initialize_patterns(count=5)
nets = recombine.combine(cls.patterns,
num_nets=1,
min_size=3,
max_size=5)
# Parameters:
cls.epochs = 1
server_id = 0
dev_id = 0
job_id = 0
# Setting necessary properties:
cls.net = nets[0]
cls.config = Configuration.from_json("./tests/fixtures/config.json")
cls.config.type = "PatternNets"
cls.training_args = (pickle.dumps(cls.net), pickle.dumps(cls.config),
cls.epochs, server_id, dev_id, job_id)
def setUpClass(self):
print(
"---------------------------------------Tests---------------------------------------\nProduct Name: Merchant Measurement\nApi Name: Merchant Benchmark API"
)
globalConfig = GlobalConfig()
config = Configuration()
config.username = globalConfig.userName
config.password = globalConfig.password
config.cert_file = globalConfig.certificatePath
config.key_file = globalConfig.privateKeyPath
# config.shared_secret = globalConfig.sharedSecret
# config.api_key['apikey'] = globalConfig.apiKey
# config.ssl_ca_cert = globalConfig.caCertPath
# config.proxy_url = globalConfig.proxyUrl
self.api = MerchantBenchmarkApi(None)
def main():
print("""*********************************************
Starting the Apartment Hunter
*********************************************""")
config = Configuration()
craigsLister = Craigslist(config.minPrice, config.maxPrice,
config.bedrooms, config.minSqft, config.maxSqft)
apartments = []
# For the list of neighbourhoods, append the list of apartments to the list
for neighbourhood in config.neighbourhoods:
apartments.extend(
craigsLister.getApartments(neighbourhood, config.pages))
# Make the list unique
temp = set(apartments)
uniqueApartments = list(temp)
# Sort the apartments based on ranking
uniqueApartments.sort(key=lambda x: x.ranking, reverse=True)
print(len(apartments), " apartments found in total.")
print(len(uniqueApartments), " unique apartments found in total.")
messenger = Messenger(config.email, config.password)
# Send the #1 ranked apartment as a text
messenger.sendTextMessageTMobile(config.phoneNumber,
str(uniqueApartments[0]))
# Send the top 10 in email
messenger.sendEmailMessage(
('<br/><br/>'.join(apt.formatForEmail()
for apt in uniqueApartments[:10])))
def init_configuration():
"""
This will instantiate the config class
and check if genesis block is created
:return: configuration object
"""
conf = Configuration()
block_height = conf.get_conf("height")
if block_height == 0:
b = genesis_block()
cwd = os.getcwd()
try:
os.makedirs(os.path.join(cwd, r'data'))
except OSError as e:
pass
save_block(b)
conf.increment_height()
conf.update_previous_hash(b.block_hash())
find_incoming_utxos(b.block_hash(), b.transactions, True)
return conf
def pooling(t):
# FIXME: dns is not yet ready.
global toSubmit
log(0, "Pooling using: " + PoolingLogs.poolingName(t))
d = None
if len(toSubmit) > 0:
d = toSubmit.pop()
print("Submitting: " + str(d))
res = request('/pool/' + Configuration()['node.id'], data=d)
j = json.loads(res)
for i in j:
if 'command' in i:
try:
jj = json.loads(i['command'])
if 'name' in jj and jj['name'] == "screenshot":
log(0, "Taking screenshot...")
d = {"cmd": i['id'], "data": take_screenshot()}
toSubmit.append(d)
print("adding to the list...")
except Exception as e:
print(str(e))
pass
else:
print(str(i))
def init_configuration():
"""
This will instantiate the config class
and check if genesis block is created
:return: configuration object
"""
conf = Configuration()
block_height = conf.get_conf("height")
if block_height == 0:
b = genesis_block()
cwd = os.getcwd()
try:
os.makedirs(os.path.join(cwd, r'data'))
except OSError as e:
pass
save_block(b)
conf.increment_height()
conf.update_previous_hash(b.block_hash())
find_incoming_utxos(b.block_hash(), b.transactions, True)
return conf
def find_incoming_utxos(block_hash, transactions, isGenesis=False):
"""
Iterates through all the outputs and looks for any directed to user's wallet.
If found, save to the utxo pool
:return:
"""
myAddress = SHA256.new(get_public_key("string").encode()).hexdigest()
conf = Configuration()
for tnx_id, tnx_info in transactions.items():
# deserialize transaction
tnx_payload = tnx_info
tnx_payload["transaction_id"] = tnx_id
tnx = Transaction(payload=tnx_payload)
for index in range(len(tnx.outputs)):
if tnx.outputs[index]["address"] == myAddress and not isGenesis:
save_utxo(tnx.get_transaction_id(), index, block_hash,
tnx.outputs[index]["amount"])
conf.add_balance(tnx.outputs[index]["amount"])
elif tnx.outputs[index]["address"] == myAddress and isGenesis:
save_utxo(tnx.get_transaction_id(), -1, block_hash,
tnx.outputs[index]["amount"])
conf.add_balance(tnx.outputs[index]["amount"])
#!/usr/bin/env python
from flask import Flask, redirect, request
app = Flask(__name__)
import sys, getopt, json
from playhouse.shortcuts import model_to_dict, dict_to_model
from datetime import date, datetime
from src.configuration import loadProxyConfig, Configuration
loadProxyConfig()
conf = Configuration()
from src.logger import log
from src.database import *
from src.utils import json_serial
@app.before_request
def before_request():
Database().connect()
@app.after_request
def after_request(response):
Database().close()
return response
@app.route('/pool/<node_id>', methods = ['POST', 'GET'])
def pool(node_id):
"""
"""
def give_configuration_object(layout_number, block_number):
layout_in_use = 'layout_' + str(layout_number)
exec('from src.layout import ' + layout_in_use)
environment_config = eval(layout_in_use + '[' + str(block_number) + ']')
ed = Configuration(env_config=environment_config)
return ed
def main(config: Configuration):
# 0.1 How many nets can be trained for each generation?
solved = False
compute_capacity = config.compute_capacity()
# 0.2 Initializing multi objective optimisation sorting:
moo_objectives = moo.classification_objectives(config)
domination_operator = moo.classification_domination_operator(
moo.classification_objectives(config))
patterns, nets = initialize_population(config, compute_capacity)
i = 0
while not solved:
# 3. Evolve for <x> generations:
for generation in range(config.generations * i,
config.generations * (i + 1)):
config.generation = generation
# 3.1 Select some patterns for mutation. Tournament
selected = selection.tournament(patterns,
size=int(len(patterns) / 2))
# 3.2 Perform Mutations + Crossover on selected patterns
mutations, crossovers = selection.divide(selected)
patterns = patterns + \
mutator.apply(mutations) + \
crossover.apply(crossovers)
# 3.3 Evaluate new patterns. Fitness calculation
nets = recombine.combine(patterns,
compute_capacity,
config.min_size,
config.max_size,
include_optimal=True)
nets = workers.start(nets, config)
patterns = evaluation.inherit_results(patterns, nets)
# 3.4 Rank all patterns using MOO. Diversity in position, 2D vs 1D, scores ++
patterns = nsga_ii(patterns, moo_objectives, domination_operator,
config)
# 3.5 Evolution of the fittest. Elitism
patterns = patterns[-config.population_size:]
# 3.6 Feedback:
print(f"--> Generation {generation} Leaderboards")
generation_finished(patterns, config, " - Patterns:")
generation_finished(nets, config, " - Neural networks:")
config.results.store_generation(patterns, generation)
config.results.store_generation(nets, generation)
# To finish up, the best combination of patterns needs to be returned and trained for
# much longer than what they are during fitness evaluation. The previous steps should only
# be used for verifying that the combination of layers is good.
#
# This might need to be tried multiple times. When a good result is gotten, the algorithm should
# stop and return the final structure with trained weights.
print("Testing best combination of patterns")
# Changing settings of training steps:
original_training_settings = copy.deepcopy(config.training)
config.training.use_restart = False
config.training.fixed_epochs = True
config.training.epochs = 300
# Finding the best combined network:@
config.type = "ea-nas"
nets.sort(key=weighted_overfit_score(config), reverse=True)
config.type = "PatternNets"
best_net = nets[-1]
# Performing training step:
best_net = workers.start([best_net], config)[0]
# Reset settings and return:
config.training = original_training_settings
if best_net.test_acc() >= config.training.acceptable_scores:
print("Found good network! ")
solved = True
config.type = "ea-nas"
generation_finished([best_net], config, "--> Found final solution:")
config.type = "PatternNets"
patterns = evaluation.inherit_results(patterns, nets)
i += 1
from __future__ import print_function
import time
from src.apis.merchant_benchmark_api import MerchantBenchmarkApi
from src.configuration import Configuration
config = Configuration()
# Uncomment this block to enable proxy
# config.proxy_url = 'PROXY_URL'
# Configure HTTP basic authorization: basicAuth
config.username = '******'
config.password = '******'
config.cert_file = 'ABSOLUTE_PATH_TO_CERT_FILE'
config.key_file = 'ABSOLUTE_PATH_TO_KEY_FILE'
config.ssl_ca_cert = 'ABSOLUTE_PATH_TO_CA_CERT_FILE'
# Unblock this block to configure MLE credentials
# config.api_key['keyId'] = 'YOUR_KEY_ID'
# config.encryption_public_key_path = 'ABSOLUTE_PATH_TO_MLE_CERT_FILE'
# config.decryption_private_key_path = 'ABSOLUTE_PATH_TO_MLE_KEY_FILE'
# create an instance of the API class
api_instance = MerchantBenchmarkApi()
# Set all the required parameters in the postmerchant_benchmark. Look at the documentation for further clarification.
merchant_benchmarkpost_payload = src.MerchantBenchmarkpostPayload(
) # MerchantBenchmarkpostPayload | Merchant Benchmark request payload
try:
api_response = api_instance.postmerchant_benchmark(
merchant_benchmarkpost_payload)
from flask.ext.api import FlaskAPI, status, exceptions
from src.configuration import Configuration
from src.validation.validation_handler import initialize_validators as hook_validators
# Initialize Flask API.
app = FlaskAPI(__name__.split('.')[0], static_url_path='/')
# Get routes.
from src.routes import route
# Acquire controllers.
from src.controllers import (Controllers)
# Get configuration.
config = Configuration()
# Set routes for flask application.
route(app, Controllers, config)
# Set debugging if necessary.
if config.ENVIRONMENT == config.ConfigurationConstants.DEVELOPMENT:
app.debug = True
# Set JSON schemas
app.config['JSONSCHEMA_DIR'] = os.path.join(app.root_path, 'DTO/schemas')
# Set request level validators.
hook_validators(app)
# Run flask application.
def main(args):
now = datetime.now()
for size in args.sizes:
device = "cpu"
if torch.cuda.is_available():
from torch.backends import cudnn
cudnn.benchmark = True
device = "cuda"
assert args.model_class in MODEL_MAP, "Model Class not in {}".format(
MODEL_MAP.keys())
model = MODEL_MAP[args.model_class].from_file(
args.model_path.name,
device,
gcn_hidden_dimension=args.gcn_hidden_dimension,
fc_hidden_dimension=args.fc_hidden_dimension,
)
# model = torch.load(args.model_path.name, map_location=device)
positive_ratio, test_loader = get_graph_test_loader(
args.dataset_path,
GraphsDataset,
args.batch_size,
args.num_workers,
dataset_size=size,
positive_ratio=args.positive_ratio,
collate_fn=collate,
pin_memory="cuda" in device if device is not None else False,
)
dataset_size = size or len(test_loader.dataset)
log_dir = os.path.join(
args.output,
"testing_{}_{}_{}".format(args.model_name, dataset_size,
now.strftime("%Y%m%d_%H%M")),
)
if not os.path.exists(log_dir):
os.makedirs(log_dir)
log_level = logging.INFO
if args.debug:
log_level = logging.DEBUG
print("Activated debug mode")
logger = logging.getLogger("Spread Classification: Test")
setup_logger(logger, log_dir, log_level)
logger.debug("Setup model: {}".format(args.model_name))
configuration = Configuration.from_dict(
**{
**vars(args),
"optimizer": "N/A",
"epochs": -1,
"train_batch_size": -1,
"val_batch_size": args.batch_size,
"lr": -1,
"lr_update_every": -1,
"weight_decay": -1,
"gamma": -1,
"restart_every": -1,
"restart_factor": -1,
"init_lr_factor": -1,
"lr_reduce_patience": -1,
"lr_reduce_factor": -1,
"early_stop_patience": -1,
"positive_ratio": positive_ratio,
"run_index": -1,
"log_dir": log_dir,
"log_level": log_level,
"log_interval": -1,
"device": device,
"dataset_size": dataset_size,
"data_type": "graph",
"model_name": args.model_path.name,
})
metrics = test_on_loader(model, test_loader, logger, configuration)
with open(os.path.join(log_dir, "metrics.json"), "w") as file:
json.dump(metrics, file)
def main(args):
now = datetime.now()
for size in args.sizes:
log_dir = os.path.join(
args.output,
"training_{}_{}_{}".format(
args.model_name, size, now.strftime("%Y%m%d_%H%M")
),
)
if not os.path.exists(log_dir):
os.makedirs(log_dir)
log_level = logging.INFO
if args.debug:
log_level = logging.DEBUG
print("Activated debug mode")
logger = logging.getLogger("Spread Classification: Train")
setup_logger(logger, log_dir, log_level)
device = "cpu"
if torch.cuda.is_available():
logger.debug("CUDA is enabled")
from torch.backends import cudnn
cudnn.benchmark = True
device = "cuda"
logger.debug("Setup model: {}".format(args.model_name))
logger.debug("Setup train/val dataloaders")
positive_ratio, loaders = get_text_loaders(
args.dataset_path,
args.train_batch_size,
args.val_batch_size,
args.num_workers,
get_model_cls(args.model_class).MAX_LEN,
dataset_size=size,
positive_ratio=args.positive_ratio,
model_class=args.model_class,
)
for run_index, (train_loader, val_loader) in it.islice(
enumerate(loaders), 0, args.max_runs
):
configuration = Configuration.from_dict(
**{
**vars(args),
"positive_ratio": positive_ratio,
"run_index": run_index,
"log_dir": log_dir,
"log_level": log_level,
"device": device,
"dataset_size": size
or (len(train_loader.dataset) + len(val_loader.dataset)),
"data_type": "text",
"gcn_hidden_dimension": -1,
"fc_hidden_dimension": -1,
}
)
train_on_loaders(train_loader, val_loader, logger, configuration)
from src.logging.mixin import LoggingMixin
logger = LoggingMixin().logger
def create_api(configuration: Configuration) -> Flask:
logger.info('[SETUP] API Application')
api = Flask(__name__)
api.url_map.strict_slashes = False
api.config['SQLALCHEMY_DATABASE_URI'] = configuration.database_uri
api.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
_register_blueprints(api)
logger.info('[DONE] API Application')
return api
def _register_blueprints(api_application: Flask) -> None:
api_application.register_blueprint(ping_blueprint)
api_application.register_blueprint(index_blueprint)
api_application.register_blueprint(bike_blueprint)
configuration = Configuration()
api = create_api(configuration)
db.init_app(api)
migration = Migrate(api, db)
def main(color):
"""
configuration: all the attacks and config data from the user and files
attacks: configure attacks from files data
hashcat: calls to hashcat individual attacks
"""
# print start datetime
start_date = datetime.now()
Color.showVerbose("Start date: " + Color.datetime_to_string(start_date))
Color.showVerbose("Press enter or [s] to see hashcat's status...")
Color.showVerbose("Press [q]' to skip one hashcat command...")
Color.showVerbose("Press [Ctrl+c] to skip one attack file...")
Color.showVerbose("Press [Ctrl+c] x3 times to stop all attacks...")
# get input arguments
arguments = getArguments()
if not arguments.attacks_file:
Color.showError("Nothing happening here... add [-a attacks_file] to execute attacks", True)
# ctrl+c signal counter for exiting program instead of bypassing resources
interruptCounter = 0
lastInterruptTime = datetime.now()
try:
"""
For every attacks_file in the list (all configs)
"""
attacks_file_list = Configuration.getConfigFilesArray(arguments.attacks_file)
for attacks_file in attacks_file_list:
"""
For every hash_file in the list, execute all the defined attacks in the attacks_file
"""
hash_files_list = Configuration.getHashFilesArray(arguments.hash_file, arguments.hash_type, arguments.extra_params, arguments.hash_files)
for hash_file_item in hash_files_list:
parsing_errors = False
if hash_file_item:
if hash_file_item["hash_file"]:
hash_file = hash_file_item["hash_file"]
else:
parsing_errors = True
if hash_file_item["hash_type"]:
hash_type = hash_file_item["hash_type"]
else:
parsing_errors = True
if len(hash_file_item) == 3 and hash_file_item["extra_params"]:
extra_params = hash_file_item["extra_params"]
else:
extra_params = ""
else:
parsing_errors = True
if parsing_errors:
Color.showError("Error in the files/types/extra_param parsing... skipping this file", False)
break
# load other scripts
conf = Configuration(hash_file, hash_type, attacks_file, extra_params, arguments.output_dir, arguments.wordlist_custom_file)
hashcat = Hashcat(conf.static_values, arguments.verbose, color)
attacks = Attacks(hashcat)
#set logging file
log_path = os.path.join(conf.results_dir, "autocrackeo.log")
color.setFileHandler(log_path) # set log file
Color.showVerbose("The results (potfile, cracked passwords and logfile) will be written to: " + conf.results_dir + "\n")
# print important info
Color.showTitle(Color.datetime_to_string(datetime.now()))
msg = "Attacks config file:" + attacks_file + ", hash file:" + hash_file + ", hash type:" + hash_type + ", extra params:" + extra_params
Color.showMessage(msg + "\n") # show attack file
color.logThis("[i] " + Color.datetime_to_string(datetime.now()) + ", " + msg) # log attack file
if attacks_file: # if -c/--config
"""
Execute a specific selection of hashcat attacks
previously defined on the configuration json file
This will be updated gradually as the efficiency of the attacks are measured
"""
try:
for attack_name in conf.attacks:
if arguments.verbose: Color.showVerbose("Attack type: " + attack_name.replace("_"," ").title()) # nice print
if "straight" in attack_name:
attacks.straight_attacks(attack_name, conf.attacks[attack_name], conf.wordlists, conf.rules)
elif "combinator" in attack_name:
attacks.combinator_attacks(attack_name, conf.attacks[attack_name], conf.wordlists)
elif "brute_force" in attack_name:
attacks.brute_force_attacks(attack_name, conf.attacks[attack_name], conf.masks)
elif "hybrid" in attack_name:
attacks.hybrid_attacks(attack_name, conf.attacks[attack_name], conf.wordlists, conf.masks)
elif "one_word_per_hash" in attack_name:
attacks.OneWordPerHashAttacks(attack_name, conf.attacks[attack_name], conf.wordlists)
else:
Color.showError("This attack name is not recognized!", False)
# dump plaintext passwords from potfile to custom wordlist
if arguments.feedback: hashcat.feedback(arguments.wordlist_custom_file)
except KeyboardInterrupt as ki:
"""
Set a SIGINT signal handler
to securely skip all the attacks for this hash_file and attacks_file
and it continues the loop
but if it is x3 times clicked with less than 1 second of distance, exit program
"""
Color.showError("Ctrl+C {0}: Skipping {1} attacks...".format(interruptCounter+1,attacks_file), False)
color.logThis("[X] Ctrl+C {0}: Skipping {1} attacks...".format(interruptCounter+1,attacks_file))
hashcat.save_cracked() # dump results output in cracked file
interruptTime = datetime.now()
difference = interruptTime - lastInterruptTime
if (difference.total_seconds() < 1):
interruptCounter+=1
if (interruptCounter > 2):
ki.message = "ctrl+c x3"
raise
else:
interruptCounter = 0
lastInterruptTime = interruptTime
except Exception as e:
Color.showException(e, True)
hashcat.save_cracked() # ALWAYS DUMP RESULTS: for every config file tried, and every hash file/type
except KeyboardInterrupt as ki:
Color.showError("Ctrl+C (x3): Exiting attacks...", False)
color.logThis("[X] Ctrl+C (x3): Exiting attacks...")
except Exception as e:
Color.showError(str(e), False)
"""
Print end of execution
"""
# print end datetime and duration
Color.showTitle("")
end_date = datetime.now()
Color.showVerbose("End date: " + Color.datetime_to_string(end_date))
duration = end_date - start_date
Color.showVerbose("Duration: " + Color.timedelta_to_string(duration))
def main():
log(0, "Creating tables... " + str(Configuration().get()))
Node.create_table()
CommandQueue.create_table()
PoolingLogs.create_table()
CommandResponse.create_table()
yn.value = value
yn.update_property_list()
print("\nCalculating Target Value...:")
targetValue = sum([yn.target_function() for yn in y])
print("Current targeted value:", targetValue)
return targetValue
if __name__ == "__main__":
welcome()
confFile = get_cmd_arg()
cfg = Configuration()
cfg.read(confFile)
#TODO no need a class.
(optMethod, ) = cfg.get_config("optimization")
(
initParaTableFile,
paraTableFile,
ffForSimulation,
ffTemplate,
) = cfg.get_config('parameters')
(
mode,
execute,
path,
processScript,
