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"
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.Packet"
DEFINITION_VERSION = "1.0"
FIELDS = [("Type", UINT8), ("SequenceNumber", UINT32({Optional: True})),
("Checksum", UINT16),
("Acknowledgement", UINT32({Optional: True})),
("Data", BUFFER({Optional: True}))]
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 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 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 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 ShutdownPacket(PoopPacketType):
DEFINITION_IDENTIFIER = "poop.shutdownpacket"
DEFINITION_VERSION = "1.0"
SUCCESS = 0
ERROR = 1
FIELDS = [
("FIN", UINT32({Optional: True})),
("FACK", UINT32({Optional: True})) #这个FACK要研究一下
]
class HandshakePacket(PoopPacketType):
DEFINITION_IDENTIFIER = "poop.handshakepacket"
DEFINITION_VERSION = "1.0"
NOT_STARTED = 0
SUCCESS = 1
ERROR = 2
FIELDS = [("SYN", UINT32({Optional: True})),
("ACK", UINT32({Optional: True})), ("status", UINT8),
("hash", UINT32)]
class HandshakePacket(PoopPacketType):
DEFINITION_IDENTIFIER = "poop.handshakepacket"
DEFINITION_VERSION = "1.0"
NOT_STARTED = 0
SUCCESS = 1
ERROR = 2
FIELDS = [("status", UINT8), ("SYN", UINT32({Optional: True})),
("ACK", UINT32({Optional: True})),
("error", STRING({Optional: True})),
("last_valid_sequence", UINT32({Optional: True}))]
class HandshakePacket(PoopPacketType
): #这个地方就不需要start那个packet了，因为这个packet的内容就包括了start中需要的内容
DEFINITION_IDENTIFIER = "poop.handshakepacket"
DEFINITION_VERSION = "1.0"
NOT_STARTED = 0
SUCCESS = 1
ERROR = 2
FIELDS = [
("status", UINT8),
("SYN", UINT32({Optional: True})),
("ACK", UINT32({Optional: True})),
("error", STRING({Optional: True})),
("hash", UINT32),
]
class MathQuestion(PacketType):
DEFINITION_IDENTIFIER = "MQ"
DEFINITION_VERSION = "1.0"
FIELDS = [
("O1", UINT32),
("O2", UINT32({Optional:True})),
("Operation", STRING),
("ID", UINT32)
]
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 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 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 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
