def First_Usage(): if Tools().Check_File(File=str(Configuration().UserFolder + "/" + Configuration().KeysFolder + "/" + Configuration().PrivateKey)) == False: #First time this program was executed while True: Password = getpass.getpass(prompt="Enter a password: "******"Enter the passsword again: ") if Password == Password2: config.Password = Password break else: print("") print("Passwords do not match!") print("") try: HayStack().Build_All_Directories() except: print("No IRI instance running on device.") else: while True: #Turn this on later Password = getpass.getpass(prompt="Enter the HayStack password: "******"The password was incorrect. Please try again.")
def __init__(self): Configuration.__init__(self) User_Profile.__init__(self) self.PublicIOTA = IOTA_Module(Seed=self.PublicSeed) self.PrivateIOTA = IOTA_Module(Seed=self.Private_Seed) self.Ledger_Accounts = [] self.All_Accounts = []
def __init__(self): Configuration.__init__(self) Tools.__init__(self) #Core directory objects self.Contact_Folder_Dir = str(self.UserFolder + "/" + self.Contacts_Folder) self.Contacts_File_Dir = str(self.Contact_Folder_Dir + "/" + self.Contacts_File)
def Return_Fastest_Node(): x = Configuration() Node_Dictionary = Tools().Read_From_Json(directory=x.UserFolder + "/" + x.NodeFolder + "/" + x.NodeFile) Send_initial = 999.0 Receive_initial = 999.0 Fastest_Combination = {} for Node, Stats in Node_Dictionary.items(): try: Send = Stats["Send"] Receive = Stats["Receive"] float except TypeError: Send = 999.0 Receive = 999.0 if Send_initial > Send: Send_initial = Send Fastest_Combination["Send"] = Node if Receive_initial > Receive: Receive_initial = Receive Fastest_Combination["Receive"] = Node return Fastest_Combination
def Symmetric_Encryption(self, PlainText, SecretKey): if isinstance(PlainText, str) == False: PlainText = PlainText.decode() if isinstance(SecretKey, bytes) == False: SecretKey = SecretKey.encode() cipher = pyffx.String(SecretKey, alphabet = Configuration().Charlib, length = len(PlainText)).encrypt(PlainText) return cipher.encode()
def PublicBackUp(self): Public_Seed = Configuration().PublicSeed Private_Seed = User_Profile().Private_Seed BackUpAddress = IOTA_Module(Seed=Public_Seed).Generate_Address(Index=2) Submit = IOTA_Module(Seed=Private_Seed).Send( ReceiverAddress=BackUpAddress, Message=self.Decompose()) print("Receipt: " + str(Submit))
def Decompose(self): KeyList = Tools().ReadLine(directory=self.PEMFile) KeyString = Tools().List_To_String(List=KeyList) KeyEncoded = Tools().String_To_Base64(String=KeyString) Private_Seed = User_Profile().Private_Seed Combined = str(KeyEncoded + Configuration().Identifier + Private_Seed) KeyCipher = Encryption().SymmetricEncryption( PlainText=Combined, SecretKey=self.SuperSecretKey1) KeyCipher = Encryption().SymmetricEncryption( PlainText=KeyCipher, SecretKey=self.SuperSecretKey2) return KeyCipher
def __init__(self): Tools.__init__(self) Configuration.__init__(self) User_Profile.__init__(self) self.Ledger_Accounts_Dir = str(self.UserFolder + "/" + self.PathFolder + "/" + self.Ledger_Accounts_File) self.Last_Block_Dir = str(self.UserFolder + "/" + self.PathFolder + "/" + self.Last_Block) self.Ping_Dir = str(self.UserFolder + "/" + self.PathFolder + "/" + self.Trajectory_Ping) self.Incoming_Shrapnells = str(self.UserFolder + "/" + self.MessageFolder + "/" + Configuration().ReceivedMessages + "/" + Configuration().ReceivedMessages + ".txt") self.TrustedNodes_Dir = str(self.UserFolder + "/" + self.PathFolder + "/" + self.Trusted_Nodes) self.Current_Block = Dynamic_Public_Ledger().Calculate_Block().Block self.PrivateIOTA = IOTA_Module(Seed=self.Private_Seed)
def __init__(self, Seed, IOTA_Instance=""): Configuration.__init__(self) try: Optimal_Node = Return_Fastest_Node()["Send"] if Optimal_Node == 999.0: Optimal_Node = Return_Fastest_Node()["Receive"] config.Node = Optimal_Node except: config.Node = "http://localhost:14265" if config.Node == "http://localhost:14265": self.IOTA_Api = Iota(RoutingWrapper(str(config.Node)).add_route( 'attachToTangle', 'http://localhost:14265'), seed=Seed) else: self.IOTA_Api = Iota(config.Node, seed=Seed) if IOTA_Instance != "": self.IOTA_Api = IOTA_Instance self.Seed_Copy = Seed
def Speed_Tx(Node, Read_Write, PoW=False): start = time.time() iota = IOTA(Seed=Configuration().PublicSeed, Node=node, PoW=PoW) if Read_Write == "w": Address = iota.Generate_Address(Index=0) Confirmation = iota.Send(Receiver_Address=Address, Message="Test") else: Confirmation = iota.Receive(Start=1, Stop=2) stop = time.time() if Confirmation == False: return "Error" else: return stop - start
def __init__(self): Initialization.__init__(self) Tools.__init__(self) Configuration.__init__(self) self.Received_Dir = str( self.InboxGenerator(Output_Directory=True).ReceivedMessages + "/" + Configuration().ReceivedMessages + ".txt") self.Relayed_Dir = str( self.InboxGenerator(Output_Directory=True).RelayedMessages + "/" + Configuration().RelayedMessage + ".txt") self.NotRelayed_Dir = str( self.InboxGenerator(Output_Directory=True).OutstandingRelay + "/" + Configuration().NotRelayedMessage + ".txt") self.Message_Inbox = self.UserFolder + "/" + self.MessageFolder + "/" + Configuration( ).ReceivedMessages + "/" + self.Inbox + ".txt"
def Reconstruction_Of_Message(self, Verify): #Make sure there is a file: self.Create_DB() #Read the file Client_Dictionary = self.Read_From_Json(directory=self.Received_Dir) Unique_SymKeys = [] for i in Client_Dictionary.values(): Unique_SymKeys.append(i) Unique_SymKeys = set(Unique_SymKeys) Message = [] for i in Unique_SymKeys: Pieces_From_SymKey = [] Unmodified_Labels = [] for Cipher, Symkey in Client_Dictionary.items(): if i == Symkey: Pieces_From_SymKey.append( str(Cipher).replace(Configuration().MessageIdentifier, '')) Unmodified_Labels.append(str(Cipher)) Sym_Key = self.Base64_To_String(str(i)) Format_To_Digest = [Pieces_From_SymKey, Sym_Key] Output = Dynamic_Public_Ledger().Rebuild_Shrapnells( String=Format_To_Digest, Verify=Verify) if isinstance(Output, list): Message.append(Output) for z in Unmodified_Labels: Client_Dictionary = self.Remove_From_Dictionary( Input_Dictionary=Client_Dictionary, Label=z) self.Write_To_Json(directory=self.Received_Dir, Dictionary=Client_Dictionary) self.Completed_Messages(Input=Message) if len(Message) == 0: return [[False, False, False]] else: return Message
def __init__(self): Configuration.__init__(self) Tools.__init__(self)
def Secret_Key(self, length = Configuration().SymKey_Length): return Encoding().To_Base64(Input = os.urandom(length))[0:length]
def First_Usage(): if Tools().Check_File(File=str(Configuration().UserFolder + "/" + Configuration().KeysFolder + "/" + Configuration().PrivateKey)) == False: print("Searching for working IOTA nodes.. please wait 30 seconds...") try: for i in range(30): sleep(1) #First time this program was executed print("Please enter a password for HayStack.") while True: Password = getpass.getpass(prompt="Enter a password: "******"Enter the passsword again: ") if Password == Password2 != "": config.Password = Password break else: print("") print("Passwords do not match!") print("") except KeyboardInterrupt: Node_Finder.Terminate() exit() try: while True: print("Would you like to restore from backup? (y/n)") Choice = raw_input(">>> ") if Choice == "y": print("Checking connectivity. Please wait.") for i in range(60): sleep(1) Dictionary = HayStack().Fastest_Node() try: x = Dictionary["Receive"] y = Dictionary["Send"] if x != "Error" and y != "Error": break except: pass Recovery = True print( "You have chosen to recover your keys. Please enter your two passwords in the correct order." ) print("Type in password 1") SuperSecretKey1 = raw_input(">>> ") print("Type in password 2") SuperSecretKey2 = raw_input(">>> ") print("Password 1: " + SuperSecretKey1 + " Password 2: " + SuperSecretKey2) answer = raw_input("Are these correct? (y/n/b) ") if answer == "y": break elif answer == "b": break elif answer == "n": pass elif Choice == "n": Recovery = False break else: print("Not a valid choice...") except KeyboardInterrupt: Node_Finder.Terminate() exit() if Recovery == True: outcome = Restore(SuperSecretKey1, SuperSecretKey2).Restore_FileDirectory() if outcome == False: print("Failed to restore keys.") HayStack().Build_All_Directories() else: print("Found your house keys!") else: for i in range(30): try: HayStack().Build_All_Directories() break except KeyboardInterrupt: Node_Finder.Terminate() exit() except: print( "Your connection is unstable. All nodes are now being tested." ) Dictionary = HayStack().Fastest_Node() x = Dictionary("Receive") y = Dictionary("Send") if x != "Error" and y != "Error": print("Nodes found!") else: while True: Password = getpass.getpass(prompt="Enter the HayStack password: "******"The password was incorrect. Please try again.")
def Message_Composer(self): while True: User_Choice = raw_input( "Please choose one of the options: \n a) Get recipient from address book \n b) From public ledger \n c) Go Back \n>>> " ) if User_Choice == "a": Recipients = self.Address_Book() if len(Recipients) != 0: print("Enter your message:\n") Message = raw_input(">>> ") Number_of_Trajectories = raw_input( "Number of trajectories: (Number < 3) >>> ") try: DifferentPaths = int(Number_of_Trajectories) if DifferentPaths >= 3: DifferentPaths = 3 except: DifferentPaths = Configuration().DifferentPaths for i in Recipients: PublicKey = i[0] Current_Address = HayStack().Last_Seen_Address( PublicKey=PublicKey) if Current_Address != None: Address = Current_Address else: Address = i[1][0] Receipt = HayStack().Send_Message( Message=Message, ReceiverAddress=Address, PublicKey=PublicKey, DifferentPaths=DifferentPaths, Encrypted=True) print("Message sent. Transaction hash: " + str(Receipt[0][1])) break if len(Recipients) == 0: print( "You dont have any contacts. Returning to previous menu." ) break else: print("Nothing entered. Returning to previous menu.") break elif User_Choice == "b": try: Current_Ledger_Pool = HayStack( ).Get_Current_Ledger_Addresses().Current_Addresses Current_Client_Address = HayStack().Get_Current_Address( ).Current_Address except: print("Please wait for Haystack to refresh the list.") Current_Ledger_Pool = [] if len(Current_Ledger_Pool) >= 1: z = 1 print("Choose one of the addresses below:\n") for i in Current_Ledger_Pool: Address = i[0] if Address == Current_Client_Address: print(str(z) + ") " + Address + " <-- You\n") else: print(str(z) + ") " + Address + "\n") z = z + 1 Choice = raw_input(">>> ") try: if len(Choice) == 81: Public_Key_of_Choice = "" for i in Current_Ledger_Pool: if Choice == i[0]: Public_Key_of_Choice = i[1] print(Public_Key_of_Choice) if Public_Key_of_Choice != "": print("Enter your message to: " + Choice + "\n") Message = raw_input(">>> ") Receipt = HayStack().Send_Message( Message=Message, ReceiverAddress=Choice, PublicKey=Public_Key_of_Choice, DifferentPaths=Configuration( ).DifferentPaths, Encrypted=True) print("Message sent. Transaction hash: " + str(Receipt[0][1])) break else: print( "Error with finding the public encryption key try again. Likely this is due to wrong address inserted or you copied whitespace." ) elif int(Choice): Choice_Data = Current_Ledger_Pool[int(Choice) - 1] print("Enter your message to: " + Choice_Data[0] + "\n") Message = raw_input(">>> ") Receipt = HayStack().Send_Message( Message=Message, ReceiverAddress=i[0], PublicKey=i[1], DifferentPaths=Configuration().DifferentPaths, Encrypted=True) print("Message sent. Transaction hash: " + str(Receipt[0][1])) break except ValueError: print( "Error with input. Make sure you type in either the above address in or simply choose the number." ) else: print( "There are currently no users online. Your address will appear shortly" ) elif User_Choice == "c": break return self
def __init__(self, Seed): Configuration.__init__(self) self.IOTA_Api = Iota(RoutingWrapper(str(self.Node)).add_route( 'attachToTangle', 'http://localhost:14265'), seed=Seed)
def Check_Current_Ledger(self): def User_Submission(): IOTA_Send_Private = Verify_Node(Dictionary=self.Send_Node, Seed=Keys.PrivateSeed)[0] String_To_Sign = Encoding().To_Base64( IOTA_Send_Private.Generate_Address(Index=Current_Block) + c.Identifier + Encoding().To_Base64(Input=Keys.PublicKey)) Signature = Encryption().Sign_Message(ToSign=String_To_Sign, PrivateKey=Keys.PrivateKey, Password=config.Password) Ready_To_Submit = Encoding().To_Base64(String_To_Sign + c.Identifier + Signature) DPL_Address = IOTA_Receive[0].Generate_Address(Index=Current_Block) Verify = Force_Alternate_Node(Dictionary=self.Send_Node, Seed=Keys.PrivateSeed, Address=DPL_Address, Message=str(Ready_To_Submit, "utf-8")) return Verify c = Configuration() u = UserProfile() Keys = u.Get_Keys(Password=config.Password) IOTA_Receive = Verify_Node(Dictionary=self.Receive_Node, Seed=c.PublicSeed) Current_Block = IOTA_Receive[1].CurrentBlock Current_Time = IOTA_Receive[1].Current_Time print(IOTA_Receive[1].Block_Remainder) Entries = Force_Alternate_Node(Dictionary=self.Receive_Node, Seed=c.PublicSeed, Start_Block=Current_Block, End_Block=Current_Block + 1) if Entries == {}: return User_Submission() elif Entries != False: Current_Ledger = {} Ledger_Accounts = Tools().JSON_Manipulation( File_Directory=u.LedgerAccounts) for Bundle, Dic in Entries.items(): Temp = {} try: User_Entry = Dic["Message"] Submission_Block = Tools().Epoch_To_Block( Epoch_Time=Dic["Timestamp"])[0] Decoded = Encoding().From_Base64(Input=User_Entry).split( c.Identifier) Address_PublicKey = Encoding().From_Base64( Input=Decoded[0]).split(c.Identifier) User_Address = Address_PublicKey[0] User_PublicKey = Encoding().From_Base64( Address_PublicKey[1]) if Decryption().Signature_Verification( ToVerify=Decoded[0], PublicKey=User_PublicKey, Signature=Decoded[1] ) == True: # and Submission_Block >= Current_Block-c.Offset: Current_Ledger[str(Address_PublicKey[1], "utf-8")] = str( User_Address, "utf-8") Temp[User_Address.decode("utf-8")] = Current_Block try: Ledger_Accounts[Address_PublicKey[1].decode( "utf-8")].update(Temp) except KeyError: Ledger_Accounts[Address_PublicKey[1].decode( "utf-8")] = {} Ledger_Accounts[Address_PublicKey[1].decode( "utf-8")].update(Temp) except: print(sys.exc_info()[1]) Tools().JSON_Manipulation(File_Directory=u.CurrentLedger, Dictionary=Current_Ledger) Tools().JSON_Manipulation(File_Directory=u.LedgerAccounts, Dictionary=Ledger_Accounts) Client_Address = str( Verify_Node(Dictionary=self.Send_Node, Seed=Keys.PrivateSeed)[0].Generate_Address( Index=Current_Block), "utf-8") if Client_Address not in Current_Ledger.values(): return User_Submission() else: return False
def __init__(self): Configuration.__init__(self) Encryption.__init__(self) User_Profile.__init__(self) self.PrivateIOTA = IOTA_Module(Seed = self.Private_Seed)
def __init__(self): Configuration.__init__(self) self.RootNode = str(self.UserFolder + "/" + self.NodeFolder) self.NodeFile_Dir = str(self.RootNode + "/" + self.NodeFile)
def Test_Nodes(): con = Configuration() for node in con.Preloaded_Nodes: Test_Node(node=node)
def __init__(self, SuperSecretKey1, SuperSecretKey2): Conf = Configuration() self.PEMFile = Conf.UserFolder + "/" + Conf.KeysFolder + "/" + Conf.PrivateKey self.SuperSecretKey1 = SuperSecretKey1 self.SuperSecretKey2 = SuperSecretKey2
def __init__(self): Configuration.__init__(self) User_Profile.__init__(self) Inbox_Manager.__init__(self) self.PrivateIOTA = IOTA_Module(Seed = self.Private_Seed) self.Block = Dynamic_Public_Ledger().Calculate_Block().Block
def Split(self, string, length=Configuration().Default_Size): return [ string[start:start + length] for start in range(0, len(string), length) ]
def __init__(self, SuperSecretKey1, SuperSecretKey2): self.SuperSecretKey1 = SuperSecretKey1 self.SuperSecretKey2 = SuperSecretKey2 self.Conf = Configuration()
def Epoch_To_Block(self, Epoch_Time): c = Configuration() BlockFloat = float(Epoch_Time - c.Genesis_Time)/float(c.Block_Duration) Block_Remainder = BlockFloat - math.trunc(BlockFloat) CurrentBlock = math.trunc(BlockFloat) return [CurrentBlock, Block_Remainder]