- 7EE0913AE7ADDD7E419CCDE7A0F4E7C2348029AD00E1D6994DA98430875358B91032DED251EE34C7917C81308BE84E9042DA9D54780B440AEC23065A53C498FF
+ 3DF1A18DC139FA71D9CE6B666778B01F9CFBB91C1A21A59CBD398914599A2F3D94EE6D453875B27F574261D5DA4921928BA9ADB0071996B764EB03ED5E838701
blatta/README.txt

(7 . 8)(7 . 8)

Notably missing:

- Pest-specific warning/informational output for incoming/outgoing messages
- GetData message support 
- Address Cast
- Prod
- Key Offer message support
- Key Slice message support

(21 . 6)(21 . 7)
GENKEY
KEY
UNKEY
KNOB

GETTING STARTED

- 0DCE4472982646FFA031D3C88C98DCDC52C94627A4E046DA8D403A501A118E74D9893604B3DAAB04AF8677711A32CCAC2D12C3A765A64BD8E36A250E0F8986BB
+ C50E1B42DBE007ED9D7DF82747BB7CE0C122966AF972A0973C9F03C96F85E7EDC24642CB770935CF61EB037924C7B06A2A295E500081A4BCBF0FF1B9E2318605
blatta/blatta

(2 . 17)(2 . 9)

import os
import re
import select
import socket
import string
import sys
import tempfile
import time
import logging
from lib.server import VERSION
from lib.server import Server 
from lib.peer import Peer
from datetime import datetime
from lib.station import Station, VERSION
from optparse import OptionParser


(27 . 29)(19 . 14)
        "-b", "--db-path",
        help="Specify path to settings database file")
    op.add_option(
        "-c", "--config-file-path",
        metavar="X",
        help="load the configfile from X")
    op.add_option(
        "-n", "--channel-name",
        metavar="X",
        help="specify the channel name for this Pest network")
    op.add_option(
        "-d", "--daemon",
        action="store_true",
        help="fork and become a daemon")
    op.add_option(
        "--log-level",
        help="specify priority level for logging: info or debug")
    op.add_option(
        "--listen",
        metavar="X",
        help="listen on specific IP address X")
    op.add_option(
        "--logdir",
        metavar="X",
        help="store channel log in directory X")
    op.add_option(
        "--motd",
        metavar="X",
        help="display file X as message of the day")
