(5 . 6)(5 . 8)
from lib.serpent import serpent_cbc_decrypt 
from commands import BROADCAST
from commands import DIRECT 
from commands import IGNORE 
from lib.message import Message
import base64
import binascii
import time
(12 . 6)(14 . 7)
import sys
import hmac
import random
import os 
import pprint
pp = pprint.PrettyPrinter(indent=4)

(28 . 6)(31 . 7)
DUPLICATE_PACKET = 1
MALFORMED_PACKET = 2
INVALID_SIGNATURE = 3
IGNORED = 4

class Infosec(object): 
    def __init__(self, server=None):
(35 . 11)(39 . 11)

    def pack(self, peer, message):
        try:
            timestamp = message["timestamp"]
            timestamp = message.timestamp
        except:
            timestamp = None
        command = message["command"]
        speaker = self._pad(message["speaker"], MAX_SPEAKER_SIZE)
        command = message.command
        speaker = self._pad(message.speaker, MAX_SPEAKER_SIZE)

        # if we are rebroadcasting we need to use the original timestamp

(56 . 32)(60 . 34)
        # there this is the first message
        

        if message["original"]:
        if message.original:
            if command == DIRECT:
                self_chain = self.server.state.get_last_message_hash(message["speaker"], peer.peer_id)
                self_chain = self.server.state.get_last_message_hash(message.speaker, peer.peer_id)
            elif command == BROADCAST:
                self_chain = self.server.state.get_last_message_hash(message["speaker"])
                self_chain = self.server.state.get_last_message_hash(message.speaker)
            elif command == IGNORE:
                self_chain = "\x00" * 32
            net_chain = "\x00" * 32
        else:
            self_chain = message["self_chain"] 
            net_chain = message["net_chain"]
            self_chain = message.self_chain 
            net_chain = message.net_chain

        # pack message bytes

        message_bytes = struct.pack(MESSAGE_PACKET_FORMAT, int_ts, self_chain, net_chain, speaker, message["body"].encode("ascii"))
        message_bytes = struct.pack(MESSAGE_PACKET_FORMAT, int_ts, self_chain, net_chain, speaker, message.body)

        # log messages 

        if message["original"]:
        if message.original:
            if command == DIRECT:
                self.server.state.log(message["speaker"], message_bytes, peer.peer_id)
                self.server.state.log(message.speaker, message_bytes, peer.peer_id)
            elif command == BROADCAST:
                self.server.state.log(message["speaker"], message_bytes)
                self.server.state.log(message.speaker, message_bytes)

        # pack packet bytes

        nonce = self._generate_nonce(16)
        bounces = message["bounces"] 
        bounces = message.bounces 
        version = 0xfe
        red_packet_bytes = struct.pack(RED_PACKET_FORMAT, nonce, bounces, version, command, self._pad(message_bytes, MAX_MESSAGE_LENGTH))

(114 . 14)(120 . 14)
            black_packet_bytes, signature_bytes = struct.unpack(BLACK_PACKET_FORMAT, black_packet)
        except:
            self.server.print_error("Discarding malformed black packet from %s" % peer.get_key())
            return { "error_code": MALFORMED_PACKET } 
            return Message({ "error_code": MALFORMED_PACKET }, self.server)

        # check signature

        signature_check_bytes = hmac.new(signing_key, black_packet_bytes, hashlib.sha384).digest()

        if(signature_check_bytes != signature_bytes):
            return { "error_code": INVALID_SIGNATURE } 
            return Message({ "error_code": INVALID_SIGNATURE }, self.server)

        # try to decrypt black packet
        
(132 . 6)(138 . 11)

        nonce, bounces, version, command, message_bytes = struct.unpack(RED_PACKET_FORMAT, red_packet_bytes)

        # nothing to be done for an IGNORE command

        if command == IGNORE:
            return Message({"error_code": IGNORED})

        # unpack message

        int_ts, self_chain, net_chain, speaker, message = struct.unpack(MESSAGE_PACKET_FORMAT, message_bytes)
(140 . 10)(151 . 10)
        # check timestamp

        if(int_ts not in self._ts_range()):
            return { "error_code": STALE_PACKET } 
            return Message({ "error_code": STALE_PACKET }, self.server)

        if(self.server.recent.has(int_ts)):
            return { "error_code": DUPLICATE_PACKET } 
            return Message({ "error_code": DUPLICATE_PACKET }, self.server)
        else:
            self.server.recent.insert(int_ts)

(167 . 17)(178 . 19)
                unpadded_message = message[0:index]
                break 

        # return the message, timestamp, and command (command replaces propagate)

        return { "body": unpadded_message.rstrip(),
                 "timestamp": int_ts,
                 "command": command,
                 "speaker": speaker,
                 "bounces": bounces,
                 "self_chain": self_chain,
                 "net_chain": net_chain,
                 "self_chain_valid": self_chain_valid,
                 "error_code": None}
        return Message({ 
                        "peer": peer,
                        "body": unpadded_message.rstrip(),
                        "timestamp": int_ts,
                        "command": command,
                        "speaker": speaker,
                        "bounces": bounces,
                        "self_chain": self_chain,
                        "net_chain": net_chain,
                        "self_chain_valid": self_chain_valid,
                        "error_code": None
                        },
                        self.server)

    def _pad(self, text, size):
        return text.ljust(size)
(189 . 3)(202 . 6)
    def _generate_nonce(self, length=8):
        """Generate pseudorandom number."""
        return ''.join([str(random.randint(0, 9)) for i in range(length)])

    def gen_rubbish_body(self):
        return os.urandom(MAX_MESSAGE_LENGTH)