def packet_handler_0x03_redirect(self, packet):
address = packet.read(4)
port = packet.read_uint16()
packet.read_byte() # remaining
seed = packet.read_byte()
key = packet.read_string8()
name = packet.read_string8()
id = packet.read_uint32()
self.crypto = Crypto(seed, key, name)
address.reverse()
address = ".".join([str(octet) for octet in address])
self.disconnect()
self.connect(address, port)
self.client_ordinal = 0
x10 = ClientPacket(0x10)
x10.write_byte(seed)
x10.write_string8(key)
x10.write_string8(name)
x10.write_uint32(id)
x10.write_byte(0x00)
self.send(x10)
if self.server == LoginServer:
self.connected_to_login()
def __init__(self, signal):
"""
Default constructor
"""
self.signal = signal
self.state = 0
self.file = None
self.file_name = None
self.file_path = None
self.storage_dir = storage_dir
self.last_pos = 0
self.new_key = False
self.buffer = ''
self.peername = ''
self.symetric_ciphers = ['ChaCha20', 'AES', '3DES']
self.cipher_modes = ['CBC', 'ECB', 'GCM']
self.digest = ['SHA384', 'SHA256', 'SHA512', 'MD5', 'BLAKE2']
self.choosen_cipher = None
self.choosen_mode = None
self.choosen_digest = None
self.crypto = Crypto(self.choosen_cipher, self.choosen_mode,
self.choosen_digest)
self.encrypted_data = ''
self.decrypted_data = []
def __init__(self, username, password):
self.username = username
self.password = password
self.crypto = Crypto()
self.start_time = time()
self.recv_buffer = []
self.client_ordinal = 0
self.socket = None
self.server = None
self.sent_version = False
self.show_outgoing = False
self.show_incoming = False
self.packet_handlers = {
0x00: self.packet_handler_0x00_encryption,
0x02: self.packet_handler_0x02_login_message,
0x03: self.packet_handler_0x03_redirect,
0x05: self.packet_handler_0x05_user_id,
0x0A: self.packet_handler_0x0A_system_message,
0x0D: self.packet_handler_0x0D_chat,
0x3B: self.packet_handler_0x3B_ping_a,
0x4C: self.packet_handler_0x4C_ending_signal,
0x68: self.packet_handler_0x68_ping_b,
0x7E: self.packet_handler_0x7E_welcome
}
def __init__(self, host, port, conf_key, auth_key):
crypt = Crypto()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, int(port)))
while True:
# client has typed somethin [sys.stdin]
# server sends a message [s]
inputs = [sys.stdin, s]
read, trash1, trash2 = select.select(inputs, [], [])
for sock in read:
if sock == s:
# if sock is server, check for data
data = sock.recv(1024)
# write data to terminal
decrypt_data = crypt.decrypt(data, conf_key, auth_key)
print(decrypt_data)
# otherwise client is trying to send a message
else:
# send server message
msg = sys.stdin.readline()
msg = crypt.encrypt(msg, conf_key, auth_key)
s.send(msg)
def add_crypto(self):
crypto_name = self.ticker_entry.get()
if crypto_name and crypto_name not in self.cryptos_tracking:
if self.get_price(crypto_name) == 0.0:
tkMessageBox.showinfo("ERROR", "Coin does not exist.")
else:
self.cryptos_tracking.append(Crypto(crypto_name, 0))
def __init__(self, host, port, conf_key, auth_key):
crypt = Crypto()
listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
listen_socket.bind(
(host, int(port))) # this socket is bound to my port 9876
listen_socket.listen(1) # specify the "backlog" for this socket
while True:
# create the input list
read_list = [listen_socket, sys.stdin] + self.connected_clients
(ready_list, _, _) = select.select(read_list, [], [])
for ready in ready_list:
if ready is listen_socket:
conn, addr = ready.accept()
self.connected_clients += [conn]
elif ready == sys.stdin:
msg = sys.stdin.readline()
msg = crypt.encrypt(msg, conf_key, auth_key)
self.shout(listen_socket, msg)
else:
data = ready.recv(1024)
if len(data) == 0:
self.connected_clients.remove(ready)
else:
decrypt_data = crypt.decrypt(data, conf_key, auth_key)
print(decrypt_data)
self.shout(ready, decrypt_data.rstrip())
def __init__(self):
self.client = zulip.Client(site="https://fazeup.zulipchat.com/api/")
self.subscribe_all()
self.hacknews = Hackernews()
self.trans = Translate()
self.movie = Movie()
self.lyrics = Lyrics()
self.holiday = Holiday()
self.currency = Currency()
self.cricket = Cricket()
# self.chatbot.train("chatterbot.corpus.english")
self.crypto = Crypto()
self.trans = Translate()
self.g = Giphy()
self.w = WikiPedia()
# self.tw = Twimega()
# self.motivate = Motivate()
self.shortenedurl = Urlshortener()
self.geo = Geocode()
self.weather = Weather()
self.dict_ = Dictionary()
self.joke = Joke()
self.pnr = Pnr()
self.mustread = Mustread()
self.ss = Ss()
self.cricket = Cricket()
self.poll = Poll()
print("done init")
self.subkeys = [
"crypto", "translate", "define", "joke", "weather", "giphy", "pnr",
"mustread", "poll", "hackernews", "hn", "HN", "motivate",
"twitter", "screenshot", "memo", "cricnews", "help", "shorturl",
"movie", "currency", "holiday", "lyrics"
]
def main():
crypto = Crypto(60, 40)
def onOpen(ws):
print('opened connection')
def onClose(ws):
print('closed connection')
def onMessage(ws, message):
# print('received message')
jsonMessage = json.loads(message)
candle = jsonMessage['k']
isCandleClosed = candle['x']
close = candle['c']
if isCandleClosed:
crypto.addClose(float(close))
RsiBasic(crypto, float(close))
ws = websocket.WebSocketApp(SOCKET,
on_open=onOpen,
on_close=onClose,
on_message=onMessage)
ws.run_forever()
def __init__(self, target_path: str, backup_path: str, password: str):
if not op.isdir(target_path):
raise Exception()
self.crypto = Crypto(password)
self.file_iterator = FileItter(target_path)
self.files = self.file_iterator.itter_files(target_path)
self.directories = self.file_iterator.itter_directories()
self.temp_folder = tempfile.TemporaryDirectory()
self.backup_path = backup_path
self.target_path = target_path
self.temp_path = self.temp_folder.name
pathlib.Path(backup_path).mkdir(parents=True,
exist_ok=True) # creates backup folder
self.backup_zip = zipfile.ZipFile(self.temp_path + "\\backup.zip",
mode='w',
compression=zipfile.ZIP_STORED,
allowZip64=True)
self.backup_zip_path = self.backup_zip.filename
self.main_config_dict = dict()
def test_get_latest_price(self):
id = 'btc'
currency = 'usd'
responses.add(responses.GET,
f'{TICKER_API_URL}/coins/list',
json=[{
'id': 'btc',
'symbol': 'BITCOIN'
}, {
'id': 'doge',
'symbol': 'DOGE'
}],
status=200)
c = Crypto()
responses.add(responses.GET,
f'{TICKER_API_URL}/simple/price/' +
f'?ids={id}&vs_currencies={currency}',
json=mock_price_response(id, currency, 512345.0),
status=200)
self.assertEqual(c.get_latest_price([id], currency),
'BITCOIN:$512,345 ')
id = 'doge'
currency = 'usd'
responses.add(responses.GET,
f'{TICKER_API_URL}/simple/price/' +
f'?ids={id}&vs_currencies={currency}',
json=mock_price_response(id, currency, 0.223432),
status=200)
self.assertEqual(c.get_latest_price([id], currency), 'DOGE:$0.223432 ')
def __init__(self):
self.client = zulip.Client(site="https://chunkzz.zulipchat.com/api/")
self.subscribe_all()
self.chatbot = ChatBot(
"Omega", trainer='chatterbot.trainers.ChatterBotCorpusTrainer')
self.chatbot.train("chatterbot.corpus.english")
self.crypto = Crypto()
self.trans = Translate()
self.g = Giphy()
self.w = WikiPedia()
self.tw = Twimega()
self.motivate = Motivate()
self.shortenedurl = Urlshortener()
self.hacknews = Hackernews()
self.geo = Geocode()
self.weather = Weather()
self.dict_ = Dictionary()
self.joke = Joke()
self.pnr = Pnr()
self.mustread = Mustread()
self.ss = Ss()
self.cricket = Cricket()
self.poll = Poll()
self.subkeys = [
"crypto", "translate", "define", "joke", "weather", "giphy", "pnr",
"mustread", "poll", "hackernews", "hn", "HN", "motivate",
"twitter", "screenshot", "memo", "cricnews", "help", "shorturl"
]
def __init__(self, file_name, loop):
"""
Default constructor
@param file_name: Name of the file to send
@param loop: Asyncio Loop to use
"""
self.file_name = file_name
self.loop = loop
self.chunk_count = 0
self.last_pos = 0
self.symetric_ciphers = ['ChaCha20', 'AES', '3DES']
self.cipher_modes = ['CBC', 'ECB', 'GCM']
self.digest = ['SHA384', 'SHA256', 'SHA512', 'MD5', 'BLAKE2']
self.state = STATE_CONNECT # Initial State
self.buffer = '' # Buffer to receive data chunks
self.choosen_cipher = None
self.choosen_mode = None
self.choosen_digest = None
self.crypto = Crypto(self.choosen_cipher, self.choosen_mode,
self.choosen_digest)
self.encrypted_data = ''
def exposed_gen_key(self, fid, chunk):
cryptObj = Crypto(fid, 'ks')
key = cryptObj.gen_key(chunk)
if keymenu.push(fid, key):
return key
else:
return None
def test_crypto1(self):
a = "teststringshowingnumbersdontwork123789$%!#"
c = Crypto("MANCHESTERBLUFF")
b = c.encrypt(a)
self.assertEqual(b, "FEFVZXJBRXTSIBNZGAWTFWKWUPYNBTDKXNTUJLBPVH")
d = c.decrypt(b)
self.assertEqual(d, "TESTSTRINGSHOWINGNUMBERSDONTWORKKLMQRSXYUW")
def test_crypto2(self):
a = "ATTACKATDAWN"
c = Crypto("MANCHESTERBLUFF")
b = c.encrypt(a)
self.assertEqual(b, "MTGCJOSMHRXY")
d = c.decrypt(b)
self.assertEqual(d, "ATTACKATDAWN")
def packet_handler_0x00_encryption(self, packet):
code = packet.read_byte()
if code == 1:
self.da_version -= 1
print("Invalid DA version, possibly too high. "
"Trying again with {0}.".format(self.da_version))
self.reconnect()
return
elif code == 2:
version = packet.read_int16()
packet.read_byte()
packet.read_string8() # patch url
self.da_version = version
print("Your DA version is too low. "
"Setting DA version to {0}.".format(version))
self.reconnect()
return
packet.read_uint32() # server table crc
seed = packet.read_byte()
key = packet.read_string8()
self.crypto = Crypto(seed, key)
x57 = ClientPacket(0x57)
x57.write_uint32(0)
self.send(x57)
def main(argv):
#load configuration
try:
configuration_file = open('config.json','r')
CONFIG = json.loads(configuration_file.read())
check_configuration(CONFIG)
configuration_file.close()
print 'Configuration loaded.'
except IOError:
print 'missing configuration file'
sys.exit(2)
except ValueError:
print 'configuration file is corrupt'
sys.exit(2)
print Globals.RESOURCES_RESOURCE_CODE
#Load database
print '\nLoading Database'
DATABASE = Database(CONFIG)
#Load encryption key
print '\nLoading encryption key'
CRYPTO = Crypto(CONFIG, DATABASE)
#Create network manager
print '\nCreating network manager'
NETWORK_MANAGER = NetworkManager(CONFIG, DATABASE, CRYPTO)
#Create server
print '\nCreating server'
SERVER = Server(CONFIG, CRYPTO)
#Create block manager
print '\nCreating block manager'
BLOCK_MANAGER = BlockManager(CONFIG, DATABASE, CRYPTO, NETWORK_MANAGER, SERVER)
SERVER.set_blocks_manager(BLOCK_MANAGER)
#Connect to nodes
print '\nConnecting to network'
NETWORK_MANAGER.connect_to_all(BLOCK_MANAGER)
print '\nStartup complete, waiting for synchronization'
while True:
try:
cmd = raw_input()
if cmd in ['shutdown', 'SHUTDOWN', '^C', '^Z', 'exit', 'EXIT', 'close', 'CLOSE']:
break
except KeyboardInterrupt:
break
print 'Shutdown signal received, stopping everything'
SERVER.shutdown()
NETWORK_MANAGER.shutdown()
print 'All was correctly stopped, exiting'
sys.exit(0)
def __init__(self, data, media_source, key=None):
self.data = data.encode('utf-8')
# Absolute path in Media Source
self.media_source = media_source
self.key = key
# Size of key is 128-bit
self.crypto = Crypto(self.key)
if self.key == None:
self.key = self.crypto.getKey()
def test_display_routine(self, mock_get_config, mock_viewer, mock_joke,
mock_coin, mock_details, mock_logo):
mock_get_config.return_value = {
'ticker': {
'tell_jokes': True,
'crypto': 'btc',
'vs_currency': 'usd'
}
}
mock_joke.return_value = "FUNNY!"
mock_coin.return_value = {
'name': 'Bitcoin',
'id': 'btc',
'symbol': 'btc',
'logo': 'bitcoin_file.jpg'
}
mock_logo.return_value = 'bitcoin_file.jpg'
mock_details.return_value = '$31,000, +10.20%'
# Don't want to wait on sleep in tests
time.sleep = mock.MagicMock()
t = Ticker()
t.crypto = Crypto()
t.load_config()
print(t.config)
t.display_routine()
calls = [mock.call('BITCOIN', MessageType.FALLING, 'bitcoin_file.jpg')]
for j in range(0, 3):
calls.append(
mock.call('$31,000, +10.20%',
MessageType.BOUNCING,
'bitcoin_file.jpg',
delay=30))
calls.append(mock.call('JOKE TIME', MessageType.FALLING, delay=25))
calls.append(mock.call('FUNNY!', MessageType.SCROLLING))
t.viewer.display_message.assert_has_calls(calls)
mock_details.side_effect = ConnectionError()
t.display_routine()
t.viewer.display_message.assert_called_with(
"Error connecting to Price API", MessageType.SCROLLING)
mock_details.side_effect = None
mock_joke.side_effect = ConnectionError()
t.display_routine()
t.viewer.display_message.assert_called_with(
"Error connecting to Joke API", MessageType.SCROLLING)
mock_joke.side_effect = Exception()
t.display_routine()
t.viewer.display_message.assert_called_with(
"Encountered an Unknown Error", MessageType.SCROLLING)
def __init__(self, backup_path: str, restore_path: str, password: str):
self.backup_path = backup_path
self.restore_path = restore_path
pathlib.Path(restore_path).mkdir(
parents=True, exist_ok=True) # create restore directory
self.tempfile = tempfile.TemporaryDirectory()
self.crypto = Crypto(password)
def readtext(self):
img = Image.open(str(self.img_obj))
passwd = self.read_text.text()
steg = steganography.Steganography(img)
msg = steg.decode_image()
decr = Crypto(passwd, enc_msg=msg)
end_msg = decr.decrypt()
self.inserted_text.setText(end_msg)
def handleEncrypt(self, input_text, key):
result = ''
if self.radio_selected == 3: input_text = 'a'
if not input_text or not key:
self.ids.result_text.text = 'NEED INPUT TEXT AND/OR KEY'
return
# STANDARD VIGENERE CIPHER
if self.radio_selected == 0:
result = Crypto().vigenere_standard(input_text, key, 0)
# FULL VIGENERE CIPHER
elif self.radio_selected == 1:
result = Crypto().vigenere_full(input_text, key, 0)
# AUTO-KEY VIGENERE CIPHER
elif self.radio_selected == 2:
result = Crypto().auto_key_vigenere(input_text, key, 0)
# EXTENDED VIGENERE CIPHER
elif self.radio_selected == 3:
if not self.file_path:
result = 'NEED TO CHOOSE FILE'
else:
Crypto().extended_vigenere_encrypt(self.file_path, key)
result = 'File encrypted and saved'
# PLAYFAIR CIPHER
elif self.radio_selected == 4:
result = Crypto().playfair_encrypt(input_text, key)
# SUPER ENCRYPT
elif self.radio_selected == 5:
result = Crypto().super_encrypt(input_text, key, 0)
# AFFINE CIPHER
elif self.radio_selected == 6:
result = Crypto().affine_cipher(input_text, key, 0)
# HILL CIPHER
elif self.radio_selected == 7:
result = Crypto().hill_encrypt(input_text, key)
# SET RESULT
if self.cipher_result == 1:
result = Crypto().string_add_seperator(result, 5)
self.ids.result_text.text = result
def test_get_latest_price_error(self):
responses.add(responses.GET,
f'{TICKER_API_URL}/coins/list',
json=[{
'btc': {
'symbol': 'BITCOIN'
}
}],
status=200)
c = Crypto()
self.assertRaises(ConnectionError, c.get_latest_price, ['btc'], 'usd')
def test_get_coin(self):
mock_coin = {'id': 'btc', 'name': 'bitcoin', 'symbol': 'btc'}
responses.add(responses.GET,
f'{TICKER_API_URL}/coins/list',
json=[mock_coin],
status=200)
c = Crypto()
coin = c.get_coin('btc')
mock_coin['logo'] = c.get_logo(coin)
self.assertEqual(coin, mock_coin)
self.assertRaises(Exception, c.get_coin, 'shitcoin')
def main(argv):
#Load configuration
print '\nLoading Configuration'
CONFIG = load_configuration()
#Load database
print '\nLoading Database'
DATABASE = Database(CONFIG)
#Load encryption key
print '\nLoading encryption key'
CRYPTO = Crypto(CONFIG, DATABASE)
#Create RPC manager
print '\nCreating RPC manager'
RPC_MANAGER = RPCManager(CONFIG, DATABASE, CRYPTO)
#Create server
print '\nCreating server'
SERVER = Server(CONFIG, DATABASE, CRYPTO)
#Create block manager
print '\nCreating block manager'
BLOCK_MANAGER = BlockManager(CONFIG, DATABASE, CRYPTO, RPC_MANAGER, SERVER)
SERVER.set_blocks_manager(BLOCK_MANAGER)
#Connect to nodes
print '\nConnecting to network'
RPC_MANAGER.connect(BLOCK_MANAGER)
while True:
try:
time.sleep(1)
os.system('clear')
print 'Ready for Interruption'
cmd = raw_input()
if cmd in [
'shutdown', 'SHUTDOWN', '^C', '^Z', 'exit', 'EXIT',
'close', 'CLOSE'
]:
break
except KeyboardInterrupt:
break
print '\nShutdown signal received, stopping everything'
SERVER.shutdown()
RPC_MANAGER.shutdown()
BLOCK_MANAGER.shutdown()
print 'All was correctly stopped, exiting'
sys.exit(0)
def test_encrypt_decrypt(self):
integrity = Integrity(
Transform(Transform.Type.INTEG,
Transform.IntegId.AUTH_HMAC_SHA1_96))
cipher = Cipher(
Transform(Transform.Type.ENCR, Transform.EncrId.ENCR_AES_CBC, 256))
encryption_key = b'Mypassword121111' * 2
iv = cipher.generate_iv()
crypto = Crypto(cipher, encryption_key, integrity, b'', None, b'')
payload_sk = PayloadSK.generate(b'Hello there!', iv, crypto)
iv2, clear = payload_sk.decrypt(crypto)
self.assertEqual(clear, b'Hello there!')
self.assertEqual(iv, iv2)
def __init__(self,config_path=None):
if config_path is None:
self.__config=Config()
else:
self.__config=Config(config_path)
self.__host=self.__config.getValue('Mongo','HOST')
self.__port=self.__config.getValue('Mongo','PORT')
self.__cry=Crypto()
self.__user=self.__cry.decrypt(self.__config.getValue('Mongo','USER')).decode("utf-8")
self.__pass=self.__cry.decrypt(self.__config.getValue('Mongo','PASS')).decode("utf-8")
self.__database=self.__config.getValue('Mongo','DATABASE')
#connection_str="mongodb://"+self.__user+":"+self.__pass+"@"+self.__host+":"+self.__port+"/?authSource=admin"
connection_str="mongodb://"+self.__user+":"+self.__pass+"@"+self.__host+":"+self.__port
self.__client=MongoClient(connection_str)
self.__db=None
def arbitrage(bot, update, args):
"""Checks for arbitrage potential."""
chat_id = update.message.chat_id
try:
# args[0] should contain the market_symbol (eg. NXT/BTC)
market_symbol = args[0]
update.message.reply_text('Checking for arbitrage potential on %s' %
(market_symbol))
c = Crypto()
c.run_check_arbitrage(market_symbol)
output = "\n".join(c.log_buffer)
update.message.reply_text(output)
except (IndexError, ValueError):
update.message.reply_text('Usage: /arbitrage <ETH/BTC>')
def __init__(self,
ip_address="127.0.0.1",
post=9999,
backlog=5,
max_seconds=5 * 60):
self.crypto = Crypto()
self.stop_signal = threading.Event()
self.backlog = backlog
self.max_work_time = timedelta(seconds=max_seconds)
self.bind_ip = ip_address
self.bind_port = post
self.main_thread = None
self.iterations_count = 0
self.listen_timeout = 1
self.started = None
def fetch_markets(bot, update, args):
"""Fetch markets for symbol."""
chat_id = update.message.chat_id
try:
# args[0] should contain the market_symbol (eg. NXT/BTC)
market_symbol = args[0]
update.message.reply_text('Fetching markets for %s.' % (market_symbol))
c = Crypto()
result = c.fetch_markets(market_symbol)
output = c.log_buffer + [str(result)]
output = "\n".join(output)
update.message.reply_text(output)
except (IndexError, ValueError):
update.message.reply_text('Usage: /fetch_markets <ETH/BTC>')