(67 . 10)(44 . 6)
        metavar="X",
        help="listen for UDP packets on X;"
             " default: 7778")
    op.add_option(
        "--statedir",
        metavar="X",
        help="save persistent channel state (topic) in directory X")
    if os.name == "posix":
        op.add_option(
            "--chroot",
(87 . 10)(60 . 7)
    if options.channel_name is None:
        options.channel_name = "#pest"
    log_format = "%(levelname)s %(asctime)s: %(message)s"
    if options.log_level == 'debug':
        logging.basicConfig(level=logging.DEBUG, format=log_format, stream=sys.stdout)
    else:
        logging.basicConfig(level=logging.INFO, format=log_format, stream=sys.stdout)
    logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"), format=log_format, stream=sys.stdout)
    if options.irc_ports is None:
        options.irc_ports = "6697"
    if options.udp_port is None:
(99 . 8)(69 . 6)
        options.udp_port = int(options.udp_port) 
    if options.db_path is None:
        options.db_path = "blatta.db"
    if options.config_file_path is None:
        options.config_file_path = "config.py" 
    if options.chroot:
        if os.getuid() != 0:
            op.error("Must be root to use --chroot")
(132 . 11)(100 . 9)
        except ValueError:
            op.error("bad port: %r" % port)
    options.irc_ports = irc_ports
    server = Server(options)
    if options.daemon:
        server.daemonize()
    station = Station(options)
    try:
        server.start()
        station.start()
    except KeyboardInterrupt:
        logging.error("Interrupted.")

- 79E611C4EC3B9DCBFC23C09140F4F2DB23923B97BEC5427FB28E3886DDAC5F074DA2A80C379837A011FC834D41DD2273F9D9A85635983DDDE769F5924F0AB74F
+
blatta/config.py.example

(1 . 10)(0 . 0)
peers = [
    {
        "name":"schellenberg",
	# Secrets must be precisely 64 bytes.
        "local_secret":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
        "remote_secret":"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
        "address":"10.0.0.1",
        "port":7778
    }
]

-
+ B73F1A4AFA94CAA17167B0316CE1AD893C33E46F3E5114230B808BABC21E4C1F9A3327576E890114DEBE2F48E2FBC4A16533A02E824D1080CDC80268A39F30BF
blatta/lib/broadcast.py

(0 . 0)(1 . 56)
import logging
import time
import hashlib
import binascii
from message import Message
from message import BROADCAST


class Broadcast(Message):
    def __init__(self, message, state):
        message['command'] = BROADCAST
        message['bounces'] = 0
        super(Broadcast, self).__init__(message, state)

    def send(self):
        if not self.speaker:
            logging.error("aborting message send due speaker not being set")
            return

        # if we are not rebroadcasting we need to set the timestamp
        self.timestamp = int(time.time())

        target_peer = None

        self.message_bytes = self.get_message_bytes(target_peer)
        self.message_hash = hashlib.sha256(self.message_bytes).digest()

        self.long_buffer.intern(self)

        self.state.update_broadcast_self_chain(self.message_hash)
        self.state.update_net_chain(self.message_hash)
        for peer in self.state.get_keyed_peers(exclude_addressless=True):
            signed_packet_bytes = self.pack(peer, self.command, self.bounces, self.message_bytes)
            peer.send(signed_packet_bytes)
            self.log_outgoing(peer)

    # we already have message bytes here since this message came from the long buffer
    def retry(self, requesting_peer):
        signed_packet_bytes = self.pack(requesting_peer, self.command, self.bounces, self.message_bytes)
        requesting_peer.send(signed_packet_bytes)
        self.log_outgoing(requesting_peer)

    def forward(self):
        if not self.speaker:
            logging.error("aborting message send due speaker not being set")
            return

        reporting_peer_ids = map(lambda p: p.peer_id, self.reporting_peers)
        for peer in self.state.get_keyed_peers(exclude_addressless=True, exclude_ids=reporting_peer_ids):
            # we don't want to send a broadcast back to the originator
            if self.peer and (peer.peer_id == self.peer.peer_id):
                continue

            signed_packet_bytes = Message.pack(peer, self.command, self.bounces, self.message_bytes)
            peer.send(signed_packet_bytes)
            self.log_outgoing(peer)

-
+ 97EEBB27E6EC219B66D69A66FFE37962046B5F76A2A30A11AAD259DE4985789E61837290C9F327E22D2D04E7894DF0AEC767D67AAB4E86F7C81DF22EB162AD91
blatta/lib/caribou.py

(0 . 0)(1 . 271)
"""
Caribou is a simple SQLite database migrations library, built
to manage the evoluton of client side databases over multiple releases 
of an application.
"""

from __future__ import with_statement

__author__ = 'clutchski@gmail.com'

import contextlib
import datetime
import glob
import imp
import os.path
import sqlite3
import traceback

# statics

VERSION_TABLE = 'migration_version'
UTC_LENGTH = 14

# errors

class Error(Exception):
    """ Base class for all Caribou errors. """
    pass

class InvalidMigrationError(Error):
    """ Thrown when a client migration contains an error. """
    pass

class InvalidNameError(Error):
    """ Thrown when a client migration has an invalid filename. """

    def __init__(self, filename):
        msg = 'Migration filenames must start with a UTC timestamp. ' \
              'The following file has an invalid name: %s' % filename
        super(InvalidNameError, self).__init__(msg)

# code

@contextlib.contextmanager
def execute(conn, sql, params=None):
    params = [] if params is None else params
    cursor = conn.execute(sql, params)
    try:
        yield cursor
    finally:
        cursor.close()

@contextlib.contextmanager
def transaction(conn):
    try:
        yield
        conn.commit()
    except:
        conn.rollback()
        msg = "Error in transaction: %s" % traceback.format_exc()
        raise Error(msg)

def has_method(an_object, method_name):
    return hasattr(an_object, method_name) and \
                    callable(getattr(an_object, method_name))

def is_directory(path):
    return os.path.exists(path) and os.path.isdir(path)

class Migration(object):
    """ This class represents a migration version. """

    def __init__(self, path):
        self.path = path
        self.filename = os.path.basename(path)
        self.module_name, _ = os.path.splitext(self.filename)
        self.get_version() # will assert the filename is valid
        self.name = self.module_name[UTC_LENGTH:]
        while self.name.startswith('_'):
            self.name = self.name[1:]
        try:
            self.module = imp.load_source(self.module_name, path)
        except:
            msg = "Invalid migration %s: %s" % (path, traceback.format_exc())
            raise InvalidMigrationError(msg)
        # assert the migration has the needed methods
        missing = [m for m in ['upgrade', 'downgrade'] 
                      if not has_method(self.module, m)]
        if missing:
            msg = 'Migration %s is missing required methods: %s.' % (
                    self.path, ', '.join(missing))
            raise InvalidMigrationError(msg)

    def get_version(self):
        if len(self.filename) < UTC_LENGTH:
            raise InvalidNameError(self.filename)
        timestamp = self.filename[:UTC_LENGTH]
        #FIXME: is this test sufficient?
        if not timestamp.isdigit():
            raise InvalidNameError(self.filename)
        return timestamp

    def upgrade(self, conn):
        self.module.upgrade(conn)

    def downgrade(self, conn):
        self.module.downgrade(conn)

    def __repr__(self):
        return 'Migration(%s)' % self.filename

class Database(object):

    def __init__(self, db_url):
        self.db_url = db_url
        self.conn = sqlite3.connect(db_url)

    def close(self):
        self.conn.close()

    def is_version_controlled(self):
        sql = """select *
                   from sqlite_master
                  where type = 'table'
                    and name = :1"""
        with execute(self.conn, sql, [VERSION_TABLE]) as cursor:
            return bool(cursor.fetchall())

    def upgrade(self, migrations, target_version=None):
        if target_version:
            _assert_migration_exists(migrations, target_version)

        migrations.sort(key=lambda x: x.get_version())
        database_version = self.get_version()

        for migration in migrations:
            current_version = migration.get_version()
            if current_version <= database_version:
                continue
            if target_version and current_version > target_version:
                break
            migration.upgrade(self.conn)
            new_version = migration.get_version()
            self.update_version(new_version)

    def downgrade(self, migrations, target_version):
        if target_version not in (0, '0'):
            _assert_migration_exists(migrations, target_version)

        migrations.sort(key=lambda x: x.get_version(), reverse=True)
        database_version = self.get_version()

        for i, migration in enumerate(migrations):
            current_version = migration.get_version()
            if current_version > database_version:
                continue
            if current_version <= target_version:
                break
            migration.downgrade(self.conn)
            next_version = 0
            # if an earlier migration exists, set the db version to 
            # its version number
            if i < len(migrations) - 1:
                next_migration = migrations[i + 1]
                next_version = next_migration.get_version()
            self.update_version(next_version)

    def get_version(self):
        """ Return the database's version, or None if it is not under version
            control.
        """
        if not self.is_version_controlled():
            return None
        sql = 'select version from %s' % VERSION_TABLE
        with execute(self.conn, sql) as cursor:
            result = cursor.fetchall()
            return result[0][0] if result else 0

    def update_version(self, version):
        sql = 'update %s set version = :1' % VERSION_TABLE
        with transaction(self.conn):
            self.conn.execute(sql, [version])

    def initialize_version_control(self):
        sql = """ create table if not exists %s
                  ( version text ) """ % VERSION_TABLE
        with transaction(self.conn):
            self.conn.execute(sql)
            self.conn.execute('insert into %s values (0)' % VERSION_TABLE)

    def __repr__(self):
        return 'Database("%s")' % self.db_url

def _assert_migration_exists(migrations, version):
    if version not in (m.get_version() for m in migrations):
        raise Error('No migration with version %s exists.' % version)

def load_migrations(directory):
    """ Return the migrations contained in the given directory. """
    if not is_directory(directory):
        msg = "%s is not a directory." % directory
        raise Error(msg)
    wildcard = os.path.join(directory, '*.py')
    migration_files = glob.glob(wildcard)
    return [Migration(f) for f in migration_files]
   
def upgrade(db_url, migration_dir, version=None):
    """ Upgrade the given database with the migrations contained in the
        migrations directory. If a version is not specified, upgrade
        to the most recent version.
    """
    with contextlib.closing(Database(db_url)) as db:
        db = Database(db_url)
        if not db.is_version_controlled():
            db.initialize_version_control()
        migrations = load_migrations(migration_dir)
        db.upgrade(migrations, version)

def downgrade(db_url, migration_dir, version):
    """ Downgrade the database to the given version with the migrations
        contained in the given migration directory.
    """
    with contextlib.closing(Database(db_url)) as db:
        if not db.is_version_controlled():
            msg = "The database %s is not version controlled." % (db_url)
            raise Error(msg)
        migrations = load_migrations(migration_dir)
        db.downgrade(migrations, version)

def get_version(db_url):
    """ Return the migration version of the given database. """
    with contextlib.closing(Database(db_url)) as db:
        return db.get_version()

def create_migration(name, directory=None):
    """ Create a migration with the given name. If no directory is specified,
        the current working directory will be used.
    """
    directory = directory if directory else '.'
    if not is_directory(directory):
        msg = '%s is not a directory.' % directory
        raise Error(msg)

    now = datetime.datetime.now()
    version = now.strftime("%Y%m%d%H%M%S")

    contents = MIGRATION_TEMPLATE % {'name':name, 'version':version}

    name = name.replace(' ', '_')
    filename = "%s_%s.py" % (version, name)
    path = os.path.join(directory, filename)
    with open(path, 'w') as migration_file:
        migration_file.write(contents)
    return path

MIGRATION_TEMPLATE = """\
\"\"\"
This module contains a Caribou migration.

Migration Name: %(name)s 
Migration Version: %(version)s
\"\"\"

def upgrade(connection):
    # add your upgrade step here
    pass

def downgrade(connection):
    # add your downgrade step here
    pass
"""

- 9E92E286E45F8D293DF0EF2126DBCD90E95FD853434D94FA37E55705D2DC7517CF768ACAD7B54029A666926E2E489541EBBE618334600B8166EE8898FD01D094
+ 9C0C2889E379F46AD66B27BE027EA4C37355442DEF1D39B79EADBBBEB437D3729D847F3F66D8F829410BD48A334F7468F772FF8B4C21835EE5999DDF0BB15760
blatta/lib/channel.py

(5 . 58)(5 . 11)
        self.server = server
        self.name = name
        self.members = set()
        self._topic = ""
        self._key = None
        if self.server.statedir:
            self._state_path = "%s/%s" % (
                self.server.statedir,
                name.replace("_", "__").replace("/", "_"))
            self._read_state()
        else:
            self._state_path = None

    def add_member(self, client):
        self.members.add(client)

    def get_topic(self):
        return self._topic

    def set_topic(self, value):
        self._topic = value
        self._write_state()

    topic = property(get_topic, set_topic)

    def get_key(self):
        return self._key

    def set_key(self, value):
        self._key = value
        self._write_state()

    key = property(get_key, set_key)

    def remove_client(self, client):
        self.members.discard(client)
        if not self.members:
            self.server.remove_channel(self)

    def _read_state(self):
        if not (self._state_path and os.path.exists(self._state_path)):
            return
        data = {}
        exec(open(self._state_path), {}, data)
        self._topic = data.get("topic", "")
        self._key = data.get("key")

    def _write_state(self):
        if not self._state_path:
            return
        (fd, path) = tempfile.mkstemp(dir=os.path.dirname(self._state_path))
        fp = os.fdopen(fd, "w")
        fp.write("topic = %r\n" % self.topic)
        fp.write("key = %r\n" % self.key)
        fp.close()
        os.rename(path, self._state_path)

- 259E95AF9FD927FA7A5733E3485ED3F1D4C11CE76DA8D093320878914F48149E06A3D9800F39BD978BCC910D8586B8FA0671AA38EDCBBF432FC5ED14259624FE
+ CE97A842DF4D7C328976CA4DCD0E99E9FF0C5E56FBA68ECB094055089B81A35C303B492FBAB33116FD5BE2213D75976259F7A947E7E4E538BA273C7D42698125
blatta/lib/client.py

(1 . 19)(1 . 17)
import socket
import time
import sys
import re
import string
import os
import base64
import traceback
import logging
from state import State
from state import KNOBS
from message import Message
from server import VERSION
import datetime
from message import Message, PEST_VERSION
from broadcast import Broadcast
from direct import Direct
from station import VERSION
from funcs import *
from commands import BROADCAST
from commands import DIRECT 
from commands import BROADCAST, DIRECT

class Client(object):
    __linesep_regexp = re.compile(r"\r?\n")
(25 . 7)(23 . 7)

    def __init__(self, server, socket):
        self.server = server
        self.state = State.get_instance()
        self.state = None 
        self.socket = socket
        self.channels = {}  # irc_lower(Channel name) --> Channel
        self.nickname = None
(44 . 7)(42 . 12)
    def message_from_station(self, msg):
        targetname = self.server.channel_name if msg.command == BROADCAST else self.nickname
        pest_prefix = msg.prefix if msg.prefix else msg.speaker
        formatted_message = ":%s PRIVMSG %s :%s" % (pest_prefix, targetname, msg.body)
        formatted_message = ":%s PRIVMSG %s :%s%s" % (
            pest_prefix,
            targetname,
            msg.warning if msg.warning else "",
            msg.body
        )
        self.__writebuffer += formatted_message + "\r\n"

    def get_prefix(self):
(76 . 20)(79 . 24)
            if not line:
                # Empty line. Ignore.
                continue
            x = line.split(" ", 1)
            command = x[0].upper()
            if len(x) == 1:
                arguments = []
            else:
                if len(x[1]) > 0 and x[1][0] == ":":
                    arguments = [x[1][1:]]
                else:
                    y = string.split(x[1], " :", 1)
                    arguments = string.split(y[0])
                    if len(y) == 2:
                        arguments.append(y[1])
            command, arguments = self.__parse_command_arguments(line)
            self.__handle_command(command, arguments)

    def __parse_command_arguments(self, line):
        x = line.split(" ", 1)
        command = x[0].upper()
        if len(x) == 1:
            arguments = []
        else:
            if len(x[1]) > 0 and x[1][0] == ":":
                arguments = [x[1][1:]]
            else:
                y = string.split(x[1], " :", 1)
                arguments = string.split(y[0])
                if len(y) == 2:
                    arguments.append(y[1])
        return command, arguments

    def __pass_handler(self, command, arguments):
        server = self.server
        if command == "PASS":
(117 . 6)(124 . 7)
                self.reply("432 * %s :Erroneous nickname" % nick)
            else:
                self.nickname = nick
                self.state.set_knob("nick", nick)
                server.client_changed_nickname(self, None)
        elif command == "USER":
            if len(arguments) < 4:
(128 . 11)(136 . 11)
            self.disconnect("Client quit")
            return
        if self.nickname and self.user:
            self.reply("001 %s :Hi, welcome to Pest" % self.nickname)
            self.reply("002 %s :Your host is %s, running version blatta-%s"
                       % (self.nickname, server.name, VERSION))
            self.reply("003 %s :This server was created sometime"
                       % self.nickname)
            self.reply("001 %s :Hi, welcome to PestNet" % self.nickname)
            self.reply("002 %s :Your host is %s, running Blatta %d and Pest 0x%X"
                       % (self.nickname, server.name, VERSION, PEST_VERSION))
            self.reply("003 %s :This server was created %s"
                       % (self.nickname, datetime.datetime.now()))
            self.reply("004 %s :%s blatta-%s o o"
                       % (self.nickname, server.name, VERSION))
            self.send_motd()
(171 . 12)(179 . 6)
                channel.add_member(self)
                self.channels[irc_lower(channelname)] = channel
                self.message_channel(channel, "JOIN", channelname, True)
                if channel.topic:
                    self.reply("332 %s %s :%s"
                               % (self.nickname, channel.name, channel.topic))
                else:
                    self.reply("331 %s %s :No topic is set"
                               % (self.nickname, channel.name))
                self.reply("353 %s = %s :%s"
                           % (self.nickname,
                              channelname,
(185 . 73)(187 . 13)
                self.reply("366 %s %s :End of NAMES list" % (self.nickname, channelname))

        def list_handler():
            if len(arguments) < 1:
                channels = server.channels.values()
            else:
                channels = []
                for channelname in arguments[0].split(","):
                    if server.has_channel(channelname):
                        channels.append(server.get_channel(channelname))
            channels.sort(key=lambda x: x.name)
            for channel in channels:
                self.reply("322 %s %s %d :%s"
                           % (self.nickname, channel.name,
                              len(channel.members), channel.topic))
            self.reply("323 %s :End of LIST" % self.nickname)
            pass

        def lusers_handler():
	    pass
            pass

        def mode_handler():
            if len(arguments) < 1:
                self.reply_461("MODE")
                return
            targetname = arguments[0]
            if server.has_channel(targetname):
                channel = server.get_channel(targetname)
                if len(arguments) < 2:
                    if channel.key:
                        modes = "+k"
                        if irc_lower(channel.name) in self.channels:
                            modes += " %s" % channel.key
                    else:
                        modes = "+"
                    self.reply("324 %s %s %s"
                               % (self.nickname, targetname, modes))
                    return
                flag = arguments[1]
                if flag == "+k":
                    if len(arguments) < 3:
                        self.reply_461("MODE")
                        return
                    key = arguments[2]
                    if irc_lower(channel.name) in self.channels:
                        channel.key = key
                        self.message_channel(
                            channel, "MODE", "%s +k %s" % (channel.name, key),
                            True)
                    else:
                        self.reply("442 %s :You're not on that channel"
                                   % targetname)
                elif flag == "-k":
                    if irc_lower(channel.name) in self.channels:
                        channel.key = None
                        self.message_channel(
                            channel, "MODE", "%s -k" % channel.name,
                            True)
                    else:
                        self.reply("442 %s :You're not on that channel"
                                   % targetname)
                else:
                    self.reply("472 %s %s :Unknown MODE flag"
                               % (self.nickname, flag))
            elif targetname == self.nickname:
                if len(arguments) == 1:
                    self.reply("221 %s +" % self.nickname)
                else:
                    self.reply("501 %s :Unknown MODE flag" % self.nickname)
            else:
                self.reply_403(targetname)
            pass

        def motd_handler():
            self.send_motd()
(278 . 6)(220 . 7)
                    ":%s!%s@%s NICK %s"
                    % (oldnickname, self.user, self.host, self.nickname),
                    True)
                self.state.set_knob('nick', self.nickname)

        def notice_and_privmsg_handler():
            if len(arguments) == 0:
(290 . 27)(233 . 31)
            targetname = arguments[0]
            message = arguments[1]

            # check for pest commands before handling this as a message
            if message[0] is "%":
                pest_command, pest_arguments = self.__parse_command_arguments(message[1:])
                self.__handle_command(pest_command, pest_arguments)
                return

            if server.has_channel(targetname):
                channel = server.get_channel(targetname)
                self.message_channel(
                    channel, command, "%s :%s" % (channel.name, message))
                # send the channel message to peers as well
                self.server.station.infosec.message(
                    Message(
                        {
                            "speaker": self.nickname,
                            "command": BROADCAST,
                            "bounces": 0,
                            "body": message 
                        }))
                Broadcast(
                    {
                        "speaker": self.nickname,
                        "body": message,
                        "long_buffer": self.server.station.long_buffer
                    },
                    self.state).send()
            else:
                self.server.station.infosec.message(Message({
                Direct({
                        "speaker": self.nickname,
                        "handle": targetname,
                        "body": message,
                        "bounces": 0,
                        "command": DIRECT
                }))
                        "long_buffer": self.server.station.long_buffer
                }, self.state).send()

        def part_handler():
            if len(arguments) < 1:
(351 . 71)(298 . 16)
            self.disconnect(quitmsg)

        def topic_handler():
            if len(arguments) < 1:
                self.reply_461("TOPIC")
                return
            channelname = arguments[0]
            channel = self.channels.get(irc_lower(channelname))
            if channel:
                if len(arguments) > 1:
                    newtopic = arguments[1]
                    channel.topic = newtopic
                    self.message_channel(
                        channel, "TOPIC", "%s :%s" % (channelname, newtopic),
                        True)
                else:
                    if channel.topic:
                        self.reply("332 %s %s :%s"
                                   % (self.nickname, channel.name,
                                      channel.topic))
                    else:
                        self.reply("331 %s %s :No topic is set"
                                   % (self.nickname, channel.name))
            else:
                self.reply("442 %s :You're not on that channel" % channelname)
            pass

        def wallops_handler():
            if len(arguments) < 1:
                self.reply_461(command)
            message = arguments[0]
            for client in server.clients.values():
                client.message(":%s NOTICE %s :Global notice: %s"
                               % (self.prefix, client.nickname, message))
            pass

        def who_handler():
            if len(arguments) < 1:
                return
            targetname = arguments[0]
            if server.has_channel(targetname):
                channel = server.get_channel(targetname)
                for member in channel.members:
                    self.reply("352 %s %s %s %s %s %s H :0 %s"
                               % (self.nickname, targetname, member.user,
                                  member.host, server.name, member.nickname,
                                  member.realname))
                self.reply("315 %s %s :End of WHO list"
                           % (self.nickname, targetname))
            pass

        def whois_handler():
            if len(arguments) < 1:
                return
            username = arguments[0]
            user = server.get_client(username)
            if user:
                self.reply("311 %s %s %s %s * :%s"
                           % (self.nickname, user.nickname, user.user,
                              user.host, user.realname))
                self.reply("312 %s %s %s :%s"
                           % (self.nickname, user.nickname, server.name,
                              server.name))
                self.reply("319 %s %s :%s"
                           % (self.nickname, user.nickname,
                              " ".join(user.channels)))
                self.reply("318 %s %s :End of WHOIS list"
                           % (self.nickname, user.nickname))
            else:
                self.reply("401 %s %s :No such nick"
                           % (self.nickname, username))
            pass

        def wot_handler():
            if len(arguments) < 1:
(427 . 7)(319 . 8)
                            address = "%s:%s" % (peer.address, peer.port)
                        else:
                            address = "<address not configured>"
                        self.pest_reply("%s %s" % (string.join(peer.handles, ","), address))
                        self.pest_reply("%s %s" % (string.join(peer.handles, ","),
                            address))
                else:
                    self.pest_reply("WOT is empty")
            elif len(arguments) == 1:
(540 . 7)(433 . 7)
                    self.pest_reply("no knobs configured")
            elif len(arguments) == 1:
                knob_value = self.state.get_knob(arguments[0])
                if knob:
                if knob_value:
                    self.pest_reply("%s %s" % (arguments[0], knob_value))
                else:
                    self.pest_reply("no such knob")
(549 . 6)(442 . 18)
                self.pest_reply("set %s to %s" % (arguments[0], arguments[1]))
            else:
                self.pest_reply("Usage: KNOB [<NAME>] [<VALUE>]")
        
        def resolve_handler():
            if len(arguments) == 1:
                handle = arguments[0]
                peer = self.state.get_peer_by_handle(handle)
                if peer:
                    self.state.resolve(handle)
                    self.pest_reply("resolved %s" % handle)
                else:
                    self.pest_reply("peer with handle %s not found" % handle)
            else:
                self.pest_reply("Usage: RESOLVE <HANDLE>")

        handler_table = {
            "AWAY": away_handler,
(557 . 6)(462 . 7)
            "ISON": ison_handler,
            "JOIN": join_handler,
            "KEY": key_handler,
            "KNOB":  knob_handler,
            "LIST": list_handler,
            "LUSERS": lusers_handler,
            "MODE": mode_handler,
(569 . 6)(475 . 7)
            "PONG": pong_handler,
            "PRIVMSG": notice_and_privmsg_handler,
            "QUIT": quit_handler,
            "RESOLVE": resolve_handler,
            "TOPIC": topic_handler,
            "UNKEY": unkey_handler,
            "UNPEER": unpeer_handler,
(576 . 7)(483 . 6)
            "WHO": who_handler,
            "WHOIS": whois_handler,
            "WOT":  wot_handler,
            "KNOB":  knob_handler
        }
        server = self.server
        valid_channel_re = self.__valid_channelname_regexp
(590 . 8)(496 . 9)
    def socket_readable_notification(self):
        try:
            data = self.socket.recv(2 ** 10)
            logging.debug(
                "[%s:%d] -> %r" % (self.host, self.port, data))
            if os.environ.get("LOG_CLIENT_MESSAGES"):
                logging.debug(
                    "[%s:%d] -> %r" % (self.host, self.port, data))
            quitmsg = "EOT"
        except socket.error as x:
            data = ""
(607 . 9)(514 . 10)
    def socket_writable_notification(self):
        try:
            sent = self.socket.send(self.__writebuffer)
            logging.debug(
                "[%s:%d] <- %r" % (
                    self.host, self.port, self.__writebuffer[:sent]))
            if os.environ.get("LOG_CLIENT_MESSAGES"):
                logging.debug(
                    "[%s:%d] <- %r" % (
                        self.host, self.port, self.__writebuffer[:sent]))
            self.__writebuffer = self.__writebuffer[sent:]
        except socket.error as x:
            self.disconnect(x)
(629 . 7)(537 . 7)
        self.message(":%s %s" % (self.server.name, msg))

    def pest_reply(self, msg):
        self.message("NOTICE %s :%s" % (self.nickname, msg))
        self.message(":Pest NOTICE %s :%s" % (self.nickname, msg))

    def reply_403(self, channel):
        self.reply("403 %s %s :No such channel" % (self.nickname, channel))

- E4FA49D77AE8627D1B7E68B131DD1E66D03C2FD30904691B1D0179BDF99D2972D8F0A635D4140B6D1E18A4ECBE5C22EDDAB3505B4CAF29673136A372BA4EDD0B
+ B3884AE3A2F5C1AB5A94171F98BED58421C997DE79EDA026218341BB26D41CA45CAFB938303F8425A57F3FA6A177BA34B0ADE6DFCBF466B443B82E14B4C0C421
blatta/lib/commands.py

(7 . 4)(7 . 11)

BROADCAST   = 0x00
DIRECT      = 0x01
GETDATA     = 0x03
IGNORE      = 0xFF
COMMAND_LABELS = {
    BROADCAST: "BROADCAST",
    DIRECT: "DIRECT",
    GETDATA: "GETDATA",
    IGNORE: "IGNORE"
}

-
+ B2BFEE16A02F0AD104FBE59958BE80D27FC59C50695D25B4C008C28ABA4438C00706C3181C473C7A74BD85F21A681059B694B3B792F7C234D3478B346307EB7C
blatta/lib/direct.py

(0 . 0)(1 . 58)
import logging
import hashlib
import time
import binascii
from message import Message
from message import DIRECT


class Direct(Message):
    def __init__(self, message, state):
        message['command'] = DIRECT
        message['bounces'] = 0
        super(Direct, self).__init__(message, state)

    def send(self):
        if not self.speaker:
            logging.error("aborting message send due speaker not being set")
            return

        self.timestamp = int(time.time())
        target_peer = self.state.get_peer_by_handle(self.handle)
        if target_peer and not target_peer.get_key():
            logging.debug("No key for peer associated with %s" % self.handle)
            return

        if target_peer == None:
            logging.debug("Aborting message: unknown handle: %s" % self.handle)
            return

        self.message_bytes = self.get_message_bytes(target_peer)
        self.message_hash = hashlib.sha256(self.message_bytes).digest()

        logging.debug("generated message_hash: %s" % binascii.hexlify(self.message_hash))

        self.peer = target_peer
        self.long_buffer.intern(self)

        signed_packet_bytes = self.pack(target_peer, self.command, self.bounces, self.message_bytes)
        self.state.update_handle_self_chain(target_peer.handles[0], self.message_hash)
        target_peer.send(signed_packet_bytes)
        self.log_outgoing(target_peer)

    def retry(self, requesting_peer):
        target_peer = self.state.get_peer_by_handle(self.handle)

        if target_peer == None:
            logging.debug("Aborting message: unknown handle: %s" % self.handle)
            return

        if not target_peer.get_key():
            logging.debug("No key for peer associated with %s" % self.handle)
            return

        # TODO: Figure out how to verify that the requester was the original intended recipient
        signed_packet_bytes = self.pack(target_peer, self.command, self.bounces, self.message_bytes)
        target_peer.send(signed_packet_bytes)
        self.log_outgoing(target_peer)

-
+ 6BB6808C15C7BFB7C89860C4565FD28E2ABDA8AB75D1C6928E4EBEBF37CEC6F104A73C595FB4DFD34515E47D77D8EEDCAF5DEC8E7CBB353858281C17C2229CBF
blatta/lib/getdata.py

(0 . 0)(1 . 66)
import time
import binascii
import hashlib
import logging
from message import Message
from message import OUTGOING_MESSAGE_LOGGING_FORMAT
from commands import GETDATA 
from commands import DIRECT 
from commands import BROADCAST
from commands import COMMAND_LABELS

class GetData(Message):
    def __init__(self, original, broken_chain, state=None):
        message = {
            'command': GETDATA,
            'body': original[broken_chain],
            'timestamp': int(time.time()),
            'speaker': state.get_knob('nick'),
            'bounces': 0,
            'original': original
        }
        super(GetData, self).__init__(message, state)

    def send(self):
        target_peer = (self.state.get_peer_by_handle(self.original['speaker'])
                        if self.original['command'] == DIRECT
                        else None)

        if self.original['command'] == DIRECT and target_peer == None:
            logging.debug("Aborting message: unknown handle: %s" % self.handle)
            return

        if target_peer and not target_peer.get_key():
            logging.debug("No key for peer associated with %s" % self.handle)
            return

        if self.state.get_knob('nick') is None:
            logging.error("unable to pack message due to null speaker value")
            return

        self.message_bytes = self.get_message_bytes(target_peer)
        self.message_hash = hashlib.sha256(self.message_bytes).digest()


        if self.original['command'] == DIRECT:
            signed_packet_bytes = self.pack(target_peer,
                                            self.command,
                                            self.bounces,
                                            self.message_bytes)
            target_peer.send(signed_packet_bytes)
            self.log_outgoing(target_peer)

        elif self.original['command'] == BROADCAST:
            for peer in self.state.get_keyed_peers(exclude_addressless=True):
                signed_packet_bytes = self.pack(peer, self.command, self.bounces, self.message_bytes)
                peer.send(signed_packet_bytes)
                self.log_outgoing(peer)

    def log_outgoing(self, peer):
        logging.info(OUTGOING_MESSAGE_LOGGING_FORMAT % (peer.address,
            peer.port,
            peer.handles[0],
            COMMAND_LABELS[self.command],
            binascii.hexlify(self.body),
            self.bounces,
            binascii.hexlify(self.message_hash)))

-
+ 3279A34976D252B3CBEC3C118A63F7606A6C7B25B02591F511ED4AAA0856CB7943AB611596F31CB4978215AA1998981F26245898677E6839861C7E4F35A12414
blatta/lib/ignore.py

(0 . 0)(1 . 30)
import logging
import time
import hashlib
import os
from message import Message
from message import IGNORE


class Ignore(Message):
    def __init__(self, message, state):
        message['command'] = IGNORE
        message['bounces'] = 0
        message['body'] = self.gen_rubbish_body()
        super(Ignore, self).__init__(message, state)

    def send(self):
        if not self.speaker:
            logging.error("aborting message send due speaker not being set")
            return

        # if we are not rebroadcasting we need to set the timestamp
        self.timestamp = int(time.time())
        self.message_bytes = self.get_message_bytes()
        self.message_hash = hashlib.sha256(self.message_bytes).digest()

        for peer in self.state.get_keyed_peers(exclude_addressless=True):
            signed_packet_bytes = self.pack(peer, self.command, self.bounces, self.message_bytes)
            peer.send(signed_packet_bytes)
            if os.environ.get('LOG_RUBBISH'):
                self.log_rubbish(peer)

- 2A3C3DF167D4BA0F838A3E9DDDDCCBE6D924C3608F742C68E56E107F1F2FC68E4569CD141C992A87565B958815DDE0DB6998179B1398562D6D4CF5963D1C980C
+
blatta/lib/infosec.py

(1 . 276)(0 . 0)
import hashlib
import serpent
from serpent import Serpent
from serpent import serpent_cbc_encrypt 
from serpent import serpent_cbc_decrypt 
from commands import BROADCAST
from commands import DIRECT 
from commands import IGNORE 
from message import Message
import base64
import binascii
import time
import struct
import sys
import hmac
import random
import os 
import pprint
import logging
pp = pprint.PrettyPrinter(indent=4)

PACKET_SIZE = 496 
MAX_SPEAKER_SIZE = 32
TS_ACCEPTABLE_SKEW = 60 * 15
BLACK_PACKET_FORMAT = "<448s48s"
RED_PACKET_FORMAT = "<16sBBxB428s"
RED_PACKET_LENGTH_WITH_PADDING = 448
MESSAGE_PACKET_FORMAT = "<q32s32s32s324s"
MAX_MESSAGE_LENGTH = 428
STALE_PACKET = 0
DUPLICATE_PACKET = 1
MALFORMED_PACKET = 2
INVALID_SIGNATURE = 3
IGNORED = 4
MESSAGE_LOGGING_FORMAT = "[%s:%d %s] <- %s %s %s"

class Infosec(object): 
    def __init__(self, state=None):
        self.state = state

    def message(self, message):
        if not message.speaker:
            logging.error("aborting message send due speaker not being set")
            return

        # if we are not rebroadcasting we need to set the timestamp
        if message.timestamp == None:
            message.original = True
            message.timestamp = int(time.time())
        else:
            message.original = False

        target_peer = (self.state.get_peer_by_handle(message.handle)
                        if message.command == DIRECT
                        else None)

        if target_peer and not target_peer.get_key():
            logging.debug("No key for peer associated with %s" % message.handle)
            return

        if message.command == DIRECT and target_peer == None:
            logging.debug("Aborting message: unknown handle: %s" % message.handle)
            return

        if message.message_bytes == None:
            message_bytes = self.get_message_bytes(message, target_peer)
        else:
            message_bytes = message.message_bytes 

        message_hash = binascii.hexlify(hashlib.sha256(message_bytes).digest())

        if message.command != IGNORE:
            logging.debug("generated message_hash: %s" % message_hash)
            self.state.add_to_dedup_queue(message_hash)
            self.state.log(message.speaker, message_bytes, target_peer)

        if message.command == DIRECT:
            signed_packet_bytes = self.pack(target_peer, message, message_bytes)
            target_peer.send(signed_packet_bytes)
            logging.info(MESSAGE_LOGGING_FORMAT % (target_peer.address,
                target_peer.port,
                target_peer.handles[0],
                message.body,
                message.bounces,
                message_hash))

        elif message.command == BROADCAST or message.command == IGNORE:
            # sanity check
            if message.message_bytes and message_bytes != message_bytes:
                logging.error("aborting send: message modified by station!")
                return

            for peer in self.state.get_keyed_peers(exclude_addressless=True):
                
                # we don't want to send a broadcast back to the originator
                if message.peer and (peer.peer_id == message.peer.peer_id):
                    continue 

                signed_packet_bytes = self.pack(peer, message, message_bytes)
                peer.send(signed_packet_bytes)
                if message.command != IGNORE:
                    logging.info(MESSAGE_LOGGING_FORMAT % (peer.address,
                        peer.port,
                        peer.handles[0],
                        message.body,
                        message.bounces,
                        message_hash))

    def get_message_bytes(self, message, peer=None):
        timestamp = message.timestamp
        command = message.command
        speaker = self._pad(message.speaker, MAX_SPEAKER_SIZE)

        # let's generate the self_chain value from the last message or set it to zero if 
        # there this is the first message
        
        if message.original:
            if command == DIRECT:
                self_chain = self.state.get_last_message_hash(message.speaker, peer.peer_id)
            elif command == BROADCAST:
                self_chain = self.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

        # pack message bytes

        if message.command != IGNORE:
            logging.debug("packing message bytes: %s" % message.body)
        else:
            logging.debug("packing rubbish message bytes: %s" % binascii.hexlify(message.body)[0:8])

        message_bytes = struct.pack(MESSAGE_PACKET_FORMAT, message.timestamp, self_chain, net_chain, speaker, message.body)
        return message_bytes

    def pack(self, peer, message, message_bytes):
        key_bytes = base64.b64decode(peer.get_key())
        signing_key = key_bytes[:32]
        cipher_key = key_bytes[32:]

        # pack packet bytes

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

        # encrypt packet

        serpent = Serpent(cipher_key)
        black_packet_bytes = serpent_cbc_encrypt(cipher_key, red_packet_bytes)

        # sign packet

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

        # pack the signed black packet

        signed_packet_bytes = struct.pack(BLACK_PACKET_FORMAT, black_packet_bytes, signature_bytes)

        return signed_packet_bytes
    
    def unpack(self, peer, black_packet):
        # unpack the black packet

        key_bytes = base64.b64decode(peer.get_key())
        signing_key = key_bytes[:32]
        cipher_key = key_bytes[32:]

        try:
            black_packet_bytes, signature_bytes = struct.unpack(BLACK_PACKET_FORMAT, black_packet)
        except:
            logging.error("Discarding malformed black packet from %s" % peer.get_key())
            return Message({ "error_code": MALFORMED_PACKET })

        # check signature

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

        if(signature_check_bytes != signature_bytes):
            return Message({ "error_code": INVALID_SIGNATURE })

        # try to decrypt black packet
        
        serpent = Serpent(cipher_key)
        red_packet_bytes = serpent_cbc_decrypt(cipher_key, black_packet_bytes)

        # unpack red packet

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

        # compute message_hash

        message_hash = binascii.hexlify(hashlib.sha256(message_bytes).digest())

        # unpack message

        int_ts, self_chain, net_chain, speaker, body = struct.unpack(MESSAGE_PACKET_FORMAT, message_bytes)
        
        # remove padding from speaker

        for index, byte in enumerate(speaker):
            if byte == '\x00':
                speaker = speaker[0:index]
                break 

        # remove padding from body

        for index, byte in enumerate(body):
            if byte == '\x00':
                body = body[0:index]
                break 

        # nothing to be done for an IGNORE command

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

        # check timestamp

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

        # check self_chain

        if command == DIRECT:
            self_chain_check = self.state.get_last_message_hash(speaker, peer.peer_id)
        elif command == BROADCAST:
            self_chain_check = self.state.get_last_message_hash(speaker)

        self_chain_valid = (self_chain_check == self_chain)

        # log this message for use in the self_chain check

        self.state.log(speaker, message_bytes, peer if (command == DIRECT) else None)

        # build message object

        message = Message({ 
                        "peer": peer,
                        "body": body.rstrip(),
                        "timestamp": int_ts,
                        "command": command,
                        "speaker": speaker,
                        "bounces": bounces,
                        "self_chain": self_chain,
                        "net_chain": net_chain,
                        "self_chain_valid": self_chain_valid,
                        "message_hash": message_hash,
                        "message_bytes": message_bytes
                        })

        # check for duplicates

        if(self.state.is_duplicate_message(message_hash)):
            message.error_code = DUPLICATE_PACKET
            return message

        return message

    def _pad(self, text, size):
        return text.ljust(size, "\x00")

    def _ts_range(self):
        current_ts = int(time.time())
        return range(current_ts - TS_ACCEPTABLE_SKEW, current_ts + TS_ACCEPTABLE_SKEW)

    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)

-
+ 9F5B2F1661FAB5FCC0A29D99094099C7A40ACAA3736475E277177ED97036DB710CCC0C4A608BE22759A2F0493CB28BB62574B055A83C71205998A2E0EB8721DD
blatta/lib/long_buffer.py

(0 . 0)(1 . 49)
import time

from lib.broadcast import Broadcast
from lib.commands import BROADCAST, DIRECT
from lib.direct import Direct
from lib.message import EMPTY_CHAIN


class LongBuffer(object):
    def __init__(self, state):
        self.state = state
        self.buffer = {}

    def exhume(self, message_hash):
        message = self.buffer.get(message_hash)
        if message:
            return message

        command, message_bytes = self.state.get_message(message_hash)
        if message_bytes:
           if command == DIRECT:
                return Direct({message_bytes: message_bytes}, self.state)
           elif command == BROADCAST:
               return Broadcast({'message_bytes': message_bytes}, self.state)

    def expunge_expired(self):
        for message in self.buffer.values():
            if message.timestamp < time.time() - 3600:
                del self.buffer[message.message_hash]

    def intern(self, message):
        # somehow we are trying to intern a message we've already got
        if self.has(message.message_hash):
            return

        self.expunge_expired()
        self.buffer[message.message_hash] = message
        self.state.log_message(message)

    def has(self, message_hash):
        if EMPTY_CHAIN == message_hash:
            return True

        if self.buffer.get(message_hash) is None:
            if self.state.log_has_message(message_hash):
                return True
            return False
        else:
            return True

- 9EFA52C31BB08E8F81821B1832F5729D9E3F52CD44CBD9C10ADCC809FD4383129ACE4D7C3615EB1E9B068E13E045DEE2898AAAC1F1EAACA81AD65B5ECE9FF751
+ EB3F3EC3FA23E3F350B870585FDBE7CCB548B4B4A266699F943CD97148D4130495D98399F73FA7E8466C61655EA5BCFEE005D1EF07C8FAE66EE91640B9BF0444
blatta/lib/message.py

(1 . 7)(1 . 59)
import hashlib

from serpent import Serpent
from serpent import serpent_cbc_encrypt 
from serpent import serpent_cbc_decrypt 
from commands import BROADCAST
from commands import DIRECT 
from commands import GETDATA 
from commands import IGNORE
from commands import COMMAND_LABELS
import base64
import binascii
import time
import struct
import hmac
import random
import os 
import logging

PEST_VERSION = 0xFC
PACKET_SIZE = 496 
MAX_SPEAKER_SIZE = 32
TS_ACCEPTABLE_SKEW = 60 * 15
BLACK_PACKET_FORMAT = "<448s48s"
RED_PACKET_FORMAT = "<16sBBxB428s"
RED_PACKET_LENGTH_WITH_PADDING = 448
MESSAGE_PACKET_FORMAT = "<q32s32s32s324s"
GETDATA_MESSAGE_PACKET_FORMAT = "<q32s32s32s32s292s"
MAX_MESSAGE_LENGTH = 428
TEXT_PAYLOAD_SIZE = 324

# error codes
STALE_PACKET = 0
DUPLICATE_PACKET = 1
MALFORMED_PACKET = 2
INVALID_SIGNATURE = 3
UNSUPPORTED_VERSION = 4
OUT_OF_ORDER_SELF = 5
OUT_OF_ORDER_NET = 6
OUT_OF_ORDER_BOTH = 7

# logging formats
OUTGOING_MESSAGE_LOGGING_FORMAT = "[%s:%d %s] <- %s %s %s %s"
INCOMING_MESSAGE_LOGGING_FORMAT = "[%s:%d %s] -> %s %s %d %s"

# fork status values
FORKED = 0
NOT_FORKED = 1
FIRST_MESSAGE = 2
EMPTY_CHAIN = "\x00" * 32 

class Message(object):
    def __init__(self, message):
        self.original = True
    def __init__(self, message, state=None):
        self.state = state
        self.prefix = None
        self.fork_status = None
        self.handle = message.get("handle")
        self.peer = message.get("peer")
        self.body = message.get("body")
(14 . 4)(66 . 325)
        self.self_chain_valid = message.get("self_chain_valid")
        self.error_code = message.get("error_code")
        self.message_hash = message.get("message_hash")
        self.message_bytes = None
        self.message_bytes = message.get("message_bytes")
        self.long_buffer = message.get("long_buffer")
        self.get_data_response = message.get("get_data_response")
        self.metadata = message.get('metadata')
        self.original = message.get('original')
        self.reporting_peers = message.get('reporting_peers', [])
        self.warning = message.get('warning')
        self.order_buffer = message.get('order_buffer')
        self.error_code = message.get('error_code')

    @classmethod
    def pack(cls, peer, command, bounces, message_bytes):
        key_bytes = base64.b64decode(peer.get_key())
        signing_key = key_bytes[:32]
        cipher_key = key_bytes[32:]

        # pack packet bytes
        nonce = cls._generate_nonce(16)
        version = PEST_VERSION
        red_packet_bytes = struct.pack(RED_PACKET_FORMAT,
                                       nonce,
                                       bounces,
                                       version,
                                       command,
                                       cls._pad(message_bytes, MAX_MESSAGE_LENGTH))

        # encrypt packet
        serpent = Serpent(cipher_key)
        black_packet_bytes = serpent_cbc_encrypt(cipher_key, red_packet_bytes)

        # sign packet
        signature_bytes = hmac.new(signing_key, black_packet_bytes, hashlib.sha384).digest()

        # pack the signed black packet
        signed_packet_bytes = struct.pack(BLACK_PACKET_FORMAT, black_packet_bytes, signature_bytes)

        return signed_packet_bytes

    @classmethod
    def unpack(cls, peer, black_packet, long_buffer, order_buffer, metadata, state=None):
        # unpack the black packet
        for key in peer.keys:
            key_bytes = base64.b64decode(key)
            signing_key = key_bytes[:32]
            cipher_key = key_bytes[32:]

            try:
                black_packet_bytes, signature_bytes = struct.unpack(BLACK_PACKET_FORMAT,
                                                                    black_packet)
            except:
                logging.error("Discarding malformed black packet from %s" % peer.get_key())
                return {
                    "error_code": MALFORMED_PACKET,
                    "metadata": metadata
                }

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

            if(signature_check_bytes != signature_bytes):
                continue

            # try to decrypt black packet
            Serpent(cipher_key)
            red_packet_bytes = serpent_cbc_decrypt(cipher_key, black_packet_bytes)

        # unpack red packet
        try:
            nonce, bounces, version, command, message_bytes = struct.unpack(
                RED_PACKET_FORMAT,
                red_packet_bytes
            )

        # if red_packet_bytes was never set, no matching key for the sig was found
        # this is expected to happen often as only one peer's key should match for each
        # message we receive
        except NameError, ex:
            return {
                "error_code": INVALID_SIGNATURE,
                "metadata": metadata
            }

        if version < PEST_VERSION:
            return { "error_code": UNSUPPORTED_VERSION }

        # compute message_hash
        message_hash = cls.gen_hash(message_bytes)
        message = cls._build_message_dict(command,
                                          peer,
                                          bounces,
                                          message_hash,
                                          message_bytes,
                                          metadata)

        return cls._evaluate_message(long_buffer, order_buffer, message)


    @classmethod
    def _evaluate_message(cls, long_buffer, order_buffer, message):
        # if we're expecting this message as a GETDATA response, skip the timestamp check
        if not order_buffer.expects(message['message_hash']):
            if not cls.in_time_window(message['timestamp']):
                message['error_code'] = STALE_PACKET
                return message
        else:
            # we need to mark this as a get data response in order not to rebroadcast it
            # TODO how to handle out of order unrequested but not stale messages subsequent to a message in the order buffer?
            message['get_data_response'] = True

        if long_buffer.has(message['message_hash']):
            message['error_code'] = DUPLICATE_PACKET
            return message

        if DIRECT is message['command']:
           return cls._evaluate_direct(long_buffer, order_buffer, message)
        elif BROADCAST is message['command']:
            return cls._evaluate_broadcast(long_buffer, order_buffer, message)
        else:
            return message

    @classmethod
    def _build_message_dict(cls, command, peer, bounces, message_hash, message_bytes, metadata):
        # unpack message
        if GETDATA == command:
            int_ts, self_chain, net_chain, speaker, body = cls._unpack_getdata_message(message_bytes)
        else:
            int_ts, self_chain, net_chain, speaker, body = cls._unpack_message(message_bytes)

        message = {
            "peer": peer,
            "body": body,
            "timestamp": int_ts,
            "command": command,
            "speaker": speaker,
            "bounces": bounces,
            "self_chain": self_chain,
            "net_chain": net_chain,
            "message_hash": message_hash,
            "message_bytes": message_bytes,
            "metadata": metadata
        }
        return message

    @classmethod
    def _evaluate_broadcast(cls, long_buffer, order_buffer, message):
        if (not long_buffer.has(message['self_chain']) and
                not long_buffer.has(message['net_chain'])):
            if message['self_chain'] != message['net_chain']:
                message['error_code'] = OUT_OF_ORDER_BOTH
                return message
            else:
                message['error_code'] = OUT_OF_ORDER_SELF
                return message
        elif not long_buffer.has(message['net_chain']):
            message['error_code'] = OUT_OF_ORDER_NET
            return message
        elif not (long_buffer.has(message['self_chain'])):
            message['error_code'] = OUT_OF_ORDER_SELF
            return message
        return message

    @classmethod
    def _evaluate_direct(cls, long_buffer, order_buffer, message):
        # if this is the first direct message from a station, we needn't check for antecedents
        if message['self_chain'] == EMPTY_CHAIN:
            return message

        # no need to check net_chain for a direct message
        if not (long_buffer.has(message['self_chain'])):
            if not order_buffer.has(message['message_hash']):
                order_buffer.add(message)
                message['error_code'] = OUT_OF_ORDER_SELF
                return message
        return message

    @classmethod
    def _unpack_message(cls, message_bytes):
        int_ts, self_chain, net_chain, speaker, body = struct.unpack(MESSAGE_PACKET_FORMAT, message_bytes)
        
        # remove padding from speaker
        for index, byte in enumerate(speaker):
            if byte == '\x00':
                speaker = speaker[0:index]
                break 

        # remove padding from body
        for index, byte in enumerate(body):
            if byte == '\x00':
                body = body[0:index]
                break 

        return int_ts, self_chain, net_chain, speaker, body

    @classmethod
    def _unpack_getdata_message(cls, message_bytes):
        int_ts, self_chain, net_chain, speaker, body, padding = struct.unpack(GETDATA_MESSAGE_PACKET_FORMAT, message_bytes)
        return int_ts, self_chain, net_chain, speaker, body

    @classmethod
    def _unpack_last_valid_message(cls, last_message_info):
        if last_message_info.get('message_bytes'):
            return cls._unpack_message(
                last_message_info['message_bytes']
            )[4]
        else:
            return "<no prior message received>"

    @classmethod
    def _pad(cls, text, size):
        return text.ljust(size, "\x00")

    @classmethod
    def _ts_range(cls):
        current_ts = int(time.time())
        return range(current_ts - TS_ACCEPTABLE_SKEW, current_ts + TS_ACCEPTABLE_SKEW)

    @classmethod
    def _generate_nonce(cls, length=8):
        """Generate pseudorandom number."""
        return ''.join([str(random.randint(0, 9)) for i in range(length)])

    @classmethod
    def gen_rubbish_body(cls):
        return os.urandom(MAX_MESSAGE_LENGTH)

    @classmethod
    def gen_hash(cls, message_bytes):
        return hashlib.sha256(message_bytes).digest()

    def set_warning(self):
        if self.timestamp < self.state.get_latest_message_timestamp():
            self.warning = time.strftime("%Y-%m-%d %H:%M:%S: ", time.localtime(self.timestamp))

    def get_message_bytes(self, peer=None):
        command = self.command
        speaker = Message._pad(self.speaker, MAX_SPEAKER_SIZE)

        # let's generate the self_chain value from the last message or set it to zero if 
        # this is the first message
        if command == DIRECT:
            self_chain = self.state.get_handle_self_chain(peer.handles[0])
            net_chain = EMPTY_CHAIN
        elif command == BROADCAST:
            self_chain = self.state.get_broadcast_self_chain()
            net_chain = self.state.get_net_chain()
        elif command == IGNORE:
            self_chain = net_chain = EMPTY_CHAIN
        elif command == GETDATA:
            self_chain = net_chain = EMPTY_CHAIN

        self.self_chain = self_chain
        self.net_chain = net_chain

        message_bytes = struct.pack(MESSAGE_PACKET_FORMAT,
            self.timestamp,
            self_chain,
            net_chain,
            speaker.encode('ascii'),
            self.body)
        return message_bytes

    def compute_message_hash(self):
        if self.message_hash is None:
            if self.message_bytes is not None:
                self.message_hash = Message.gen_hash(self.message_bytes)
                return self.message_hash
            else:
                return None
        else:
            return self.message_hash

    def log_outgoing(self, peer):
        logging.info(OUTGOING_MESSAGE_LOGGING_FORMAT % (peer.address,
            peer.port,
            peer.handles[0],
            COMMAND_LABELS[self.command],
            self.body,
            self.bounces,
            binascii.hexlify(self.compute_message_hash())))

    def log_rubbish(self, peer):
        logging.info(OUTGOING_MESSAGE_LOGGING_FORMAT % (peer.address,
                                                        peer.port,
                                                        peer.handles[0],
                                                        COMMAND_LABELS[self.command],
                                                        "<rubbish>",
                                                        self.bounces,
                                                        binascii.hexlify(self.message_hash)))

    def log_incoming(self, peer):
        try:
            logging.info(INCOMING_MESSAGE_LOGGING_FORMAT % (peer.address,
                peer.port,
                peer.handles[0],
                COMMAND_LABELS[self.command],
                self.body,
                self.bounces,
                binascii.hexlify(self.message_hash)))
        except Exception, ex:
            logging.info("unable to log incoming message")

    def log_incoming_getdata(self, peer):
        try:
            logging.info(INCOMING_MESSAGE_LOGGING_FORMAT % (peer.address,
                                                            peer.port,
                                                            peer.handles[0],
                                                            COMMAND_LABELS[self.command],
                                                            binascii.hexlify(self.body),
                                                            self.bounces,
                                                            binascii.hexlify(self.message_hash)))
        except Exception, ex:
            logging.info("unable to log incoming message")
    def retry(self, requesting_peer):
        logging.debug("Can't retry a message that isn't DIRECT or BROADCAST")

        return

    @classmethod
    def in_time_window(cls, timestamp):
        return timestamp in cls._ts_range()

-
+ 388113D46790BA9828275D8F1B20CEF6DCA63976D43192EFA8D4332B3360FA8CB93A50A026EB35A66BA129BEA7E61FC6973491072F6B5385D4EC83C11CCD2DC7
blatta/lib/order_buffer.py

(0 . 0)(1 . 57)
import time
from broadcast import Broadcast
from direct import Direct
from commands import BROADCAST
from commands import DIRECT


class OrderBuffer(object):
    def __init__(self, state):
        self.buffer = {}
        self.state = state

    def add(self, message):
        ts = time.time()
        if message['command'] == BROADCAST:
            m = Broadcast(message, self.state)
        elif message['command'] == DIRECT:
            m = Direct(message, self.state)
        else:
            return

        if self.buffer.get(ts) is None:
            self.buffer[ts] = [m]
        else:
            self.buffer[ts].append(m)

    def expects(self, message_hash):
        for value in self.buffer.values():
            for message in value:
                if message_hash == message.self_chain:
                    return True
                elif message_hash == message.net_chain:
                    return True
        return False

    def has(self, message_hash):
        for value in self.buffer.values():
            for message in value:
                if message_hash == message.message_hash:
                    return True
        return False

    def dequeue_and_order_mature_messages(self):
        current_time = time.time()
        sorted_messages = sorted(self.buffer.keys())
        mature_messages = []
        for timestamp in sorted_messages:
            if timestamp < current_time - int(self.state.get_knob('order_buffer_expiration_seconds')):
                if isinstance(self.buffer[timestamp], list):
                    if len(self.buffer[timestamp]) > 0:
                        for message in self.buffer[timestamp]:
                            mature_messages.append(message)
                    del self.buffer[timestamp]
                else:
                    mature_messages.append(self.buffer[timestamp])
                    del self.buffer[timestamp]
        return sorted(mature_messages, key=lambda m: m.timestamp)

- 01648A4C6129C725EBFAF5A84166BBC34CF2080DF4842887C872524819B87E13D524B0B8351F75F5ECC4F7A638CCE26D5DA72C4967C5785EBF1A956DB5906B38
+ B37B49C4C4371DC8D5ECD15D8B07CAC76DE8F70A51D3A590891E89CFA5C2E2C8F3A883257976C4F77040831199211FF3FC038EC159A3AD477FE2A3970CC8B7CC
blatta/lib/peer.py

(16 . 6)(16 . 7)
        self.address = peer_entry["address"]
        self.port = peer_entry["port"]
        self.socket = socket 
        self.forked = peer_entry.get("forked")

    def get_key(self):
        if len(self.keys) > 0:
(27 . 9)(28 . 6)
        if self.get_key() != None and self.address != None and self.port != None:
            try:
                self.socket.sendto(signed_packet_bytes, (self.address, self.port))   
                logging.debug("[%s:%d] <- %s" % (self.address,
                                                         int(self.port),
                                                         binascii.hexlify(signed_packet_bytes)[0:16]))

            except Exception as ex:
               stack = traceback.format_exc()

- 2003B827BA1E77B0E67A9A00BDF37ED146DDAF00BB0EC9EB72AF3AEFCED8541F948FA2B8A7770975165F96029E489A6E609E188700F5655C697E05271419D9EF
+ 225CCF41F5E87FFF8D9837F1EAF03D4806FA62F9A2A1608F4642660DFA9BC863F10860FD02879A42283CE862C9C0C0B034FD2B0158A4506FB15FA4FFD33FFFC9
blatta/lib/server.py

(1 . 37)(1 . 22)
VERSION = "9983"

import os
import select
import socket
import sys
import tempfile
import time
import string
import datetime
import sqlite3
from datetime import datetime
from funcs import *
from client import Client 
from channel import Channel
from station import Station
from message import Message
from infosec import PACKET_SIZE
import imp
from message import PACKET_SIZE
import pprint
import logging

class Server(object):
    def __init__(self, options):
    def __init__(self, options, station):
        self.station = station
        self.irc_ports = options.irc_ports
        self.udp_port = options.udp_port
        self.channel_name = options.channel_name
        self.password = options.password
        self.motdfile = options.motd
        self.logdir = options.logdir
        self.chroot = options.chroot
        self.setuid = options.setuid
        self.statedir = options.statedir
        self.config_file_path = options.config_file_path
        self.pp = pprint.PrettyPrinter(indent=4)
        self.db_path = options.db_path
        self.address_table_path = options.address_table_path
(48 . 33)(33 . 6)
        self.client = None
        self.nicknames = {}  # irc_lower(Nickname) --> Client instance.

        if self.logdir:
            create_directory(self.logdir)
        if self.statedir:
            create_directory(self.statedir)

    def daemonize(self):
        try:
            pid = os.fork()
            if pid > 0:
                sys.exit(0)
        except OSError:
            sys.exit(1)
        os.setsid()
        try:
            pid = os.fork()
            if pid > 0:
                logging.info("PID: %d" % pid)
                sys.exit(0)
        except OSError:
            sys.exit(1)
        os.chdir("/")
        os.umask(0)
        dev_null = open("/dev/null", "r+")
        os.dup2(dev_null.fileno(), sys.stdout.fileno())
        os.dup2(dev_null.fileno(), sys.stderr.fileno())
        os.dup2(dev_null.fileno(), sys.stdin.fileno())

    def get_client(self, nickname):
        return self.nicknames.get(irc_lower(nickname))

(124 . 10)(82 . 7)
        # Setup UDP first
        self.udp_server_socket = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
        self.udp_server_socket.bind((self.udp_address, self.udp_port))
        self.station = Station({ "socket": self.udp_server_socket,
                                 "db_path": self.db_path,
                                 "address_table_path": self.address_table_path
                                 })
        self.station.socket = self.udp_server_socket
        logging.info("Listening for Pest packets on udp port %d." % self.udp_port)

        serversockets = []
(143 . 20)(98 . 13)
            serversockets.append(s)
            del s
            logging.info("Listening for IRC connections on port %d." % port)
        if self.chroot:
            os.chdir(self.chroot)
            os.chroot(self.chroot)
            logging.info("Changed root directory to %s" % self.chroot)
        if self.setuid:
            os.setgid(self.setuid[1])
            os.setuid(self.setuid[0])
            logging.info("Setting uid:gid to %s:%s"
                            % (self.setuid[0], self.setuid[1]))

        # event loop setup
        last_aliveness_check = time.time()
        last_embargo_queue_check = time.time()
        last_short_buffer_check = time.time()
        last_rubbish_dispatch = time.time()
        last_order_buffer_check = time.time()

        while True:
            # we don't want to be listening for client connections if there's already a client connected
            if self.client == None:
(176 . 6)(124 . 8)
                        (conn, addr) = x.accept()
                        self.client = Client(self, conn)
                        self.station.client = self.client
                        self.client.state = self.station.state
                        self.client.long_buffer = self.station.long_buffer
                        logging.info("Accepted connection from %s:%s." % (
                            addr[0], addr[1]))
                    except socket.error as e:
(199 . 15)(149 . 20)
                    last_aliveness_check = now

            # clear embargo queue if enough time has elapsed
            if last_embargo_queue_check + int(self.station.state.get_knob('embargo_interval')) < now:
                self.station.check_embargo_queue()
                last_embargo_queue_check = now
            if last_short_buffer_check + int(self.station.state.get_knob('short_buffer_check_interval_seconds')) < now:
                self.station.check_short_buffer()
                last_short_buffer_check = now

            # spray rubbish
            if last_rubbish_dispatch + int(self.station.state.get_knob('rubbish_interval')) < now:
            if last_rubbish_dispatch + int(self.station.state.get_knob('rubbish_interval_seconds')) < now:
                self.station.send_rubbish()
                last_rubbish_dispatch = now

            # check order buffer
            if last_order_buffer_check + int(self.station.state.get_knob('order_buffer_check_seconds')) < now:
                self.station.check_order_buffer()
                last_order_buffer_check = now

def create_directory(path):
    if not os.path.isdir(path):
        os.makedirs(path)

-
+ 6AE2E0B4022E647056CD53DF1B08F99F9DBDCEDA1F3EB8CF5A371BFA6F59A4A5CF90DCD9FB594C2D67466E202A684AE5E3BEB3528AE4CB61D4C198A3E493E315
blatta/lib/short_buffer.py

(0 . 0)(1 . 45)
import time

class ShortBuffer(object):
    def __init__(self, state):
        self.state = state
        self.buffer = {}

    def embargo(self, message):
        if message.message_hash not in self.buffer.keys():
            self.buffer[message.message_hash] = {
                'received': time.time(),
                'message': message,
                'low_bounce_count': message.bounces,
                'closest_peers': [message.peer],
                'reporting_peers': [message.peer]
            }
        else:
            embargoed_message = self.buffer[message.message_hash]
            if message.bounces < embargoed_message['low_bounce_count']:
                embargoed_message['low_bounce_count'] = message.bounces
                embargoed_message['closest_peers'] = [message.peer]
            elif message.bounces == embargoed_message['low_bounce_count']:
                embargoed_message['closest_peers'].append(message.peer)
            else:
                # not interested in the message because the bounce count
                # is higher than what we've already got and we just want the
                # list of peers closest to the originator
                pass
            embargoed_message['reporting_peers'].append(message.peer)

    def flush(self):
        current_time = time.time()
        messages = []
        for message_with_stats in self.buffer.values():
            if (message_with_stats['received'] <
                    (current_time - int(self.state.get_knob('short_buffer_expiration_seconds')))):
                messages.append(message_with_stats)
                del self.buffer[message_with_stats['message'].message_hash]
        return sorted(messages, key=lambda m: m['message'].timestamp)

    def has(self, message_hash):
        return self.buffer.get(message_hash)

    def drop(self, message_hash):
        del self.buffer[message_hash]

- 302F32CC4525B593ED2B8E61AE3610003F5811F59778E1085B3E6CB28DD87646D77758A48B7BB7643D41D7602524B2CB35F2D7C9D96FC1D3E4F5136CD5A1A6F8
+ 770B11A71459E33F5F4D2C72CF55DCB79B18C711F3041D8D23375A1419224D309A50C4F10C466527DC7EE910DBDA120ABE877D68E8981C7F51CA4A401BF54775
blatta/lib/state.py

(1 . 65)(1 . 119)
from peer import Peer
from message import EMPTY_CHAIN
import sqlite3
import imp
import hashlib
import binascii
import logging
import datetime
import caribou

from itertools import chain

KNOBS=({'max_bounces': 3,
        'embargo_interval': 1,
        'rubbish_interval': 10})
        'embargo_interval_seconds': 1,
        'rubbish_interval_seconds': 10,
        'nick': '',
        'order_buffer_check_seconds': 5 * 60,
        'order_buffer_expiration_seconds': 5 * 60,
        'short_buffer_expiration_seconds': 1,
        'short_buffer_check_interval_seconds': 1})

