Exemple #1
0
def pack_header(header_data):
    """
        Attempt to pack the data from the header_data dictionary into binary format according to Waggle protocol.

        :param dictionary header_data: The header data to be serialized
        :rtype: string
        :raises KeyError: An exception will be raised if the provided dictionary does not contain required information
    """

    header = str()
    try:
        header += _pack_version(header_data["prot_ver"])                                                   # Serialize protocol version
        header += _pack_flags(header_data["flags"])                                                        # Packet flags
        header += _bin_pack(header_data["len_body"],HEADER_BYTELENGTHS["len_body"])          # Length of message body
        header += _bin_pack(header_data["time"],HEADER_BYTELENGTHS["time"])                  # Timestamp
        header += _bin_pack(header_data["msg_mj_type"], HEADER_BYTELENGTHS["msg_mj_type"])   # Message Major Type
        header += _bin_pack(header_data["msg_mi_type"], HEADER_BYTELENGTHS["msg_mi_type"])   # Message Minor Type
        header += _bin_pack(header_data["ext_header"], HEADER_BYTELENGTHS["ext_header"])     # Optional extended header
        header += _bin_pack(header_data["s_uniqid"],HEADER_BYTELENGTHS["s_uniqid"])          # Sender unique ID
        header += _bin_pack(header_data["r_uniqid"],HEADER_BYTELENGTHS["r_uniqid"])          # Recipient unique ID
        header += _bin_pack(header_data["snd_session"],HEADER_BYTELENGTHS["snd_session"])    # Send session number
        header += _bin_pack(header_data["resp_session"],HEADER_BYTELENGTHS["resp_session"])  # Response session number
        header += _bin_pack(header_data["snd_seq"],HEADER_BYTELENGTHS["snd_seq"])            # Send sequence number
        header += _bin_pack(header_data["resp_seq"],HEADER_BYTELENGTHS["resp_seq"])          # Response sequence number
    except KeyError as e:
        raise KeyError("Header packing failed. The required dictionary entry %s was missing!" % str(e))


    #Compute the header CRC and stick it on the end
    crc16 = mkCrcFun('crc-16')
    header += _bin_pack(crc16(header),2)

    return header
Exemple #2
0
def main() -> None:
    """Main function to run everything."""
    functions: Dict[str, Any] = {
        'mod_crc': predefinedcrc.mkCrcFun('crc-32c'),
        'sha1': hashlib.sha1,
        'md5': hashlib.md5,
        'blake2b': hashlib.blake2b,
        'blake2s': hashlib.blake2s
    }

    low: int = 32
    high: int = 1024
    increment: int = 2
    iterations: List[int] = [1000, 5000, 10000, 15000]
    data: Dict[int, bytes] = gen_data(low=low, high=high,\
        increment=increment, additionals=[20])
    # print actual size of data objects in the memory
    print("Actual sizes of generated chunks ...")
    for each in data.values():
        print(f"{len(each)} bytes: {sys.getsizeof(each)}")

    # measure timings
    for iteration in iterations:
        timings_total, timings_avg = calculate_timings(data,\
            functions, iterations=iteration)
        print_timings(timings_total, timings_avg)
Exemple #3
0
def flash_firmware(device: Device, path: str = "firmware/5110") -> None:
    firmware_file = open(join(path, f"{TARGET_FIRMWARE}.bin"), "rb")
    firmware = firmware_file.read()
    firmware_file.close()

    length = len(firmware)

    for i in range(0, length, 1008):
        device.write_firmware(i, firmware[i:i + 1008])

    device.check_firmware(0, len(firmware), mkCrcFun("crc-32-mpeg")(firmware))

    device.reset(False, True)
    device.wait_disconnect()

    print("Flash firmware: OK")
