def in6_getRandomizedIfaceId(ifaceid, previous=None):
    """
    Implements the interface ID generation algorithm described in RFC 3041.
    The function takes the Modified EUI-64 interface identifier generated
    as described in RFC 4291 and an optional previous history value (the
    first element of the output of this function). If no previous interface
    identifier is provided, a random one is generated. The function returns
    a tuple containing the randomized interface identifier and the history
    value (for possible future use). Input and output values are provided in
    a "printable" format as depicted below.

    ex:
    >>> in6_getRandomizedIfaceId('20b:93ff:feeb:2d3')
    ('4c61:76ff:f46a:a5f3', 'd006:d540:db11:b092')
    >>> in6_getRandomizedIfaceId('20b:93ff:feeb:2d3',
                                 previous='d006:d540:db11:b092')
    ('fe97:46fe:9871:bd38', 'eeed:d79c:2e3f:62e')
    """

    s = b""
    if previous is None:
        d = b"".join(chb(x) for x in range(256))
        for _ in range(8):
            s += chb(random.choice(d))
        previous = s
    s = inet_pton(socket.AF_INET6, "::" + ifaceid)[8:] + previous
    import hashlib
    s = hashlib.md5(s).digest()
    s1, s2 = s[:8], s[8:]
    s1 = chb(orb(s1[0]) | 0x04) + s1[1:]
    s1 = inet_ntop(socket.AF_INET6, b"\xff" * 8 + s1)[20:]
    s2 = inet_ntop(socket.AF_INET6, b"\xff" * 8 + s2)[20:]
    return (s1, s2)

 def post_build(self, p, pay):
     if self.length is None:
         tmp_len = len(p)
         tmp_pay = p[:2] + chb((tmp_len >> 8) & 0xff)
         p = tmp_pay + chb(tmp_len & 0xff) + p[4:]
     p += pay
     return p

    def post_build(self, p, pay):
        p += pay

        if self.keysize is None:
            keysize = len(self.authdata)
            p = p[:6] + chb((keysize >> 8) & 0xff) + chb(keysize & 0xff) + p[8:]  # noqa: E501

        return p

 def post_build(self, pkt, pay):
     if self.len is None:
         # len should be a FieldLenField but has an unsupported
         # format (14 bits)
         flags = orb(pkt[0]) & 0xc0
         length = len(self.value)
         pkt = chb(flags + (length >> 8)) + chb(length % 256) + pkt[2:]
     return pkt + pay

    def post_build(self, p, pay):
        p += pay

        if self.len is None:
            l = len(p)
            p = p[:2] + chb((l >> 8) & 0xff) + chb(l & 0xff) + p[4:]

        return p

 def post_build(self, p, pay):
     p += pay
     if self.Length is None:
         l = len(p)
         p = p[:6] + chb((l >> 8) & 0xff) + chb(l & 0xff) + p[8:]
     if self.chksum is None:
         ck = checksum(p)
         p = p[:2] + chb(ck >> 8) + chb(ck & 0xff) + p[4:]
     return p

    def decompressDestinyAddr(self, packet):
        try:
            tmp_ip = inet_pton(socket.AF_INET6, self.destinyAddr)
        except socket.error:
            tmp_ip = b"\x00" * 16

        if self.m == 0 and self.dac == 0:
            if self.dam == 0:
                pass
            elif self.dam == 1:
                tmp_ip = LINK_LOCAL_PREFIX[0:8] + tmp_ip[-8:]
            elif self.dam == 2:
                tmp_ip = LINK_LOCAL_PREFIX[0:8] + b"\x00\x00\x00\xff\xfe\x00" + tmp_ip[-2:]  # noqa: E501
            """else: #self.dam == 3
                raise Exception('Unimplemented')"""

        elif self.m == 0 and self.dac == 1:
            if self.dam == 0:
                raise Exception('Reserved')
            elif self.dam == 0x3:
                underlayer = self.underlayer
                while underlayer is not None and not isinstance(underlayer, Dot15d4Data):  # noqa: E501
                    underlayer = underlayer.underlayer
                if type(underlayer) == Dot15d4Data:
                    if underlayer.underlayer.fcf_destaddrmode == 3:
                        tmp_ip = LINK_LOCAL_PREFIX[0:8] + struct.pack(">Q", underlayer.dest_addr)  # noqa: E501
                        # Turn off the bit 7.
                        tmp_ip = tmp_ip[0:8] + struct.pack("B", (orb(tmp_ip[8]) ^ 0x2)) + tmp_ip[9:16]  # noqa: E501
                    elif underlayer.underlayer.fcf_destaddrmode == 2:
                        tmp_ip = LINK_LOCAL_PREFIX[0:8] + \
                            b"\x00\x00\x00\xff\xfe\x00" + \
                            struct.pack(">Q", underlayer.dest_addr)[6:]
                else:
                    # Most of the times, it's necessary the IEEE 802.15.4 data to extract this address  # noqa: E501
                    raise Exception('Unimplemented: IP Header is contained into IEEE 802.15.4 frame, in this case it\'s not available.')  # noqa: E501
            elif self.dam not in [0x1, 0x2]:
                warning("Unknown destiny address compression mode !")
        elif self.m == 1 and self.dac == 0:
            if self.dam == 0:
                raise Exception("unimplemented")
            elif self.dam == 1:
                tmp = b"\xff" + chb(tmp_ip[16 - destiny_addr_mode(self)])
                tmp_ip = tmp + b"\x00" * 9 + tmp_ip[-5:]
            elif self.dam == 2:
                tmp = b"\xff" + chb(tmp_ip[16 - destiny_addr_mode(self)])
                tmp_ip = tmp + b"\x00" * 11 + tmp_ip[-3:]
            else:  # self.dam == 3:
                tmp_ip = b"\xff\x02" + b"\x00" * 13 + tmp_ip[-1:]
        elif self.m == 1 and self.dac == 1:
            if self.dam == 0x0:
                raise Exception("Unimplemented: I didnt understand the 6lowpan specification")  # noqa: E501
            else:  # all the others values
                raise Exception("Reserved value by specification.")

        self.destinyAddr = inet_ntop(socket.AF_INET6, tmp_ip)
        return self.destinyAddr

 def post_build(self, p, pay):
     p += pay
     if self.Length is None:
         tmp_len = len(p)
         tmp_p = p[:6] + chb((tmp_len >> 8) & 0xff) + chb(tmp_len & 0xff)
         p = tmp_p + p[8:]
     if self.chksum is None:
         ck = checksum(p)
         p = p[:2] + chb(ck >> 8) + chb(ck & 0xff) + p[4:]
     return p

 def post_build(self, p, pay):
     if self.chksum is None:
         if isinstance(self.underlayer, IP):
             ck = in4_chksum(112, self.underlayer, p)
         elif isinstance(self.underlayer, IPv6):
             ck = in6_chksum(112, self.underlayer, p)
         else:
             warning("No IP(v6) layer to compute checksum on VRRP. Leaving null")  # noqa: E501
             ck = 0
         p = p[:6] + chb(ck >> 8) + chb(ck & 0xff) + p[8:]
     return p

 def enc(cls, s):
     # /!\ this is DER encoding (bit strings are only zero-bit padded)
     s = raw(s)
     if len(s) % 8 == 0:
         unused_bits = 0
     else:
         unused_bits = 8 - len(s) % 8
         s += b"0" * unused_bits
     s = b"".join(chb(int(b"".join(chb(y) for y in x), 2))
                  for x in zip(*[iter(s)] * 8))
     s = chb(unused_bits) + s
     return chb(hash(cls.tag)) + BER_len_enc(len(s)) + s