class State(object):
    __instance = None
    @staticmethod
    def get_instance(socket=None, db_path=None):
        if State.__instance == None:
            State(socket, db_path)
        return State.__instance

    def __init__(self, socket, db_path):
        if State.__instance != None:
            raise Exception("This class is a singleton")
        else:
            self.socket = socket
            self.conn = sqlite3.connect(db_path, check_same_thread=False)
            cursor = self.cursor()
            cursor.execute("create table if not exists at(handle_id integer,\
                                                          address text not null,\
                                                          port    integer not null,\
                                                          updated_at datetime default null,\
                                                          unique(handle_id, address, port))")

            cursor.execute("create table if not exists wot(peer_id integer primary key)")

            cursor.execute("create table if not exists handles(handle_id integer primary key,\
                                                               peer_id integer,\
                                                               handle text,\
                                                               unique(handle))")

            cursor.execute("create table if not exists keys(peer_id intenger,\
                                                            key text,\
                                                            used_at datetime default current_timestamp,\
                                                            unique(key))")

            cursor.execute("create table if not exists logs(\
                            handle text not null,\
                            peer_id integer,\
                            message_bytes blob not null,\
                            created_at datetime default current_timestamp)")

            cursor.execute("create table if not exists dedup_queue(\
                                 hash text not null,\
                                 created_at datetime default current_timestamp)")
            cursor.execute("create table if not exists knobs(\
                                 name text not null,\
                                 value text not null)")
            State.__instance = self
    def __init__(self, station, db_path=None):
        self.station = station
        if db_path:
            self.conn = sqlite3.connect(db_path)
        else:
            self.conn = sqlite3.connect("file::memory:")

        cursor = self.cursor()
        cursor.execute("create table if not exists handle_self_chain(id integer primary key autoincrement,\
                                                              handle string not null,\
                                                              message_hash blob not null)")

        cursor.execute("create table if not exists broadcast_self_chain(id integer primary key autoincrement,\
                                                              message_hash blob not null)")

        cursor.execute("create table if not exists net_chain(id integer primary key autoincrement,\
                                                              message_hash blob not null)")

        cursor.execute("create table if not exists at(handle_id integer,\
                                                      address text not null,\
                                                      port    integer not null,\
                                                      updated_at datetime default null,\
                                                      unique(handle_id, address, port))")

        cursor.execute("create table if not exists wot(peer_id integer primary key autoincrement)")

        cursor.execute("create table if not exists handles(handle_id integer primary key,\
                                                           peer_id integer,\
                                                           handle text,\
                                                           unique(handle))")

        cursor.execute("create table if not exists keys(peer_id intenger,\
                                                        key text,\
                                                        used_at datetime default current_timestamp,\
                                                        unique(key))")

        cursor.execute("create table if not exists log(\
                        message_bytes blob not null,\
                        message_hash text not null, \
                        command integer not null, \
                        timestamp datetime not null, \
                        created_at datetime default current_timestamp)")

        cursor.execute("create table if not exists knobs(\
                             name text not null,\
                             value text not null)")
        
        # migrate the db if necessary
        if db_path:
            caribou.upgrade(db_path, "migrations")

        self.conn.commit()

    def cursor(self):
        return self.conn.cursor()

    def update_handle_self_chain(self, handle, message_hash):
        cursor = self.cursor()
        cursor.execute("insert into handle_self_chain(handle, message_hash) values(?, ?)", (handle, buffer(message_hash)))
        self.conn.commit()

    def get_handle_self_chain(self, handle):
        cursor = self.cursor()
        results = cursor.execute("select message_hash from handle_self_chain where handle=?\
                                  order by id desc limit 1", (handle,)).fetchone()
        if results is not None:
            return results[0][:]
        else:
            return EMPTY_CHAIN

    def update_broadcast_self_chain(self, message_hash):
        cursor = self.cursor()
        cursor.execute("insert into broadcast_self_chain(message_hash) values(?)", (buffer(message_hash),))
        self.conn.commit()

    def get_broadcast_self_chain(self):
        cursor = self.cursor()
        results = cursor.execute("select message_hash from broadcast_self_chain order by id desc limit 1").fetchone()
        if results is not None:
            return results[0][:]
        else:
            return EMPTY_CHAIN

    def update_net_chain(self, message_hash):
        self.cursor().execute("insert into net_chain(message_hash) values(?)", (buffer(message_hash),))
        self.conn.commit()

    def get_net_chain(self):
        cursor = self.cursor()
        results = cursor.execute("select message_hash from net_chain order by id desc limit 1").fetchone()
        if results is not None:
            return results[0][:]
        else:
            return EMPTY_CHAIN

    def get_knobs(self):
        cursor = self.cursor()
        results = cursor.execute("select name, value from knobs order by name asc").fetchall()