Exemple #4
0
def unpack(packet):
    """
        Turns a packet object into a tuple containing the header data and message body

        :param string packet: The packet data to be unpacked
        :rtype: tuple(dictionary, string)
        :raises IOError: An IOError will be raised if a CRC fails in the packet
        :raises KeyError: An IndexError will be raised if a packet header is the wrong length
    """
    crc32fun = mkCrcFun('crc-32')
    if(crc32fun(packet[HEADER_LENGTH:-FOOTER_LENGTH]) != _bin_unpack(packet[-FOOTER_LENGTH:])):
        raise IOError("Packet body CRC-32 failed.")
    try:
        header = _unpack_header(packet[:HEADER_LENGTH])
    except Exception as e:
        raise

    return (header, packet[HEADER_LENGTH:-FOOTER_LENGTH])
Exemple #5
0
def _unpack_header(packed_header):
    """
        Given a packed header, this method will return a dictionary with the unpacked contents.

        :param string packed_header: A string representing a waggle header
        :rtype: Dictionary
        :raises IndexError: An IndexError will be raised if the packed header is not 40 bytes long
        :raises IOError: An IOError will be raised if the packet header fails its CRC-16 check
    """

    # Check header length
    if len(packed_header) != HEADER_LENGTH:
        raise IndexError("Tried to unpack a waggle header that was not 40 bytes long.")

    header_IO = StringIO.StringIO(packed_header)

    #Check the CRC
    CRC16 = mkCrcFun('CRC-16')
    header_IO.seek(HEADER_LOCATIONS["crc-16"])
    headerCRC = header_IO.read(2)
    if(CRC16(packed_header[:-2]) != _bin_unpack(headerCRC)):
        raise IOError("Header CRC-16 check failed")
    header_IO.seek(0)

    # The header passed the CRC check. Hooray! Now return a dictionary containing the info.
    header = {
        "prot_ver"     : _unpack_version(header_IO.read(HEADER_BYTELENGTHS["prot_ver"])),        # Load protocol version
        "flags"        : _unpack_flags(header_IO.read(HEADER_BYTELENGTHS["flags"])),             # Load flags
        "len_body"     : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["len_body"])),            # Load message body length
        "time"         : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["time"])),                # Load time
        "msg_mj_type"  : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["msg_mj_type"])),         # Load message major type
        "msg_mi_type"  : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["msg_mi_type"])),         # Load message minor type
        "ext_header"   : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["ext_header"])),          # Load extended header
        "s_uniqid"     : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["s_uniqid"])),            # Load sender unique ID
        "r_uniqid"     : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["r_uniqid"])),            # Load recipient unique ID
        "snd_session"  : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["snd_session"])),         # Load send session number
        "resp_session" : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["resp_session"])),        # Load recipient session number
        "snd_seq"      : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["snd_seq"])),             # Load send sequence number
        "resp_seq"     : _bin_unpack(header_IO.read(HEADER_BYTELENGTHS["resp_seq"]))             # Load recieve sequence number
    }

    header_IO.close()
    return header
Exemple #6
0
import sys
from fds_const import commands as FMCC
from crcmod.predefined import mkCrcFun

crc = mkCrcFun("crc-16")


def query_yes_no(question, default="yes"):
    """Ask a yes/no question via raw_input() and return their answer.

    "question" is a string that is presented to the user.
    "default" is the presumed answer if the user just hits <Enter>.
        It must be "yes" (the default), "no" or None (meaning
        an answer is required of the user).

    The "answer" return value is True for "yes" or False for "no".
    """
    valid = {"yes": True, "y": True, "ye": True, "no": False, "n": False}
    if default is None:
        prompt = " [y/n] "
    elif default == "yes":
        prompt = " [Y/n] "
    elif default == "no":
        prompt = " [y/N] "
    else:
        raise ValueError("invalid default answer: '%s'" % default)

    while True:
        sys.stdout.write(question + prompt)
        choice = input().lower()
        if default is not None and choice == "":
HEADER_LENGTH = 40
FOOTER_LENGTH = 4
MAX_SEQ_NUMBER = pow(2,8*HEADER_BYTELENGTHS["snd_seq"])
MAX_PACKET_SIZE = 1024

VERSION = "0.4"