def BER_id_enc(n):
    if n < 256:
        # low-tag-number
        return chb(n)
    else:
        # high-tag-number
        s = BER_num_enc(n)
        tag = orb(s[0])             # first byte, as an int
        tag &= 0x07                 # reset every bit from 8 to 4
        tag <<= 5                   # move back the info bits on top
        tag |= 0x1f                 # pad with 1s every bit from 5 to 1
        return chb(tag) + s[1:]

    def post_build(self, p, pay):
        """Called implicitly before a packet is sent to compute and place IGMP checksum.  # noqa: E501

        Parameters:
          self    The instantiation of an IGMP class
          p       The IGMP message in hex in network byte order
          pay     Additional payload for the IGMP message
        """
        p += pay
        if self.chksum is None:
            ck = checksum(p)
            p = p[:2] + chb(ck >> 8) + chb(ck & 0xff) + p[4:]
        return p

def BER_len_enc(ll, size=0):
    if ll <= 127 and size == 0:
        return chb(ll)
    s = b""
    while ll or size > 0:
        s = chb(ll & 0xff) + s
        ll >>= 8
        size -= 1
    if len(s) > 127:
        raise BER_Exception(
            "BER_len_enc: Length too long (%i) to be encoded [%r]" %
            (len(s), s)
        )
    return chb(len(s) | 0x80) + s