(88 . 7)(142 . 15)
            cursor.execute("update knobs set value=? where name=?", (knob_value, knob_name,))
        else:
            cursor.execute("insert into knobs(name, value) values(?, ?)", (knob_name, knob_value,))
        

        self.conn.commit()

    def get_latest_message_timestamp(self):
        cursor = self.cursor()
        result = cursor.execute("select timestamp from log order by timestamp desc limit 1").fetchone()
        if result:
            return result[0]

    def get_at(self, handle=None):
        cursor = self.cursor()
        at = []
(114 . 57)(176 . 6)
                       "active_at": updated_at if updated_at else "no packets received from this address"})
        return at


    def is_duplicate_message(self, message_hash):
        cursor = self.cursor()
        cursor.execute("delete from dedup_queue where created_at < datetime(current_timestamp, '-1 hour')")
        self.conn.commit() 
        result = cursor.execute("select hash from dedup_queue where hash=?",
                            (message_hash,)).fetchone()
        logging.debug("checking if %s is dupe" % message_hash)
        if(result != None):
            return True
        else:
            return False

    def add_to_dedup_queue(self, message_hash):
        cursor = self.cursor()
        cursor.execute("insert into dedup_queue(hash)\
                             values(?)",
                            (message_hash,))
        logging.debug("added %s to dedup" % message_hash)
        self.conn.commit()

    def get_last_message_hash(self, handle, peer_id=None):
        cursor = self.cursor()
        if peer_id:
            message_bytes = cursor.execute("select message_bytes from logs\
                                                 where handle=? and peer_id=?\
                                                 order by created_at desc limit 1",
                                                (handle, peer_id)).fetchone()

        else:
            message_bytes = cursor.execute("select message_bytes from logs\
                                                 where handle=? and peer_id is null\
                                                 order by created_at desc limit 1",
                                                (handle,)).fetchone()

        if message_bytes:
            return hashlib.sha256(message_bytes[0][:]).digest()
        else:
            return "\x00" * 32

    def log(self, handle, message_bytes, peer=None):
        cursor = self.cursor()
        if peer != None:
            peer_id = peer.peer_id
        else:
            peer_id = None

        cursor.execute("insert into logs(handle, peer_id, message_bytes)\
                values(?, ?, ?)",
                (handle, peer_id, buffer(message_bytes)))

    def import_at_and_wot(self, at_path):
        cursor = self.cursor()
        wot = imp.load_source('wot', at_path)