#Sequence becomes zero when the node starts again or when the package is
#reimported
SEQUENCE = 0

#The /etc/waggle folder has waggle specific information
S_UNIQUEID_HEX=None

#Create the CRC functions
crc32fun = mkCrcFun('crc-32')
crc16fun = mkCrcFun('crc-16')

crc16_position = HEADER_LOCATIONS['crc-16']

def nodeid_hexstr2int(node_id_hex):
    if type(node_id_hex) is str:
        node_id_hex = node_id_hex.encode('iso-8859-1')
    #return int.from_bytes(node_id_hex, byteorder='big')
    return int(node_id_hex, 16)
 
if os.path.isfile('/etc/waggle/node_id'):
    with open('/etc/waggle/node_id','r') as file_:
        S_UNIQUEID_HEX = file_.read().rstrip('\n')
    
    if len(S_UNIQUEID_HEX) != 2*HEADER_BYTELENGTHS["s_uniqid"]:
Exemple #8
0
HEADER_LENGTH = 40
FOOTER_LENGTH = 4
MAX_SEQ_NUMBER = pow(2, 8 * HEADER_BYTELENGTHS["snd_seq"])
MAX_PACKET_SIZE = 1024

VERSION = "0.4"

#Sequence becomes zero when the node starts again or when the package is
#reimported
SEQUENCE = 0

#The /etc/waggle folder has waggle specific information
S_UNIQUEID_HEX = None

#Create the CRC functions
crc32fun = mkCrcFun('crc-32')
crc16fun = mkCrcFun('crc-16')

crc16_position = HEADER_LOCATIONS['crc-16']


def nodeid_hexstr2int(node_id_hex):
    if type(node_id_hex) is str:
        node_id_hex = node_id_hex.encode('iso-8859-1')
    #return int.from_bytes(node_id_hex, byteorder='big')
    return int(node_id_hex, 16)


if os.path.isfile('/etc/waggle/node_id'):
    with open('/etc/waggle/node_id', 'r') as file_:
        S_UNIQUEID_HEX = file_.read().rstrip('\n')
Exemple #9
0
#!/usr/bin/env python
from __future__ import print_function
from bottle import request, response, get, post, run, template
from time import time
from datetime import datetime
import struct
from os import environ
from sys import argv

#from crc16 import crc16xmodem
from crcmod.predefined import mkCrcFun
crc16xmodem = mkCrcFun('xmodem')

# user details
GENDERS = {'f': 0, 'm': 2}

name = environ.get('HEL_USER', 'EXAMPLE')
min_tolerance = int(environ.get('HEL_MIN_TOLERANCE', 89000))  # grams
max_tolerance = int(environ.get('HEL_MAX_TOLERANCE', 97000))  # grams
age = datetime.now().year - int(environ.get('HEL_BIRTHYEAR',
                                            1970))  # birthyear
gender = GENDERS.get(environ.get('HEL_GENDER', '')[:1].lower(), 0x34)
height = int(environ.get('HEL_HEIGHT', 1900))  # millimetres

name = name[:20].upper().ljust(20)
age = 1 if age < 1 else age

log_buffer = []


