def __init__(self, username: str, threads: int, passlist_path: str):
self.is_alive = True
self.is_found = False
self.password: str = None
self.username: str = username
self.last_password: str = None
self.bots_per_proxy = 0
self.total_threads: int = threads
self.proxy_manager = ProxyManager()
self.display = Display(username, passlist_path)
self.password_manager = PasswordManager(username, passlist_path,
threads, self.display)
self.browsers: typing.List[Browser] = []
self.active_passwords: typing.List[str] = []
self.unstarted_browsers: typing.List[Browser] = []
# Locks
self.lock_browsers = threading.RLock()
self.lock_unstarted_browsers = threading.RLock()
self.lock_active_passwords = threading.RLock()
self.lock_password_manager = threading.RLock()
class Test(TestCase):
display = Display()
@patch('builtins.input', side_effect=['GooG', 'FB', ''])
def test_get_tickers(self, mock_inputs):
self.display.ask_for_tickers()
self.assertEqual(self.display.tickers, ['GOOG', "FB"])
def __init__(self, username: str, wordlist: str, threads: int, verbose: bool = False) -> None:
# Consts
self.verbose = verbose
self.max_proxies = threads
self.proxies_browsers = {}
self.username = username.title()
self.max_browsers = const.MAX_ATTEMPT_PROXY
# Objects
self.display = Display()
self.proxies = Proxies()
self.local_passwords = deque()
self.expired_proxies = Queue()
self.passwords = Password(username, wordlist)
# States
self.attempts = 0
self.is_alive = True
self.csrftoken = None
self.active_browsers = 0
self.account_password = None
# Locks
self.lock_display = RLock()
self.lock_csrftoken = RLock()
self.lock_passwords = RLock()
self.lock_local_passwords = RLock()
self.lock_expired_proxies = RLock()
self.lock_proxies_browsers = RLock()
def __init__(self, username, threads, passlist_path, is_color):
self.resume = False
self.is_alive = True
self.threads = threads
self.username = username
self.passlist_path = passlist_path
self.display = Display(is_color=is_color)
self.bruter = Bruter(username, threads, passlist_path)
def __init__(self, username, threads, passlist_path):
self.bruter = None
self.resume = False
self.is_alive = True
self.threads = threads
self.username = username
self.display = Display()
self.passlist_path = passlist_path
def args():
enable_colors = str(input('Enable colors? (default: y) [y/n]: '))
if not enable_colors:
enable_colors = True
else:
if enable_colors[0].lower() == 'n':
enable_colors = False
display = Display(is_color=enable_colors)
username = display.prompt('Enter a username: '******'You can\'t leave this field empty')
display.wait()
exit()
passlist = display.prompt('Enter the path to your password list: ')
if not exists(passlist):
display.warning('Invalid path to password list', False)
display.wait()
exit()
display.info(
'''Modes:\r
0: => 512 passwords at a time
1: => 256 passwords at a time
2: => 128 passwords at a time
3: => 64 passwords at a time
''', False)
mode = display.prompt('Select a mode [0, 1, 2, 3]: ', False)
if not mode.isdigit():
display.warning('Mode must be a number', False)
display.wait()
exit()
mode = int(mode)
if int(mode) > 3:
display.warning('Mode must be no more than 3', False)
display.wait()
exit()
if int(mode) < 0:
display.warning('Mode must bot no less than 0', False)
display.wait()
exit()
return [username, passlist, mode]
def __init__(self, username, threads, passlist_path):
self.browsers = []
self.lock = RLock()
self.password = None
self.is_alive = True
self.is_found = False
self.bots_per_proxy = 0
self.username = username
self.last_password = None
self.active_passwords = []
self.proxy_manager = ProxyManager()
self.display = Display(username, passlist_path)
self.password_manager = PasswordManager(username,
passlist_path, threads)
def init_Game_or_Original_scene():
# Exécuté une seule fois
init_tempo()
init_objet()
gl.dataInOPY = DataIn('localhost', gl.port_in, 1024, 0.01)
gl.dataOutOPY = DataOut()
gl.displayOPY = Display()
init_audio()
gl.music["bf2"].repeat()
gl.refereeingOPY = Refereeing()
# Active player
gl.activ_player = [0, 1, 2, 3]
# Init particulier pour la scène Original
init_original_only()
def run_siamese(self, train_csv, config):
data = Data()
display = Display()
data.run(train_csv,
n_train_samples=config.n_train_samples,
n_validation_samples=config.n_validation_samples,
embedding_matrix = config.embedding_matrix,
max_len = config.max_len,
embedding_dim=config.embedding_dim,
train_x1 = config.train_x1,
train_x2 = config.train_x2,
contrastive=config.contrastive,
save_embedding=config.save_embedding,
save_train_data=config.save_train_data)
with tf.Graph().as_default() as graph:
config.model = config.model(data)
writer = TensorBoard(graph=graph, logdir=config.logdir).writer
output, loss, acc, train_summ, valid_summ, opt, merged = config.build_network(graph)
init = tf.global_variables_initializer()
with tf.Session(graph=graph) as sess:
sess.run(init)
for epoch in range(config.n_epochs):
train_iter_ = data.batch_generator(config.batch_size)
for batch_idx, batch in enumerate(tqdm(train_iter_)):
train_x1_batch, train_x2_batch, train_labels_batch = batch
_, batch_train_loss, batch_train_accuracy, batch_train_summary, _, summary = sess.run([output, loss, acc, train_summ, opt, merged],
feed_dict={
config.model.network.x1 : train_x1_batch,
config.model.network.x2 : train_x2_batch,
config.model.loss.labels : train_labels_batch,
config.model.network.embedding_matrix : data.embedding_matrix
})
display.log_train(epoch, batch_idx, batch_train_loss, batch_train_accuracy)
writer.add_summary(batch_train_summary, batch_idx)
if config.calculate_validation:
if batch_idx % 100 == 0:
batch_valid_accuracy, batch_valid_summary = sess.run([acc, valid_summ], feed_dict={
config.model.network.x1 : data.valid_x1,
config.model.network.x2 : data.valid_x2,
config.model.loss.labels : data.valid_labels,
config.model.network.embedding_matrix : data.embedding_matrix
})
display.log_validation(epoch, batch_idx, batch_valid_accuracy)
writer.add_summary(batch_valid_summary, batch_idx)
writer.add_summary(summary, batch_idx)
display.done()
def __init__(self, username, wordlist, max_passwords=64) -> None:
# Consts
self.session = None
self.wordlist = wordlist
self.username = username
self.display = Display()
self.max_passwords = max_passwords
self.total_lines = self.count_lines(wordlist)
# States
self.EOF = False # end of file
self.is_alive = True
# resume
self.attempts = 0
self.resume = False
# Storages
self.passwords = deque()
if int(mode) > 3:
display.warning('Mode must be no more than 3', False)
display.wait()
exit()
if int(mode) < 0:
display.warning('Mode must bot no less than 0', False)
display.wait()
exit()
return [username, passlist, mode]
if __name__ == '__main__':
try:
user_input = args()
except KeyboardInterrupt:
exit()
display = Display()
username, passlist, mode = user_input
try:
Engine(username, modes[mode], passlist).start()
except:
pass
finally:
display.wait()
exit()
def __init__(self, dork, write_over):
self.dork = dork
self.display = Display()
self.sql = SQL(dork, write_over)
def main():
display = Display()
print('\n\n========= Tickers =========\n\n')
display.initial_data_request()
while True:
display.give_menu_of_options()
def __init__(self, display=Display(), client_api=ClientApi()):
self.display = display
self.client_api = client_api