(184 . 7)(195 . 6)
                                    (handle_id, peer["address"], peer["port"], None))
                cursor.execute("insert into keys(peer_id, key) values(?, ?)",
                                    (peer_id, key))

        self.conn.commit()

    def update_at(self, peer, set_active_at=True):
(212 . 24)(222 . 18)
                peer['address'],
                peer['port']))

        # otherwise update the existing entry if it differs
        # otherwise just update the existing entry
        else:
            try:
                if (at_entry[1] != peer['address'] or
                    at_entry[2] != peer['port']):
                    cursor.execute("update at set updated_at = ?,\
                    address = ?,\
                    port = ?\
                    where handle_id=?",
                    (timestamp,
                    peer["address"],
                    peer["port"],
                    handle_id))

                    logging.debug("updated at entry for %s: %s:%d" % (
                        peer['handle'],
                        peer['address'],
                        peer['port']))
                cursor.execute("update at set updated_at = ?,\
                address = ?,\
                port = ?\
                where handle_id=?",
                (timestamp,
                peer["address"],
                peer["port"],
                handle_id))

            except sqlite3.IntegrityError:
                cursor.execute("delete from at where handle_id=?", (handle_id,))
                
(310 . 10)(314 . 38)

    def listify(self, results):
        return list(chain.from_iterable(results))
        
    def get_keyed_peers(self, exclude_addressless=False):

    def log_has_message(self, message_hash):
        cursor = self.cursor()
        result = cursor.execute("select exists(select 1 from log where message_hash=?)\
                                 limit 1", (binascii.hexlify(message_hash),)).fetchone()
        return result[0]

    def log_message(self, message):
        cursor = self.cursor()
        message_hash_hex_string = binascii.hexlify(message.message_hash)
        cursor.execute("insert into log(message_hash, message_bytes, command, timestamp) values(?, ?, ?, ?)",
                       (message_hash_hex_string,
                        buffer(message.message_bytes),
                        message.command,
                        message.timestamp))
        self.conn.commit()

    def get_message(self, message_hash):
        cursor = self.cursor()
        message_hash_hex_string = binascii.hexlify(message_hash)
        result = cursor.execute("select command, message_bytes from log where message_hash=? limit 1",
                                (message_hash_hex_string,)).fetchone()
        if result:
            return result[0], result[1][:]

        return None, None

    def get_keyed_peers(self, exclude_addressless=False, exclude_ids=[]):
        cursor = self.cursor()
        peer_ids = self.listify(cursor.execute("select peer_id from keys").fetchall())
        peer_ids = self.listify(cursor.execute("select peer_id from keys\
                                                where peer_id not in (%s) order by random()" % ','.join('?'*len(exclude_ids)),
                                               exclude_ids).fetchall())
        peers = []
        for peer_id in peer_ids:
            handle = cursor.execute("select handle from handles where peer_id=?", (peer_id,)).fetchone()[0]