def log(f, *args):
Exemple #10
0
"""

import logging
import struct
from typing import Optional, Any
from crcmod import predefined  # type: ignore

import attr

from ventserver.protocols import exceptions
from ventserver.sansio import channels
from ventserver.sansio import protocols


CRC_FUNC = predefined.mkCrcFun('crc-32c')

def quad_byte_attr(
        _: Any, __: 'attr.Attribute[bytes]', value: bytes
) -> None:
    """Validate the attr input as a byte re.

    Raises:
        ValueError: attr init value cannot be represented as a single byte.

    """
    if len(bytes(value)) != 4:
        raise ValueError(
            'Attr must be a bytes representation of unsigned long: {!r}'
            .format(value)
        )
Exemple #11
0
def pack(header_data, message_data=""):
    """
        Takes header and message information and yields packets representing that data.

        :param dictionary header_data: A dictionary containing the header data
        :param string/FileObject message_data: The data to be packed into a Packet
        :yields: string
        :raises KeyError: A KeyError will be raised if the header_data dictionary is not properly formatted
    """
    global SEQUENCE
    global UNIQUEID
    global VERSION

    #Generate the automatic fields
    auto_header = {
        "prot_ver"         : VERSION,
        "flags"            : (1,1,True),
        "len_body"         : len(message_data),
        "time"             : int(time.time()),
        "snd_session"      : 0,
        "s_uniqid"         : UNIQUEID,
        "ext_header"       : 0,
        "resp_session"     : 0,
        "r_uniqid"         : 0,
        "snd_seq"          : SEQUENCE,
        "resp_seq"         : 0,
    }
    #and update them with user-supplied values
    auto_header.update(header_data)

    #Create the CRC function
    crc32fun = mkCrcFun('crc-32')

    #If it's a string, make it a file object
    if(type(message_data) is str):
        message_data = StringIO.StringIO(message_data)

    #If it's under 1K, send it off as a single packet
    #Jump to the end of the file
    message_data.seek(0,2)

    #See if it is less than 1K
    if(message_data.tell() < MAX_PACKET_SIZE):
        try:
            header = pack_header(auto_header)
        except KeyError as e:
            raise

        #Save the short message to a string
        message_data.seek(0)
        msg = message_data.read()
        message_data.close()

        #Calculate the CRC, pack it all up, and return the result.
        SEQUENCE = (SEQUENCE + 1) % MAX_SEQ_NUMBER
        msg_crc32 = _bin_pack(crc32fun(msg),FOOTER_LENGTH)

        yield header + msg + msg_crc32

    #Multi-packet
    else:
        length = message_data.tell()
        message_data.seek(0)
        packetNum = 0

        # Create smaller packets MAX_PACKET_SIZE bytes at a time, also attach packet number
        while length > MAX_PACKET_SIZE:
            try:
                header = pack_header(auto_header)
            except KeyError as e:
                raise
            msg = _bin_pack(packetNum,4) + message_data.read(MAX_PACKET_SIZE)
            SEQUENCE = (SEQUENCE + 1) % MAX_SEQ_NUMBER
            packetNum += 1
            msg_crc32 = _bin_pack(crc32fun(msg),FOOTER_LENGTH)
            yield header + msg + msg_crc32
            length -= MAX_PACKET_SIZE

        # Finish sending the message
        if length > 0:
            header = pack_header(auto_header)
            msg = _bin_pack(packetNum,4) + message_data.read(MAX_PACKET_SIZE)
            SEQUENCE = (SEQUENCE + 1) % MAX_SEQ_NUMBER
            msg_crc32 = _bin_pack(crc32fun(msg),FOOTER_LENGTH)
            yield header + msg + msg_crc32
Exemple #12
0
#!/usr/bin/env python
from __future__ import print_function 
from bottle import request, response, get, post, run, template
from time import time
from datetime import datetime
import struct
from os import environ
from sys import argv

#from crc16 import crc16xmodem
from crcmod.predefined import mkCrcFun
crc16xmodem = mkCrcFun('xmodem')

# user details
GENDERS = {'f': 0, 'm': 2}

name = environ.get('HEL_USER', 'EXAMPLE')
min_tolerance = int(environ.get('HEL_MIN_TOLERANCE', 89000)) # grams
max_tolerance = int(environ.get('HEL_MAX_TOLERANCE', 97000)) # grams
age = datetime.now().year - int(environ.get('HEL_BIRTHYEAR', 1970)) # birthyear
gender = GENDERS.get(environ.get('HEL_GENDER', '')[:1].lower(), 0x34)
height = int(environ.get('HEL_HEIGHT', 1900)) # millimetres

name = name[:20].upper().ljust(20)
age = 1 if age < 1 else age

log_buffer = []
def log(f, *args):
	global log_buffer
	now = datetime.now().isoformat()
	o = f % args