class RIPPPacket(PacketType): DEFINITION_IDENTIFIER = "RIPP.Packet" DEFINITION_VERSION = "1.0" FIELDS = [ ("Type", STRING), ("SeqNo", UINT32({Optional: True})), ("AckNo", UINT32({Optional: True})), ("Checksum", BUFFER({Optional: True})), ("Data", BUFFER({Optional: True})) ] # RIPPPacket type SYN = "SYN" ACK = "ACK" FIN = "FIN" DATA = "DATA" def __init__(self): super().__init__() self.Checksum = b"" def calculateChecksum(self): oldChecksum = self.Checksum self.Checksum = b"" bytes = self.__serialize__() self.Checksum = oldChecksum return hashlib.sha256(bytes).digest() def updateChecksum(self): self.Checksum = self.calculateChecksum() def verifyChecksum(self): return self.Checksum == self.calculateChecksum()
class SITHPacket(PacketType): DEFINITION_IDENTIFIER = "SITH.kandarp.packet.Base" DEFINITION_VERSION = "1.0" TYPE_HELLO = "HELLO" TYPE_FINISH = "FINISH" TYPE_DATA = "DATA" TYPE_CLOSE = "CLOSE" FIELDS = [ ("Random", BUFFER({Optional: True})), #older version ("Type", STRING({Optional: True})), # HELLO, FINISH, DATA, CLOSE ("PublicValue", BUFFER({Optional: True})), #to store public key ("Certificate", LIST(BUFFER)({Optional: True})), #inherit older version 'Certs' ("Signature", BUFFER({Optional: True})), ("Ciphertext", BUFFER({Optional: True})) #inherit older version 'Ciphertext' ] @classmethod def makeHelloPacket(cls, random, certs, public_key): pkt = cls() pkt.Random = random pkt.Certificate = certs pkt.Type = cls.TYPE_HELLO pkt.PublicValue = public_key.public_bytes() #change the format of 'public_key' to bytes, in order to be stored in 'Buffer' field return pkt @classmethod def makeFinishPacket(cls, m1, m2, private_key): pkt = cls() hasher = hashes.Hash(hashes.SHA256(), backend = default_backend()) hasher.update(m1 + m2) #input message needed to hash hash_msg = hasher.finalize() # get the hash result signed_msg = private_key.sign( #generate the signature of messages by signing its hash hash_msg, ec.ECDSA(hashes.SHA256()) ) pkt.Type = cls.TYPE_FINISH pkt.Signature = signed_msg return pkt @classmethod def makeDataPacket(cls, ciphertext): pkt = cls() pkt.Ciphertext = ciphertext pkt.Type = cls.TYPE_DATA return pkt @classmethod def makeClosePacket(cls, error): pkt = cls() pkt.Ciphertext = bytes(error) pkt.Type = cls.TYPE_CLOSE return pkt
class HandshakePacket(CrapPacketType): DEFINITION_IDENTIFIER = "crap.handshakepacket" DEFINITION_VERSION = "1.0" NOT_STARTED = 0 SUCCESS = 1 ERROR = 2 FIELDS = [("status", UINT8), ("nonce", UINT32({Optional: True})), ("nonceSignature", BUFFER({Optional: True})), ("signature", BUFFER({Optional: True})), ("pk", BUFFER({Optional: True})), ("cert", BUFFER({Optional: True}))]
class PassthroughPacket(PacketType): DEFINITION_IDENTIFIER = "passthroughpacket" DEFINITION_VERSION = "1.0" FIELDS = [ ("syn", BOOL({Optional: True})), ("ack", BOOL({Optional: True})), ("certificate", BUFFER({Optional: True})), ("public_key", BUFFER({Optional: True})), ("challenge", STRING({Optional: True})), ("signature", BUFFER({Optional: True})), ("seq_num", UINT16({Optional: True})), ]
class SITHPacket(PacketType): DEFINITION_IDENTIFIER = "SITH.kandarp.packet" DEFINITION_VERSION = "1.0" FIELDS = [ ("Type", STRING), ("Random", BUFFER({Optional: True})), ("PublicValue", BUFFER({Optional: True})), ("Certificate", LIST(BUFFER)({Optional: True})), ("Signature", BUFFER({Optional: True})), ("Ciphertext", BUFFER({Optional: True})) ]
class SITHPacket(PacketType): DEFINITION_IDENTIFIER = "SITH.kandarp.packet" DEFINITION_VERSION = "1.0" FIELDS = [ ("Type", STRING), # HELLO, FINISH, DATA, CLOSE ("Random", BUFFER({Optional: True})), ("PublicValue", BUFFER({Optional: True})), ("Certificate", LIST(BUFFER)({ Optional: True })), ("Signature", BUFFER({Optional: True})), ("Ciphertext", BUFFER({Optional: True})) ] def sith_hello(self, random, public_val, certs): hello = SITHPacket() hello.Type = SITHPacketType.HELLO.value hello.Random = random hello.PublicValue = public_val hello.Certificate = certs return hello def sith_finish(self, signature): finish = SITHPacket() finish.Type = SITHPacketType.FINISH.value finish.Signature = signature return finish def sith_data(self, ciphertext): data = SITHPacket() data.Type = SITHPacketType.DATA.value data.Ciphertext = ciphertext return data def sith_close(self, error=None): close = SITHPacket() close.Type = SITHPacketType.CLOSE.value close.Ciphertext = bytes(error, 'utf-8') return close def __repr__(self): return super(SITHPacket, self).__repr__() + \ ". Type: " + str(self.Type) + \ ". Random: " + str(self.Random) + \ ". PublicValue: " + str(self.PublicValue) + \ ". Certificate: " + str(self.Certificate) + \ ". Ciphertext: " + str(self.Ciphertext)
class PEEPPacket(PacketType): DEFINITION_IDENTIFIER = 'PEEP.Packet' DEFINITION_VERSION = '1.0' FIELDS = [ ('Type', UINT8), ('SequenceNumber', UINT32({Optional: True})), ('Checksum', UINT16), ("Acknowledgement", UINT32({Optional: True})), ("Data", BUFFER({Optional: True})) ] SYN = Constant(intValue=0, strValue="SYN") SYN_ACK = Constant(intValue=1, strValue="SYN-ACK") ACK = Constant(intValue=2, strValue="ACK") RIP = Constant(intValue=3, strValue="RIP") RIP_ACK = Constant(intValue=4, strValue="RIP-ACK") RST = Constant(intValue=5, strValue="RST") DATA = Constant(intValue=6, strValue="DATA") PACKET_TYPES = [SYN, SYN_ACK, ACK, RIP, RIP_ACK, RST, DATA] def calculate_checksum(self): original_checksum = self.Checksum self.Checksum = 0 bytes = self.__serialize__() self.Checksum = original_checksum return zlib.adler32(bytes) & 0xffff def update_checksum(self): self.Checksum = self.calculate_checksum() def verify_checksum(self): return self.Checksum == self.calculate_checksum()
class PEEPPacket(PacketType): DEFINITION_IDENTIFIER = "PEEP.Packet" DEFINITION_VERSION = "1.0" FIELDS = [("Type", UINT8), ("SequenceNumber", UINT32({Optional: True})), ("Checksum", UINT16), ("Acknowledgement", UINT32({Optional: True})), ("Data", BUFFER({Optional: True}))]
class PEEPPacket(PacketType): DEFINITION_IDENTIFIER = "PEEP.Packet" DEFINITION_VERSION = "1.0" SYN = 0 SYNACK = 1 ACK = 2 RIP = 3 RIPACK = 4 DATA = 5 FIELDS = [("Type", UINT8), ("SequenceNumber", UINT32({Optional: True})), ("Checksum", UINT16), ("Acknowledgement", UINT32({Optional: True})), ("Data", BUFFER({Optional: True}))] def calculateChecksum(self): oldChecksum = self.Checksum self.Checksum = 0 bytes = self.__serialize__() self.Checksum = oldChecksum return zlib.adler32(bytes) & 0xffff def updateChecksum(self): self.Checksum = self.calculateChecksum() def verifyChecksum(self): return self.Checksum == self.calculateChecksum() def __repr__(self): return "PEEPPacket: \n" + "Type: " + str(self.Type) + "\nSeq: " + str( self.SequenceNumber) + "\nAck: " + str(self.Acknowledgement)
class PEEPPacket(PacketType): DEFINITION_IDENTIFIER = "PEEP" DEFINITION_VERSION = "1.0" FIELDS = [("Type", UINT8), ("SequenceNumber", UINT32({Optional: True})), ("Acknowledgement", UINT32({Optional: True})), ("Checksum", UINT16), ("Data", BUFFER({Optional: True}))] def updateSeqAcknumber(self, seq, ack): self.SequenceNumber = seq self.Acknowledgement = ack def calculateChecksum(self): oldChecksum = self.Checksum self.Checksum = 0 bytes = self.__serialize__() self.Checksum = oldChecksum return zlib.adler32(bytes) & 0xffff def updateChecksum(self): self.Checksum = self.calculateChecksum() def verifyChecksum(self): return self.Checksum == self.calculateChecksum()
class PEEPPacket(PacketType): DEFINITION_IDENTIFIER = "PEEP.Packet" DEFINITION_VERSION = "1.0" FIELDS = [("Type", UINT8), ("SequenceNumber", UINT32({Optional: True})), ("Checksum", UINT16), ("Acknowledgement", UINT32({Optional: True})), ("Data", BUFFER({Optional: True}))] MAXIMUM_DATA_SIZE = 1024 def calculateChecksum(self): oldChecksum = self.Checksum self.Checksum = 0 bytes = self.__serialize__() self.Checksum = oldChecksum return zlib.adler32(bytes) & 0xffff def verifyChecksum(self): return self.Checksum == self.calculateChecksum() def updateChecksum(self): self.Checksum = self.calculateChecksum() def verify(self): return self.Checksum == self.calculateChecksum() and isinstance( self.SequenceNumber, int) def __eq__(self, other): if not isinstance(other, PEEPPacket): return False return self.SequenceNumber == other.SequenceNumber def __lt__(self, other): return uint32CircularLessThan(self.SequenceNumber, other.SequenceNumber)
class DataPacket(PoopPacketType): DEFINITION_IDENTIFIER = "poop.datapacket" DEFINITION_VERSION = "1.0" FIELDS = [ ("seq", UINT32({Optional: True})), ("hash", UINT32), ("data", BUFFER({Optional: True})), ("ACK", UINT32({Optional: True})), ]
class PEEPPacket(PacketType): DEFINITION_IDENTIFIER = 'peep.packet' DEFINITION_VERSION = '1.2' FIELDS = [('Type', UINT8), ('SequenceNumber', UINT32({Optional: True})), ('Checksum', UINT16), ("Acknowledgement", UINT32({Optional: True})), ("Data", BUFFER({Optional: True}))] # Type SYN = Constant(intValue=0, strValue='SYN') SYN_ACK = Constant(intValue=1, strValue='SYN-ACK') ACK = Constant(intValue=2, strValue='ACK') RIP = Constant(intValue=3, strValue='RIP') RIP_ACK = Constant(intValue=4, strValue='RIP-ACK') DATA = Constant(intValue=5, strValue='DATA') PACKET_TYPES = [SYN, SYN_ACK, ACK, RIP_ACK, DATA] def updateSeqAcknumber(self, seq, ack): self.SequenceNumber = seq self.Acknowledgement = ack def calculateChecksum(self): original_checksum = self.Checksum self.Checksum = 0 bytes = self.__serialize__() self.Checksum = original_checksum return zlib.adler32(bytes) & 0xffff def updateChecksum(self): self.Checksum = self.calculateChecksum() def verifyChecksum(self): return self.Checksum == self.calculateChecksum() def __lt__(self, other): return self.SequenceNumber < other.SequenceNumber @classmethod def Create_SYN(cls): seq_number = random.randint(0, 2**16) packet = cls(Type=cls.SYN, SequenceNumber=seq_number, Checksum=0) packet.updateChecksum() return packet @classmethod def Create_SYN_ACK(cls, client_seq_num): seq_number = random.randint(0, 2**16) packet = cls(Type=cls.SYN_ACK, SequenceNumber=seq_number, Checksum=0, Acknowledgement=client_seq_num + 1) packet.updateChecksum() return packet @classmethod def Create_handshake_ACK(cls, server_seq_num, client_seq_num): packet = cls(Type=cls.ACK, SequenceNumber=client_seq_num + 1, Checksum=0, Acknowledgement=server_seq_num + 1) packet.updateChecksum() return packet @classmethod def Create_packet_ACK(cls, expected_seq_number): packet = cls(Type=cls.ACK, Checksum=0, Acknowledgement=expected_seq_number) packet.updateChecksum() return packet @classmethod def Create_RIP(cls, expected_seq_number): packet = cls(Type=cls.RIP, SequenceNumber=expected_seq_number, Checksum=0) packet.updateChecksum() return packet @classmethod def Create_RIP_ACK(cls, expected_seq_num, sender_seq_num): packet = cls(Type=cls.RIP_ACK, SequenceNumber=expected_seq_num, Checksum=0, Acknowledgement=sender_seq_num + 1) packet.updateChecksum() return packet @classmethod def Create_DATA(cls, seq_number, data, size_for_previous_data): packet = cls(Type=cls.DATA, SequenceNumber=seq_number + size_for_previous_data, Checksum=0, Data=data) packet.updateChecksum() return packet @classmethod def makeSynPacket(cls, seq): pkt = cls() pkt.Type = cls.TYPE_SYN pkt.SequenceNumber = seq pkt.updateChecksum() return pkt @classmethod def makeSynAckPacket(cls, seq, ack): pkt = cls() pkt.Type = cls.TYPE_SYN_ACK pkt.SequenceNumber = seq pkt.Acknowledgement = ack pkt.updateChecksum() return pkt @classmethod def makeAckPacket(cls, seq, ack): pkt = cls() pkt.Type = cls.TYPE_ACK if seq: pkt.SequenceNumber = seq pkt.Acknowledgement = ack pkt.updateChecksum() return pkt @classmethod def makeRipPacket(cls, seq, ack): pkt = cls() pkt.Type = cls.TYPE_RIP pkt.SequenceNumber = seq pkt.Acknowledgement = ack pkt.updateChecksum() return pkt @classmethod def makeRipAckPacket(cls, ack): pkt = cls() pkt.Type = cls.TYPE_RIP_ACK pkt.Acknowledgement = ack pkt.updateChecksum() return pkt @classmethod def makeDataPacket(cls, seq, data): pkt = cls() pkt.Type = cls.TYPE_DATA pkt.SequenceNumber = seq pkt.Data = data pkt.updateChecksum() return pkt
class PEEPPacket(PacketType): DEFINITION_IDENTIFIER = "PEEP.Packet" DEFINITION_VERSION = "1.0" FIELDS = [("Type", UINT8), ("SequenceNumber", UINT32({Optional: True})), ("Checksum", UINT16), ("Acknowledgement", UINT32({Optional: True})), ("Data", BUFFER({Optional: True}))] def __init__(self, typ=5, che=0): super().__init__() self.Type = typ self.Checksum = che @classmethod def set_data(cls, seq, ack, dat): pkt = cls(5, 0) pkt.SequenceNumber = seq pkt.Acknowledgement = ack pkt.Data = dat pkt.Checksum = pkt.calculateChecksum() return pkt @classmethod def set_synack(cls, seq, ack): pkt = cls(1, 0) pkt.SequenceNumber = seq pkt.Acknowledgement = ack pkt.Checksum = pkt.calculateChecksum() return pkt @classmethod def set_syn(cls, seq): pkt = cls(0, 0) pkt.SequenceNumber = seq pkt.Checksum = pkt.calculateChecksum() return pkt @classmethod def set_ack(cls, ack): pkt = cls(2, 0) pkt.Acknowledgement = ack pkt.Checksum = pkt.calculateChecksum() return pkt @classmethod def set_rip(cls, seq): pkt = cls(3, 0) pkt.SequenceNumber = seq pkt.Checksum = pkt.calculateChecksum() return pkt @classmethod def set_ripack(cls, ack): pkt = cls(4, 0) pkt.Acknowledgement = ack pkt.Checksum = pkt.calculateChecksum() return pkt def to_string(self): return "Type = " + self.get_type_string() + ". SEQ = " + str(self.SequenceNumber) \ + ". ACK = " + str(self.Acknowledgement) + ". Checksum = " + str(self.Checksum) def calculateChecksum(self): oldChecksum = self.Checksum self.Checksum = 0 bytes = self.__serialize__() self.Checksum = oldChecksum return zlib.adler32(bytes) & 0xffff def validate_checksum(self): return self.Checksum == self.calculateChecksum() def get_type_string(self): packet_type = ["SYN", "SYN-ACK", "ACK", "RIP", "RIP-ACK", "DATA"] return packet_type[self.Type]
class PEEPPacket(PacketType): # Type definitions TYPE_DESC = { 0: "SYN", 1: "SYN_ACK", 2: "ACK", 3: "RIP", 4: "RIP_ACK", 5: "DATA" } TYPE_SYN = 0 TYPE_SYN_ACK = 1 TYPE_ACK = 2 TYPE_RIP = 3 TYPE_RIP_ACK = 4 TYPE_DATA = 5 DEFINITION_IDENTIFIER = "PEEP.Packet" DEFINITION_VERSION = "1.0" FIELDS = [("Type", UINT8), ("SequenceNumber", UINT32({Optional: True})), ("Checksum", UINT16({Optional: True})), ("Acknowledgement", UINT32({Optional: True})), ("Data", BUFFER({Optional: True}))] def calculateChecksum(self): oldChecksum = self.Checksum self.Checksum = 0 bytes = self.__serialize__() self.Checksum = oldChecksum return zlib.adler32(bytes) & 0xffff def updateChecksum(self): self.Checksum = self.calculateChecksum() def verifyChecksum(self): return self.Checksum == self.calculateChecksum() @classmethod def makeSynPacket(cls, seq): pkt = cls() pkt.Type = cls.TYPE_SYN pkt.SequenceNumber = seq pkt.updateChecksum() return pkt @classmethod def makeSynAckPacket(cls, seq, ack): pkt = cls() pkt.Type = cls.TYPE_SYN_ACK pkt.SequenceNumber = seq pkt.Acknowledgement = ack pkt.updateChecksum() return pkt @classmethod def makeAckPacket(cls, seq, ack): pkt = cls() pkt.Type = cls.TYPE_ACK if seq: pkt.SequenceNumber = seq pkt.Acknowledgement = ack pkt.updateChecksum() return pkt @classmethod def makeRipPacket(cls, seq, ack): pkt = cls() pkt.Type = cls.TYPE_RIP pkt.SequenceNumber = seq pkt.Acknowledgement = ack pkt.updateChecksum() return pkt @classmethod def makeRipAckPacket(cls, ack): pkt = cls() pkt.Type = cls.TYPE_RIP_ACK pkt.Acknowledgement = ack pkt.updateChecksum() return pkt @classmethod def makeDataPacket(cls, seq, data): pkt = cls() pkt.Type = cls.TYPE_DATA pkt.SequenceNumber = seq pkt.Data = data pkt.updateChecksum() return pkt
class PLSPacket(PacketType): DEFINITION_IDENTIFIER = 'PLS.Packet' DEFINITION_VERSION = '1.0' FIELDS = [ ('Type', STRING), # type can be Hello, KeyTransport, Finished, Data and Close. ('Premaster_Secret', BUFFER({Optional: True})), ('Random', BUFFER({Optional: True})), ('Certificate', LIST(BUFFER, {Optional: True})), ('Encrypted_Data', BUFFER) ] @classmethod def HelloPacket(cls, random, mychain): pkt = cls() pkt.Type = "Hello" pkt.Random = random pkt.Certificate = mychain pkt.Encrypted_Data = b"" print("<><><><> SENT Hello Packet <><><><>") return pkt @classmethod def KeyPacket(cls, random): pkt = cls() pkt.Type = "KeyTransport" pkt.Premaster_Secret = random # need to sort it out #pkt.Random = random #This too #pkt.Certificate = PLSCertificate #Should send a list pkt.Encrypted_Data = b"" print("<><><><> SENT Key Packet <><><><>") return pkt @classmethod def FinPacket(cls): pkt = cls() pkt.Type = "Finished" #pkt.Premaster_Secret = "" # need to sort it out #pkt.Random = "" #This too #pkt.Certificate = "" #Should send a list pkt.Encrypted_Data = b"" print("<><><><> SENT Finished Packet <><><><>") return pkt @classmethod def ClosePacket(cls): pkt = cls() pkt.Type = "Close" #pkt.Premaster_Secret = "" # need to sort it out #pkt.Random = 0 #This too #pkt.Certificate = "" #Should send a list pkt.Encrypted_Data = b"" print("<><><><> SENT Close Packet <><><><>") return pkt @classmethod def DataPacket(cls, encrypted_data): pkt = cls() pkt.Type = "Data" #pkt.Premaster_Secret = "" # need to sort it out #pkt.Random = 0 #This too #pkt.Certificate = "" #Should send a list pkt.Encrypted_Data = encrypted_data print("<><><><> SENT Data Packet <><><><>") return pkt
class RIPPPacket(PacketType): TYPE_SYN = "SYN" TYPE_ACK = "ACK" TYPE_FIN = "FIN" TYPE_DATA = "DATA" DEFINITION_IDENTIFIER = "RIPP.Packet" DEFINITION_VERSION = "1.0" FIELDS = [ ("Type", STRING), ("SequenceNumber", UINT32({Optional: True})), ("Checksum", BUFFER({Optional: True})), ("Acknowledgement", UINT32({Optional: True})), ("Data", BUFFER({Optional: True})) ] def calculateChecksum(self): # oldChecksum = self.Checksum self.Checksum = b"0" #when calculating the hash value, we should make sure # the already existing self.Checksum not going to interfere our next calculation for hash. #because the format of Checksum is BUFFER, so we need to generate a '0' in byte, which could be put into the buffer. bytes = self.__serialize__() #serialize the packet into bytes # self.Checksum = oldChecksum hash = hashlib.sha256() #we use sha256 algorithm to calculate the hash value of the packet hash.update(bytes) return hash.digest() #why we use digest() not hexdigest() is the return value format of the former is bytes and that of the latter is str #return the output of hash, whose format is int def updateChecksum(self): self.Checksum = self.calculateChecksum() #calculate the hash value and attribute it to pkt.Checksum argument def verifyChecksum(self): oldChecksum = self.Checksum newChecksum = self.calculateChecksum() self.Checksum = newChecksum return newChecksum == oldChecksum #verify whether the new hash value equals to the former one @classmethod def SynPacket(cls, seq): pkt = cls() pkt.Type = cls.TYPE_SYN pkt.SequenceNumber = seq #seq = x pkt.updateChecksum() #calculate the hash value of the packet return pkt @classmethod def SynAckPacket(cls, seq, ack): pkt = cls() pkt.Type = cls.TYPE_SYN + cls.TYPE_ACK pkt.SequenceNumber = seq #seq = y pkt.Acknowledgement = ack #ack = seq(received) + 1 pkt.updateChecksum() return pkt @classmethod def AckPacket(cls, ack): pkt = cls() pkt.Type = cls.TYPE_ACK pkt.Acknowledgement = ack #ack = y + 1 pkt.updateChecksum() return pkt @classmethod def DataPacket(cls, seq, data): pkt = cls() pkt.Type = cls.TYPE_DATA pkt.SequenceNumber = seq pkt.Data = data pkt.updateChecksum() return pkt @classmethod def FinPacket(cls, seq): pkt = cls() pkt.Type = cls.TYPE_FIN pkt.SequenceNumber = seq # pkt.Acknowledgement = ack pkt.updateChecksum() return pkt @classmethod def FinAckPacket(cls, ack): pkt = cls() pkt.Type = cls.TYPE_FIN + cls.TYPE_ACK pkt.Acknowledgement = ack # pkt.SequenceNumber = seq pkt.updateChecksum() return pkt