(334 . 15)(366 . 16)
        if handle_info == None:
            return None

        peer_id = handle_info[1]
        address = cursor.execute("select address, port from at where handle_id=?\
                                       order by updated_at desc limit 1",
                                     (handle_info[0],)).fetchone()
        handles = self.listify(cursor.execute("select handle from handles where peer_id=?",
                                      (handle_info[1],)).fetchall())
                                      (peer_id,)).fetchall())
        keys = self.listify(cursor.execute("select key from keys where peer_id=?\
                                                             order by used_at desc",
                                      (handle_info[1],)).fetchall())
        return Peer(self.socket, {
                                                             order by random()",
                                      (peer_id,)).fetchall())
        return Peer(self.station.socket, {
                                    "handles": handles,
                                    "peer_id": handle_info[1],
                                    "address": address[0] if address else None,
(352 . 6)(385 . 8)

    def is_duplicate(self, peers, peer):
        for existing_peer in peers:
            if existing_peer.address == peer.address and existing_peer.port == peer.port:
            if (not existing_peer.address is None
                and existing_peer.address == peer.address
                and existing_peer.port == peer.port):
               return True 
        return False 

- F53458362F6D7C18A066F42DBA0D1F8370DEF5BE9DD1A89A972082F3D387E34881CC879688AD66D1F5FE0D5930132FFCC176D32FA34487C0F5226394C17E6169
+ 24C203C6741B7EB17BF86C2A1046D5BE50F4FDECC7E9B4E5316E2F9101BEDEE9B84CE01A666EDF98F6545574571358E5B2EBC19B12C941F006BC1182DC2992F2
blatta/lib/station.py

(1 . 28)(1 . 47)
import time
VERSION = 9982

import binascii
import logging
import os

from lib.broadcast import Broadcast
from lib.direct import Direct
from state import State
from infosec import STALE_PACKET 
from infosec import DUPLICATE_PACKET 
from infosec import MALFORMED_PACKET 
from infosec import INVALID_SIGNATURE 
from infosec import IGNORED 
from infosec import Infosec
from commands import IGNORE 
from getdata import GetData
from message import STALE_PACKET, OUT_OF_ORDER_NET, OUT_OF_ORDER_SELF, OUT_OF_ORDER_BOTH
from message import DUPLICATE_PACKET 
from message import MALFORMED_PACKET 
from message import INVALID_SIGNATURE 
from message import UNSUPPORTED_VERSION
from message import Message
from commands import BROADCAST
from commands import DIRECT 
from peer import Peer
from ignore import Ignore
from server import Server
from long_buffer import LongBuffer
from order_buffer import OrderBuffer
from short_buffer import ShortBuffer
from commands import BROADCAST, DIRECT, GETDATA, IGNORE


class Station(object):
    def __init__(self, options):
    def __init__(self, cmd_line_options):
        self.client = None
        self.state = State.get_instance(options["socket"], options["db_path"])
        if options.get("address_table_path") != None:
            self.state.import_at_and_wot(options.get("address_table_path"))
        self.infosec = Infosec(self.state)
        self.embargo_queue = {} 
        self.socket = None
        self.state = State(self, cmd_line_options.db_path)
        if cmd_line_options.address_table_path is not None:
            self.state.import_at_and_wot(cmd_line_options.address_table_path)
        self.short_buffer = ShortBuffer(self.state)
        self.long_buffer = LongBuffer(self.state)
        self.order_buffer = OrderBuffer(self.state)
        self.server = Server(cmd_line_options, self)
        self.handlers = {
            DIRECT: self.handle_direct,
            BROADCAST: self.handle_broadcast,
            GETDATA: self.handle_getdata,
            IGNORE: self.handle_ignore
        }

    def start(self):
        self.server.start()

    def handle_udp_data(self, bytes_address_pair):
        data = bytes_address_pair[0]
(30 . 118)(49 . 173)
        packet_info = (address[0],
                       address[1], 
                       binascii.hexlify(data)[0:16])
        logging.debug("[%s:%d] -> %s" % packet_info)
        for peer in self.state.get_keyed_peers():
            message = self.infosec.unpack(peer, data)
            error_code = message.error_code
            if(error_code == None):
                logging.info("[%s:%d %s] -> %s %d %s" % (peer.address,
                    peer.port,
                    peer.handles[0],
                    message.body,
                    message.bounces,
                    message.message_hash))
                self.conditionally_update_at(peer, message, address)

                # if this is a direct message, just deliver it and return
                if message.command == DIRECT:
                    self.deliver(message)
                    return

                # embargo to wait for immediate copy of message 
                else:
                    self.embargo(message)
                    return
            elif error_code == STALE_PACKET:
                logging.debug("[%s:%d] -> stale packet: %s" % packet_info)
                return 
            elif error_code == DUPLICATE_PACKET:
                logging.debug("[%s:%d] -> duplicate packet: %s" % packet_info)
                return 
            elif error_code == MALFORMED_PACKET:
                logging.debug("[%s:%d] -> malformed packet: %s" % packet_info)
                return 
            elif error_code == IGNORED:
                self.conditionally_update_at(peer, message, address)
                logging.debug("[%s:%d] -> ignoring packet: %s" % packet_info)
                return 
            elif error_code == INVALID_SIGNATURE:
                pass 
        logging.debug("[%s:%d] -> martian packet: %s" % packet_info)
    
    def deliver(self, message):
        # add to duplicate queue
        self.state.add_to_dedup_queue(message.message_hash)

        # send to the irc client
        if self.client:
            self.client.message_from_station(message)

    def embargo(self, message):
        # initialize the key/value to empty array if not in the hash
        # append message to array
        if not message.message_hash in self.embargo_queue.keys():
            self.embargo_queue[message.message_hash] = []
        self.embargo_queue[message.message_hash].append(message)

    def check_embargo_queue(self):
        # get a lock so other threads can't mess with the db or the queue
        self.check_for_immediate_messages()
        self.flush_hearsay_messages()

    def check_for_immediate_messages(self):
        for key in dict(self.embargo_queue).keys():
            messages = self.embargo_queue[key]

            for message in messages:

                # if this is an immediate copy of the message

                if message.speaker in message.peer.handles:

                    # clear the queue and deliver

                    self.embargo_queue.pop(key, None)
                    self.deliver(message)
                    self.rebroadcast(message)           
                    break 
        metadata = {
            'address': address,
            'packet_info': packet_info,
        }

        for peer in self.state.get_keyed_peers():
            message = Message.unpack(peer,
                                     data,
                                     self.long_buffer,
                                     self.order_buffer,
                                     metadata,
                                     self.state)

            if message.get('error_code') is INVALID_SIGNATURE:
                continue

            if message.get('error_code') in [None,
                                             UNSUPPORTED_VERSION,
                                             STALE_PACKET,
                                             OUT_OF_ORDER_BOTH,
                                             OUT_OF_ORDER_SELF,
                                             OUT_OF_ORDER_NET,
                                             DUPLICATE_PACKET,
                                             MALFORMED_PACKET]:
                break

        if message.get('error_code') is None:
            if message['command'] == DIRECT:
                self.handle_message(Direct(message, self.state))
            elif message['command'] == BROADCAST:
                self.handle_message(Broadcast(message, self.state))
            elif message['command'] == GETDATA:
                # This is a little weird.  We don't want to instantiate a GetData
                # object here because that would switch around body and self_chain,
                # so let's just instantiate a generic Message and make sure to handle
                # it as a GetData message.
                self.handle_message(Message(message, self.state))
            elif message['command'] == IGNORE:
                self.handle_message(Ignore(message, self.state))
        else:
            self.report_error(message['error_code'], message)

    def flush_hearsay_messages(self):
        # if we made it this far either we haven't found any immediate messages
        # or we sent them all so we must deliver the remaining hearsay messages
        # with the appropriate labeling
        for key in dict(self.embargo_queue).keys():

            # collect the source handles
            handles = [] 
            messages = self.embargo_queue[key]
            for message in messages:
                handles.append(message.peer.handles[0])

            # select the message with the lowest bounce count 
            message = sorted(messages, key=lambda m: m.bounces)[0]

            # clear the queue
            self.embargo_queue.pop(key, None)

    def handle_message(self, message):
        try:
            self.handlers[message.command](message)
        except KeyError:
            logging.error("Unknown command, ignoring")

    def handle_direct(self, message):
        message.log_incoming(message.peer)
        self.deliver(message)
        self.long_buffer.intern(message)
        self.conditionally_update_at(message, message.metadata["address"])

    def handle_broadcast(self, message):
        # it's possible we'll log dupes coming out of the order buffer here
        message.log_incoming(message.peer)

        # check if this is an immediate message
        if message.speaker in message.peer.handles:
            # remove message from short buffer if it was received as hearsay
            if self.short_buffer.has(message.message_hash):
                self.short_buffer.drop(message.message_hash)
            self.deliver(message)
            self.long_buffer.intern(message)
            self.state.update_net_chain(message.message_hash)
            self.rebroadcast(message)
        else:
            # embargo to wait for immediate copy of message
            self.short_buffer.embargo(message)
        self.conditionally_update_at(message, message.metadata["address"])

    def handle_getdata(self, message):
        message.log_incoming_getdata(message.peer)

        # check for the requested message
        archived_message = self.long_buffer.exhume(message.body)

        # resend it if it exists
        if archived_message:
            archived_message.retry(message.peer)

    def handle_ignore(self, message):
        self.conditionally_update_at(message, message.metadata['address'])
        packet_info = message.metadata["packet_info"]
        address = packet_info[0]
        port = packet_info[1]
        packet_sample = packet_info[2]
        if os.environ.get('LOG_RUBBISH'):
            logging.debug("[%s:%d] -> ignoring packet: %s" % (address, port, packet_sample))
        return

    def check_order_buffer(self):
        messages = self.order_buffer.dequeue_and_order_mature_messages()
        for message in messages:
            self.handle_message(message)

    def check_short_buffer(self):
        messages = self.short_buffer.flush()
        for message_with_stats in messages:
            message = message_with_stats['message']
            # compute prefix
            if len(messages) < 4:
            if len(message_with_stats['closest_peers']) < 4:
                handles = []
                for peer in message_with_stats['closest_peers']:
                    handles.append(peer.handles[0])
                message.prefix = "%s[%s]" % (message.speaker, "|".join(handles))
            else:
                message.prefix = "%s[%d]" % (message.speaker, len(messages))
                message.prefix = "%s[%d]" % (message.speaker, len(message_with_stats['closest_peers']))

            # deliver
            self.deliver(message)
            self.long_buffer.intern(message)
            self.state.update_net_chain(message.message_hash)
            message.reporting_peers = message_with_stats['reporting_peers']
            self.rebroadcast(message)

    def report_error(self, error_code, message):
        packet_info = message['metadata']["packet_info"]
        address = packet_info[0]
        port = packet_info[1]
        packet_sample = packet_info[2]
        if error_code == STALE_PACKET:
            logging.debug("[%s:%d] -> stale packet: %s" % (address, port, binascii.hexlify(message['message_hash'])))
        elif error_code == DUPLICATE_PACKET:
            logging.debug("[%s:%d] -> duplicate packet: %s" % (address, port, binascii.hexlify(message['message_hash'])))
        elif error_code == MALFORMED_PACKET:
            logging.debug("[%s:%d] -> malformed packet: %s" % (address, port, packet_sample))
        elif error_code == INVALID_SIGNATURE:
            logging.debug("[%s:%d] -> invalid packet signature: %s" % (address, port, packet_sample))
        elif error_code == UNSUPPORTED_VERSION:
            logging.debug("[%s:%d] -> pest version not supported: %s" % (address, port, packet_sample))
        elif error_code == OUT_OF_ORDER_NET:
            self.add_message_to_order_buffer_and_send_getdata(message, ['net_chain'])
        elif error_code == OUT_OF_ORDER_SELF:
            self.add_message_to_order_buffer_and_send_getdata(message, ['self_chain'])
        elif error_code == OUT_OF_ORDER_BOTH:
            self.add_message_to_order_buffer_and_send_getdata(message, ['self_chain', 'net_chain'])

    def add_message_to_order_buffer_and_send_getdata(self, message, broken_chains):
        packet_info = message['metadata']["packet_info"]
        address = packet_info[0]
        port = packet_info[1]
        logging.debug(
            "[%s:%d] -> message received out of order: %s" % (address, port, binascii.hexlify(message['message_hash'])))
        if not self.order_buffer.has(message['message_hash']):
            for chain in broken_chains:
                GetData(message, chain, self.state).send()
        self.order_buffer.add(message)

            # send the message to all other peers if it should be propagated
            self.rebroadcast(message)           
    def deliver(self, message):
        # it's possible that these messages are from an order buffer
        # dump and their immediate copies may already have been broadcast
        # or vice versa so we need to check the long buffer
        if self.long_buffer.has(message.message_hash):
            return

        # set a timestamp warning if the message is older than the last displayed message.
        message.set_warning()

    # we only update the address table if the speaker is same as peer
        # send to the irc client
        if self.client:
            self.client.message_from_station(message)

    def conditionally_update_at(self, peer, message, address):
        if message.speaker in peer.handles:
    # we only update the address table if the speaker is same as peer
    def conditionally_update_at(self, message, address):
        if message.speaker in message.peer.handles:
            self.state.update_at({
                "handle": message.speaker,
                "address": address[0],
(149 . 19)(223 . 15)
            })

    def rebroadcast(self, message):
        if message.bounces < int(self.state.get_knob("max_bounces")):
            message.command = BROADCAST
            message.bounces = message.bounces + 1
            self.infosec.message(message) 
        else:
            logging.debug("message TTL expired: %s" % message.message_hash)

        if not message.get_data_response:
            if message.bounces < int(self.state.get_knob("max_bounces")):
                message.bounces = message.bounces + 1
                message.forward()
            else:
                logging.debug("message TTL expired: %s" % message.message_hash)

    def send_rubbish(self):
        if self.client:
            self.infosec.message(Message({
            Ignore({
                "speaker": self.client.nickname,
                "command": IGNORE,
                "bounces": 0,
                "body": self.infosec.gen_rubbish_body()
            }))
            }, self.state).send()

-
+ 24CB89EE415217D9D19CA443F9A25C918FD5D0ED9C30FAC6051A6886AF0AB5F05310A6E64F4D24C6B69AA5DDA096E99FADA0FB1A18FAE16F68BD36E725BDDA9A
blatta/migrations/20220106130042_use_ids.py

(0 . 0)(1 . 17)
"""
This module contains a Caribou migration.

Migration Name: use_ids 
Migration Version: 20220106130042
"""
import hashlib

def upgrade(conn):
    # alter dedup_queue hash type from text to blog
    conn.execute("drop table if exists dedup_queue")

    # add the unique id and message_hash columns to logs
    conn.execute("drop table if exists logs")

def downgrade(conn):
    pass

- C617E723EF3A1360C343CA635D0E4AA7F77AED515557644FCE41DAB0319057193EE75CFF2258F69486037A025353672C6E81418D8CD9DC0C1FA6C64B66DA8ED9
+
blatta/scripts/gen_key_pair.py

(1 . 63)(0 . 0)
#! /usr/bin/env python
# This is a TOY.  Do not fire in anger.

import os 
import sys
import base64
import pprint
from optparse import OptionParser


def main(argv):
    pp = pprint.PrettyPrinter(indent=4)
    op = OptionParser(
        description="gen_key_pair generates pseudo-random 64 byte key pairs for use in testing alcuin")
    op.add_option(
        "-r", "--remote-name",
        help="Name of remote station to include with key pair")
    op.add_option(
        "-l", "--local-name",
        help="Name of local station to include with key pair")
    op.add_option(
        "-p", "--remote-port",
        help="Remote station port number to include with key pair")
    op.add_option(
        "-q", "--local-port",
        help="Local station port number to include with key pair")
    op.add_option(
        "-a", "--remote-address",
        help="Remote station IP address to include with key pair")
    op.add_option(
        "-b", "--local-address",
        help="Local station IP address to include with key pair")

    (options, args) = op.parse_args(argv[1:])

    if options.local_port is None:
        options.local_port = 7778
    if options.remote_port is None:
        options.remote_port = 7778
    if options.local_address is None:
        options.local_address = "" 
    if options.remote_address is None:
        options.remote_address = "" 
    key = generate_key()
    my_config = {
        "name": options.local_name,
        "key": key,
        "address": options.local_address,
        "port": options.local_port
    }
    their_config = {
        "name": options.remote_name,
        "key": key,
        "address": options.remote_address,
        "port": options.remote_port
    }
    pp.pprint(my_config)
    pp.pprint(their_config)

def generate_key():
    return base64.b64encode(os.urandom(64))

main(sys.argv)

- BB6A2CA2267F79B30C0F393A552EC5CF79BD1B248A71093E72631955FA1F8D637AE3E0B2D5BC6FCA90A9615347DF64D79BBB390173A4F5B494C192545421E7A9
+ AFCBBCF791E1F0E90125A8FFDA4A018FB172FAE6C074BF5DD046371662BEFEA5CA980E28BB23DE5A5C3F1A6B0283B628605BDEA22FC5C425736B89FB12219442
blatta/start_test_net.sh

(2 . 5)(2 . 5)

# start 3 servers on different ports
./blatta --log-level debug --channel-name \#aleth --irc-port 9968 --udp-port 7778 --db-path a.db --address-table-path test_net_configs/a.py > logs/a &
# ./blatta --log-level info --channel-name \#aleth --irc-port 6669 --udp-port 7779 --db-path b.db --address-table-path test_net_configs/b.py > logs/b &
./blatta --log-level debug --channel-name \#aleth --irc-port 6669 --udp-port 7779 --db-path b.db --address-table-path test_net_configs/b.py > logs/b &
./blatta --log-level debug --channel-name \#aleth --irc-port 6670 --udp-port 7780 --db-path c.db --address-table-path test_net_configs/c.py > logs/c &

- 27BFACB1A2F3D5C0C9947045E0DBF61D2822C0DA84BE7B9589B261D79FD3B9B2A845D354FC0310AAE2841D5DC0B1D8FF22960D33D779DFBC6E0680BD33424D27
+ 215072B9B4CB54E788224F8E27B7FDA063F1CB9DBA302E7AFF276828AABF2DDB0EA5A802AF6165BE85F49AFAB36C4855059E40463372AEC8B396DC5FDD2D6A5A
blatta/test_net_configs/a.py

(1 . 12)(1 . 26)
peers = [
    {   'address': 'localhost',
    {
        'address': 'localhost',
        'key': '58bc4NyvMjasIXvsOvPxugaMpFS6tme+xJleOEwVn4iv2IuLUNAfHrkFCeL/Q4m/13Q5gfZxDbVEOtjQe+zW6Q==',
        'name': 'awt_b',
        'port': 7779
    },
#    {   'address': 'localhost',
#        'key': 'lT8/fYe/rQdReyavsTrVqInnLFCaU38o2ZAn5+r8uoFSSWgJelafikFELR9t6SJHMpFQvLmlAbF14nL2PfOAyA==',
#        'name': 'awt_c',
#        'port': 7780
#    }
    {
        'address': 'localhost',
        'key': 'oVIZ+U9F1b0YI9QdLVt2If/qLxoHG/2NCmgXq7HyaYASNn3zQeXTR/4Tz8z9MB6gOkwu+5+LH8L+MsyyQ0nhdA==',
        'name': 'awt_c',
        'port': 7780
    },
    {
        'address': 'localhost',
        'key': 'WEEnf6QWATZaVjKCkgsgYUD4uJyiYIqsQQagl/Hc35Hd/HOWSaw79YJ7uXyw9G1/XoJD0BMxMCJ6HEJ0jupL1A==',
        'name': 'awt_d',
        'port': 7781
     },
    {
        'address': 'localhost',
        'key': 'S3KJlcOLAlsy1bFJp71/woKsAF48SRPX5fcxWyxVmgsHlJeuVwq7hvQK6qKuNfIDnTUO/T9V0b75ugF0mAcQsg==',
        'name': 'awt_e',
        'port': 7782
     }
]

- 8869517FFCED618BB8197669AA4124F29E450CA8F2E6451DB8C7CB62D09F6EE4B6724DBD0A511851BCCA1D392A4AB6C6A5A1FC1FEB3F61E6F637A33BECD6E251
+ 44002664205935959EA93351A57366A1F91252AAD95FE5523919754220E4AEB61621D2D568F31B1364F04BED1453E1BC78B0C5C3C8D074AA2EF10D489554B212
blatta/test_net_configs/b.py

(8 . 5)(8 . 10)
        'key': '8ugkh+G1NC45DhPPtvPCI/78+fvV8K3v2XaQXvLGpJzeXy2IEA5ZnIo3PGU30+25JxAr0KV+InoqBa0VpY+zCA==',
        'name': 'awt_c',
        'port': 7780
    }
    },
    {   'address': 'localhost',
         'key': '+H7mJLhUvecaE+mcV1AOKzppSWHyPTpN8Sv8+Kr1usr9haxYGC8NSjs7LaXBdtuYceUAkl+TDJ6zJnqmVQUy8w==',
         'name': 'awt_d',
         'port': 7781
     }
]

