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