def obfuscate(pay, secret, session_id, version, seq):
    '''

    Obfuscation methodology from section 3.7
    https://tools.ietf.org/html/draft-ietf-opsawg-tacacs-06#section-3.7

    '''

    pad = b""
    curr_pad = b""

    # pad length must equal the payload to obfuscate.
    # pad = {MD5_1 [,MD5_2 [ ... ,MD5_n]]}

    while len(pad) < len(pay):

        msg = hashlib.md5()
        msg.update(struct.pack('!I', session_id))
        msg.update(secret.encode())
        msg.update(struct.pack('!BB', version, seq))
        msg.update(curr_pad)
        curr_pad = msg.digest()
        pad += curr_pad

    # Obf/Unobfuscation via XOR operation between plaintext and pad

    return b"".join(chb(orb(pad[i]) ^ orb(pay[i])) for i in range(len(pay)))

 def post_build(self, p, pay):
     p += pay
     optionlen = self.optionlen
     if optionlen is None:
         optionlen = (len(self.options) + 3) // 4
         p = chb(optionlen & 0x2f | orb(p[0]) & 0xc0) + p[1:]
     return p

 def next(self):
     c = pcap_next_ex(self.pcap, byref(self.header), byref(self.pkt_data))  # noqa: E501
     if not c > 0:
         return
     ts = self.header.contents.ts.tv_sec + float(self.header.contents.ts.tv_usec) / 1000000  # noqa: E501
     pkt = b"".join(chb(i) for i in self.pkt_data[:self.header.contents.len])  # noqa: E501
     return ts, pkt

def _tls_del_pad(p):
    """
    Provided with a just decrypted TLSCiphertext (now a TLSPlaintext instance)
    p, the function removes the trailing padding found in p.data. It also
    performs some sanity checks on the padding (length, content, ...). False
    is returned if one of the check fails. Otherwise, True is returned,
    indicating that p.data and p.len have been updated.
    """

    if p.len < 1:
        warning("Message format is invalid (padding)")
        return False

    padlen = orb(p.data[-1])
    padsize = padlen + 1

    if p.len < padsize:
        warning("Invalid padding length")
        return False

    if p.data[-padsize:] != chb(padlen) * padsize:
        warning("Padding content is invalid %s", repr(p.data[-padsize:]))
        return False

    p.data = p.data[:-padsize]
    p.len -= padsize

    return True

 def post_build(self, p, pay):
     if self.headerLen is None:
         headerLen = len(p)
         if isinstance(self.payload, (USBpcapTransferIsochronous,
                                      USBpcapTransferInterrupt,
                                      USBpcapTransferControl)):
             headerLen += len(self.payload) - len(self.payload.payload)
         p = chb(headerLen) + p[1:]
     return p + pay

 def post_build(self, p, pay):
     # This just forces destaddrmode to None for Ack frames.
     if self.fcf_frametype == 2 and self.fcf_destaddrmode != 0:
         self.fcf_destaddrmode = 0
         return p[:1] + \
             chb((self.fcf_srcaddrmode << 6) + (self.fcf_framever << 4)) \
             + p[2:] + pay
     else:
         return p + pay

def BER_num_enc(ll, size=1):
    x = []
    while ll or size > 0:
        x.insert(0, ll & 0x7f)
        if len(x) > 1:
            x[0] |= 0x80
        ll >>= 7
        size -= 1
    return b"".join(chb(k) for k in x)