- 12569FC74A9742F8D4CE31DE62C222D1F0010AFCBE863ED471EB95384CD06C6E86605BCABC04A9D6E1C53106FA46655AB9E6CAE2EC935C64BE5156186D7488C3
+ 1FBE9273E73AC3A8D9EC188FD3796C9CE35B68B232485B27B55B328FDE071E0DC221CF5A318446AAA76A52245F7A57F403B68EF1E984CA62D43756E90CEE4F5D
blatta/test_net_configs/c.py

(5 . 7)(5 . 7)
        'key': '8ugkh+G1NC45DhPPtvPCI/78+fvV8K3v2XaQXvLGpJzeXy2IEA5ZnIo3PGU30+25JxAr0KV+InoqBa0VpY+zCA=='
    },
    {   'address': 'localhost',
        'key': 'lT8/fYe/rQdReyavsTrVqInnLFCaU38o2ZAn5+r8uoFSSWgJelafikFELR9t6SJHMpFQvLmlAbF14nL2PfOAyA==',
        'key': 'oVIZ+U9F1b0YI9QdLVt2If/qLxoHG/2NCmgXq7HyaYASNn3zQeXTR/4Tz8z9MB6gOkwu+5+LH8L+MsyyQ0nhdA==',
        'name': 'awt_a',
        'port': 7778
    }

-
+ 3F950DF14EE015DDBE13D7982DDC1D5FD99B08E959B30C7BCC9478D7DBBF24019CECA6AC892C004C422AF2EDF5404439345DB9F10FE53097AE0AB3160CD10F3F
blatta/test_net_configs/d.py

(0 . 0)(1 . 14)
peers = [
    {
        'address': 'localhost',
        'name': 'awt_b',
        'port': 7779,
        'key': '+H7mJLhUvecaE+mcV1AOKzppSWHyPTpN8Sv8+Kr1usr9haxYGC8NSjs7LaXBdtuYceUAkl+TDJ6zJnqmVQUy8w=='
    },
    {
        'address': 'localhost',
        'name': 'awt_a',
        'port': 7778,
        'key': 'WEEnf6QWATZaVjKCkgsgYUD4uJyiYIqsQQagl/Hc35Hd/HOWSaw79YJ7uXyw9G1/XoJD0BMxMCJ6HEJ0jupL1A=='
     }
]

-
+ DBF72C79C7768C7C268AEBE48687FCEC4EBB25FC900A6F317F54C81B5879064A5BE52C3AF6D8FC68AB823638D21BE742949E2B06B09D4AA14F3281D7D3F5B7C0
blatta/test_net_configs/e.py

(0 . 0)(1 . 8)
peers = [
    {
        'address': 'localhost',
        'name': 'awt_a',
        'port': 7778,
        'key': 'S3KJlcOLAlsy1bFJp71/woKsAF48SRPX5fcxWyxVmgsHlJeuVwq7hvQK6qKuNfIDnTUO/T9V0b75ugF0mAcQsg=='
    }
]

-
+ 636EB6ADDE55156D0F8951B85CB7C3F58BE4BA90A8E616821794F8280FC7BEC33934C1A6CCA12B707207A083791B81DD74B4BE9AB5CE4E041B809205C90389E0
blatta/tests/helper.py

(0 . 0)(1 . 8)
import logging
import os
import sys


def setup():
    log_format = "%(levelname)s %(asctime)s: %(message)s"
    logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"), format=log_format, stream=sys.stdout)

-
+ 29EA5E81951450A33616BE0D9609CA1391F9A92A45378ABA6E6DA21058D4AD588FEF569CFF2B4AEE6B98BE416AEC7B6CE01BB09716A19975189BDB2A1281C04F
blatta/tests/test_broadcast.py

(0 . 0)(1 . 69)
import unittest
import helper
from mock import Mock
from lib.state import State
from lib.message import Message
from lib.broadcast import Broadcast
from lib.long_buffer import LongBuffer
from lib.order_buffer import OrderBuffer

class TestMessage(unittest.TestCase):
    def setUp(self):
        helper.setup()
        self.alice_socket = Mock()
        self.alice_state = State(self.alice_socket)
        self.bob_socket = Mock()
        self.bob_state = State(self.bob_socket)
        self.setupAlice()
        self.setupBob()

    def setupAlice(self):
        self.bob_state.add_peer('alice')
        self.bob_state.add_key(
            'alice',
            '9h6wYndVjt8QpnIZOYb7KD2tYKCKw4rjlYg4LM1ODx1Qkr3qA0IuKNukkwKhQ4UP9ypMlhyPHa7AGD7NO7Ws5w=='
        )
        self.bob_state.update_at({
            'handle': 'alice',
            'address': '127.0.0.1',
            'port': 8888
        })

    def setupBob(self):
        self.alice_state.add_peer('bob')
        self.alice_state.add_key(
            'bob',
            '9h6wYndVjt8QpnIZOYb7KD2tYKCKw4rjlYg4LM1ODx1Qkr3qA0IuKNukkwKhQ4UP9ypMlhyPHa7AGD7NO7Ws5w=='
        )
        self.alice_state.update_at({
            'handle': 'bob',
            'address': '127.0.0.1',
            'port': 8889
        })

    def tearDown(self):
        self.alice_state.remove_peer('bob')
        self.bob_state.remove_peer('alice')

    def test_broadcast_message(self):
        message = Broadcast({
            'handle': 'bob',
            'speaker': 'alice',
            'body': 'm1',
            'long_buffer': LongBuffer(self.alice_state)
        }, self.alice_state)
        message.send()
        bob = self.alice_state.get_peer_by_handle('bob')
        message_bytes = message.get_message_bytes(bob)
        black_packet = Message.pack(bob, message.command, message.bounces, message_bytes)
        self.bob_socket.sendto.called_once_with(black_packet, (bob.address, bob.port))

        # now bob must unpack the black packet
        alice = self.bob_state.get_peer_by_handle('alice')
        received_message = Message.unpack(alice,
                                          black_packet,
                                          LongBuffer(self.bob_state),
                                          OrderBuffer(self.bob_state),
                                          {})
        self.assertEqual(message.body, received_message['body'])

-
+ B5E72914E0E830B2EBAB8B1052667ED3A36F72ACD69312F87516894510ACA9EBF0A629F502B02B960E7AA4BC383AF801575B9EA0FD7860C26B9029B9AF2D0540
blatta/tests/test_direct.py

(0 . 0)(1 . 73)
import unittest

import time

import helper
from mock import Mock

from lib.state import State
from lib.message import Message
from lib.direct import Direct
from lib.long_buffer import LongBuffer
from lib.order_buffer import OrderBuffer

class TestMessage(unittest.TestCase):
    def setUp(self):
        helper.setup()
        self.alice_socket = Mock()
        self.alice_state = State(self.alice_socket)
        self.bob_socket = Mock()
        self.bob_state = State(self.bob_socket)
        self.setupAlice()
        self.setupBob()

    def setupAlice(self):
        self.bob_state.add_peer('alice')
        self.bob_state.add_key(
            'alice',
            '9h6wYndVjt8QpnIZOYb7KD2tYKCKw4rjlYg4LM1ODx1Qkr3qA0IuKNukkwKhQ4UP9ypMlhyPHa7AGD7NO7Ws5w=='
        )
        self.bob_state.update_at({
            'handle': 'alice',
            'address': '127.0.0.1',
            'port': 8888
        })

    def setupBob(self):
        self.alice_state.add_peer('bob')
        self.alice_state.add_key(
            'bob',
            '9h6wYndVjt8QpnIZOYb7KD2tYKCKw4rjlYg4LM1ODx1Qkr3qA0IuKNukkwKhQ4UP9ypMlhyPHa7AGD7NO7Ws5w=='
        )
        self.alice_state.update_at({
            'handle': 'bob',
            'address': '127.0.0.1',
            'port': 8889
        })

    def tearDown(self):
        self.alice_state.remove_peer('bob')
        self.bob_state.remove_peer('alice')

    def test_direct_message(self):
        message = Direct({
            'handle': 'bob',
            'speaker': 'alice',
            'body': 'm1',
            'long_buffer': LongBuffer(self.alice_state),
            'timestamp': int(time.time())
        }, self.alice_state)
        bob = self.alice_state.get_peer_by_handle('bob')
        message.message_bytes = message.get_message_bytes(bob)
        message.send()
        black_packet = Message.pack(bob, message.command, message.bounces, message.message_bytes)
        self.bob_socket.sendto.called_once_with(black_packet, (bob.address, bob.port))

        # now bob must unpack the black packet
        alice = self.bob_state.get_peer_by_handle('alice')
        received_message = Message.unpack(alice,
                                          black_packet,
                                          LongBuffer(self.bob_state),
                                          OrderBuffer(self.bob_state),
                                          {})
        self.assertEqual(message.body, received_message['body'])

-
+ B48397DE933C7423E2E5C881F18C0E30FF858F31D3DE6EF4C6074EA512AFA85069C9FD0CAF537C2CC41CC4CA8D69FDFE1AE1FD6F7AF9211CCDE47C8311A70776
blatta/tests/test_getdata.py

(0 . 0)(1 . 118)
import unittest
import logging

import time
from mock import Mock
from lib.message import Message
from lib.getdata import GetData
from lib.long_buffer import LongBuffer
from lib.order_buffer import OrderBuffer
from lib.state import State
from lib.direct import Direct
from lib.broadcast import Broadcast
import helper

class TestGetData(unittest.TestCase):
    def setUp(self):
        helper.setup()
        self.alice_socket = Mock()
        self.alice_state = State(self.alice_socket)
        self.alice_state.set_knob('nick', 'alice')
        self.setupBob()
        self.bob_socket = Mock()
        self.bob_state = State(self.bob_socket)
        self.setupAlice()

    def setupBob(self):
        self.alice_state.add_peer('bob')
        self.alice_state.add_key(
            'bob',
            '9h6wYndVjt8QpnIZOYb7KD2tYKCKw4rjlYg4LM1ODx1Qkr3qA0IuKNukkwKhQ4UP9ypMlhyPHa7AGD7NO7Ws5w=='
        )
        self.alice_state.update_at({
            'handle': 'bob',
            'address': '127.0.0.1',
            'port': 8889
        })

    def setupAlice(self):
        self.bob_state.add_peer('alice')
        self.bob_state.add_key(
            'alice',
            '9h6wYndVjt8QpnIZOYb7KD2tYKCKw4rjlYg4LM1ODx1Qkr3qA0IuKNukkwKhQ4UP9ypMlhyPHa7AGD7NO7Ws5w=='
        )
        self.bob_state.update_at({
            'handle': 'alice',
            'address': '127.0.0.1',
            'port': 8888
        })

    def test_send(self):
        long_buffer = LongBuffer(self.bob_state)
        m1 = Direct({
            'handle': 'alice',
            'speaker': 'bob',
            'body': 'm1',
            'timestamp': int(time.time()),
            'long_buffer': long_buffer
        }, self.bob_state)
        m2 = Direct({
            'handle': 'alice',
            'speaker': 'bob',
            'body': 'm2',
            'timestamp': int(time.time()),
            'long_buffer': long_buffer
        }, self.bob_state)
        m3 = Direct({
            'handle': 'alice',
            'speaker': 'bob',
            'body': 'm3',
            'timestamp': int(time.time()),
            'long_buffer': long_buffer
        }, self.bob_state)
        # we need to send these messages to get them into the log
        alice = self.bob_state.get_peer_by_handle('alice')
        m1.message_bytes = m1.get_message_bytes(alice)
        m1.send()
        m2.message_bytes = m2.get_message_bytes(alice)
        m2.send()
        m3.message_bytes = m3.get_message_bytes(alice)
        m3.send()

        # now let's compile the black packet so alice can
        # unpack it and get a message we can pass to GetData()
        m1_message_bytes = m1.get_message_bytes(alice)
        m1_black_packet = Message.pack(alice, m1.command, m1.bounces, m1_message_bytes)

        # we use m3 because if we used m2 there would be no break,
        # and if we used m1 it would be considered the first message
        m3_message_bytes = m3.get_message_bytes(alice)
        # TODO: something strange going on here with the message bytes causing the logger to barf
        m3_black_packet = Message.pack(alice, m3.command, m3.bounces, m3_message_bytes)


        # we need bob's peer object to know what key to use to decrypt
        bob = self.alice_state.get_peer_by_handle('bob')
        m1_received = Message.unpack(bob,
                                     m1_black_packet,
                                     LongBuffer(self.alice_state),
                                     OrderBuffer(self.alice_state),
                                     {},
                                     self.alice_state)

        m3_received = Message.unpack(bob,
                                     m3_black_packet,
                                     LongBuffer(self.alice_state),
                                     OrderBuffer(self.alice_state),
                                     {},
                                     self.alice_state)

        gd_message = GetData(m3_received, 'self_chain', self.alice_state)
        gd_message.send()

        # rebuild the black packet so we can compare with what was actually sent
        gd_black_packet = Message.pack(bob,
                                       gd_message.command,
                                       gd_message.bounces,
                                       gd_message.get_message_bytes(bob))
        self.alice_socket.sendto.called_once_with(gd_black_packet, (bob.address, bob.port))

- 991E1FF9817A01D4320ABDF30E09C890B5454C726E313A488DD6BEDC9E8E663019A63CAF9FC16979251F653BEDA05ECECA4A806A7E3C299E6847A8B6FE11A6E4
+ F6EB911B7A54EC1EF368E1EED8202AA2E385086F3D5509C08EB8BB78D216FF2408B7409B5F4F368D46EA98475C4AFB3A67A094EDE9109278AD0CB7EA93459F4B
blatta/tests/test_station.py

(2 . 27)(2 . 81)
import unittest
import logging
from mock import Mock
from mock import patch 

from lib.commands import DIRECT
from lib.commands import GETDATA
from lib.station import Station
from lib.state import State
from lib.message import Message
from lib.getdata import GetData
from lib.order_buffer import OrderBuffer
from lib.long_buffer import LongBuffer
from collections import namedtuple
import helper

class TestStation(unittest.TestCase):
    def setUp(self):
        helper.setup()
        logging.basicConfig(level=logging.DEBUG)
        options = {
            "clients": {"clientsocket": Mock()},
            "db_path": "tests/test.db",
            "socket": Mock()
        }
        self.station_socket = Mock()
        Options = namedtuple('Options', ['db_path',
                                         'address_table_path',
                                         'socket',
                                         'irc_ports',
                                         'udp_port',
                                         'channel_name',
                                         'password',
                                         'motd',
                                         'listen'])
        options = Options(
            None,
            None,
            self.station_socket,
            None,
            None,
            None,
            None,
            None,
            None
        )
        self.station = Station(options)
        self.station.deliver = Mock()
        self.station.rebroadcast = Mock()
        self.station.rebroadcast.return_value = "foobar"
        self.bob_state = State(Mock(), None)
        self.station.state.set_knob('nick', 'alice')
        self.bob_state.set_knob('nick', 'bob')
        self.setupBob()
        self.setupAlice()

    def setupBob(self):
        self.station.state.add_peer('bob')
        self.station.state.add_key(
            'bob',
            '9h6wYndVjt8QpnIZOYb7KD2tYKCKw4rjlYg4LM1ODx1Qkr3qA0IuKNukkwKhQ4UP9ypMlhyPHa7AGD7NO7Ws5w=='
        )
        self.station.state.update_at({
            'handle': 'bob',
            'address': '127.0.0.1',
            'port': 8889
        })

    def setupAlice(self):
        self.bob_state.add_peer('alice')
        self.bob_state.add_key(
            'alice',
            '9h6wYndVjt8QpnIZOYb7KD2tYKCKw4rjlYg4LM1ODx1Qkr3qA0IuKNukkwKhQ4UP9ypMlhyPHa7AGD7NO7Ws5w=='
        )
        self.bob_state.update_at({
            'handle': 'alice',
            'address': '127.0.0.1',
            'port': 8888
        })

    def tearDown(self):
        pass

    def test_embargo_bounce_ordering(self):
        self.skipTest("the tested code has been re-implemented")
        peer1 = Mock()
        peer1.handles = ["a", "b"]
        peer2 = Mock()
(35 . 7)(89 . 7)
        high_bounce_message.peer = peer2
        high_bounce_message.bounces = 2
        high_bounce_message.message_hash = "messagehash"
        self.station.embargo_queue = {
        self.station.short_buffer = {
            "messagehash": [
                low_bounce_message,
                high_bounce_message
(45 . 73)(99 . 31)
        self.station.deliver.assert_called_once_with(low_bounce_message)
        self.station.rebroadcast.assert_called_once_with(low_bounce_message)

    def test_immediate_message_delivered(self):
        peer = Mock()
        peer.handles = ["a", "b"]
        message = Mock()
        message.speaker = "a"
        message.peer = peer
        self.station.embargo_queue = {
            "messagehash": [
                message
            ],
        }
        self.station.check_for_immediate_messages()
        self.station.deliver.assert_called_once_with(message)
        self.station.rebroadcast.assert_called_once_with(message)

    def test_hearsay_message_not_delivered(self):
        peer = Mock()
        peer.handles = ["a", "b"]
        message = Mock()
        message.speaker = "c"
        message.peer = peer
        self.station.embargo_queue = {
            "messagehash": [
                message
            ],
        }
        self.station.check_for_immediate_messages()
        self.station.deliver.assert_not_called()

    def test_embargo_queue_cleared(self):
        self.skipTest("the embargo queue is now th short buffer")
        peer = Mock()
        peer.handles = ["a", "b"]
        message = Mock()
        message.speaker = "c"
        message.peer = peer
        self.station.embargo_queue = {
        self.station.short_buffer = {
            "messagehash": [
                message
            ],
        }
        self.assertEqual(len(self.station.embargo_queue), 1)
        self.assertEqual(len(self.station.short_buffer), 1)
        self.station.flush_hearsay_messages()
        self.assertEqual(len(self.station.embargo_queue), 0)

    def test_immediate_prefix(self):
        peer = Mock()
        peer.handles = ["a", "b"]
        message = Mock()
        message.speaker = "a"
        message.prefix = None
        message.peer = peer
        self.station.embargo_queue = {
            "messagehash": [
                message
            ],
        }
        self.station.check_for_immediate_messages()
        self.assertEqual(message.prefix, None)
        self.assertEqual(len(self.station.short_buffer), 0)

    def test_simple_hearsay_prefix(self):
        self.skipTest("this code has moved")
        peer = Mock()
        peer.handles = ["a", "b"]
        message = Mock()
        message.speaker = "c"
        message.prefix = None
        message.peer = peer
        self.station.embargo_queue = {
        self.station.short_buffer = {
            "messagehash": [
                message
            ],
(120 . 6)(132 . 7)
        self.assertEqual(message.prefix, "c[a]")

    def test_in_wot_hearsay_prefix_under_four(self):
        self.skipTest("the embargo queue is now th short buffer")
        peer1 = Mock()
        peer1.handles = ["a", "b"]
        peer2 = Mock()
(141 . 7)(154 . 7)
        message_via_peer3.prefix = None
        message_via_peer3.peer = peer3
        message_via_peer3.bounces = 1
        self.station.embargo_queue = {
        self.station.short_buffer = {
            "messagehash": [
                message_via_peer1,
                message_via_peer2,
(153 . 6)(166 . 7)
        self.assertEqual(message_via_peer1.prefix, "c[a|d|f]")

    def test_in_wot_hearsay_prefix_more_than_three(self):
        self.skipTest("the embargo queue is now th short buffer")
        peer1 = Mock()
        peer1.handles = ["a", "b"]
        peer2 = Mock()
(181 . 7)(195 . 7)
        message_via_peer4.prefix = None
        message_via_peer4.peer = peer4
        message_via_peer4.bounces = 1
        self.station.embargo_queue = {
        self.station.short_buffer = {
            "messagehash": [
                message_via_peer1,
                message_via_peer2,
(192 . 3)(206 . 47)
        self.station.flush_hearsay_messages()
        self.station.deliver.assert_called_once_with(message_via_peer1)
        self.assertEqual(message_via_peer1.prefix, "c[4]")

    # this test occasionally fails
    def test_receive_getdata_request_for_existing_direct_message(self):
        self.skipTest("intermittent failure")
        # 'send' bob a couple of messages
        m1 = Message({
            'command': DIRECT,
            'handle': 'bob',
            'speaker': 'alice',
            'body': 'm1',
            'bounces': 0
        }, self.station.state)

        m1.send()

        m2 = Message({
            'command': DIRECT,
            'handle': 'bob',
            'speaker': 'alice',
            'body': 'm2',
            'bounces': 0,
        }, self.station.state)

        m2.send()

        # oops look's like bob didn't get the message

        # build GETDATA black packet to retreive m1
        alice = self.bob_state.get_peer_by_handle('alice')
        bob = self.station.state.get_peer_by_handle('bob')
        gd_message = GetData(m2, self.bob_state)
        gd_message_bytes = gd_message.get_message_bytes(alice)
        gd_black_packet = Message.pack(bob, GETDATA, gd_message.bounces, gd_message_bytes)

        # call handle_udp_data with GETDATA packet
        self.station.handle_udp_data([gd_black_packet, ['127.0.0.1', 8889]])

        # build up the retry black packet to verify that it was sent 
        retry_black_packet = Message.pack(bob, DIRECT, 0, m1.get_message_bytes(bob))

        # assert retry is called and sends the correct message
        sent_message_black_packet = self.station_socket.sendto.call_args[0][0]
        sent_message = Message.unpack(bob, sent_message_black_packet, LongBuffer(), OrderBuffer(), self.station.state)
        self.assertEqual(sent_message.body, 'm1')