Handshake working with new abstractions

10 files changed, 1089 insertions, 72 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e5e23ac..9084cbb 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -24,6 +24,9 @@ add_library (usbhost
     cobs.c
     noise.c
     packet_interface.c
+    adjectives.c
+    nouns.c
+    hid_keycodes.c
 )
 
 add_subdirectory (crypto)
diff --git a/src/adjectives.c b/src/adjectives.c
new file mode 100644
index 0000000..e3bc3d0
--- /dev/null
+++ b/src/adjectives.c
@@ -0,0 +1,262 @@
+
+#include "words.h"
+
+const char * const adjectives[256] = {
+    "wrathful",             /* 0   */
+    "worthy",               /* 1   */
+    "weird",                /* 2   */
+    "warm",                 /* 3   */
+    "volatile",             /* 4   */
+    "veiled",               /* 5   */
+    "vacuous",              /* 6   */
+    "useless",              /* 7   */
+    "upset",                /* 8   */
+    "unsoiled",             /* 9   */
+    "unsightly",            /* 10  */
+    "unpronounceable",      /* 11  */
+    "unfriendly",           /* 12  */
+    "unfree",               /* 13  */
+    "unfit",                /* 14  */
+    "unfaithful",           /* 15  */
+    "unchaste",             /* 16  */
+    "unbroken",             /* 17  */
+    "unbound",              /* 18  */
+    "unblessed",            /* 19  */
+    "unbefitting",          /* 20  */
+    "unaltered",            /* 21  */
+    "unabused",             /* 22  */
+    "unable",               /* 23  */
+    "ugly",                 /* 24  */
+    "tongued",              /* 25  */
+    "thorny",               /* 26  */
+    "thirsty",              /* 27  */
+    "thick",                /* 28  */
+    "terminal",             /* 29  */
+    "ten-sided",            /* 30  */
+    "teeming",              /* 31  */
+    "tangerine",            /* 32  */
+    "taken",                /* 33  */
+    "substantial",          /* 34  */
+    "stupefying",           /* 35  */
+    "stringy",              /* 36  */
+    "strange",              /* 37  */
+    "stillborn",            /* 38  */
+    "sticky",               /* 39  */
+    "stagnant",             /* 40  */
+    "spongy",               /* 41  */
+    "sour",                 /* 42  */
+    "soul-destroying",      /* 43  */
+    "smoldering",           /* 44  */
+    "smitten",              /* 45  */
+    "slain",                /* 46  */
+    "six-sided",            /* 47  */
+    "shifting",             /* 48  */
+    "shadowy",              /* 49  */
+    "severed",              /* 50  */
+    "seven-sided",          /* 51  */
+    "serene",               /* 52  */
+    "salty",                /* 53  */
+    "rust-red",             /* 54  */
+    "royal",                /* 55  */
+    "rotten",               /* 56  */
+    "riddled",              /* 57  */
+    "resentful",            /* 58  */
+    "regrettable",          /* 59  */
+    "reeking",              /* 60  */
+    "rare",                 /* 61  */
+    "rank",                 /* 62  */
+    "rancid",               /* 63  */
+    "quiescent",            /* 64  */
+    "putrid",               /* 65  */
+    "putrid",               /* 66  */
+    "putrescent",           /* 67  */
+    "prehistoric",          /* 68  */
+    "predatory",            /* 69  */
+    "predaceous",           /* 70  */
+    "porous",               /* 71  */
+    "poisonous",            /* 72  */
+    "pierced",              /* 73  */
+    "phlegmatic",           /* 74  */
+    "petrifying",           /* 75  */
+    "pessimal",             /* 76  */
+    "pathetic",             /* 77  */
+    "odorless",             /* 78  */
+    "oddish",               /* 79  */
+    "obsessed",             /* 80  */
+    "obscene",              /* 81  */
+    "numb",                 /* 82  */
+    "nine-sided",           /* 83  */
+    "nasty",                /* 84  */
+    "mysterious",           /* 85  */
+    "mute",                 /* 86  */
+    "musky",                /* 87  */
+    "morose",               /* 88  */
+    "moribund",             /* 89  */
+    "moldy",                /* 90  */
+    "miasmic",              /* 91  */
+    "material",             /* 92  */
+    "many-lobed",           /* 93  */
+    "malodorous",           /* 94  */
+    "malign",               /* 95  */
+    "maimed",               /* 96  */
+    "luminescent",          /* 97  */
+    "low-cut",              /* 98  */
+    "lousy",                /* 99  */
+    "live",                 /* 100 */
+    "limp",                 /* 101 */
+    "lifeless",             /* 102 */
+    "leering",              /* 103 */
+    "leaky",                /* 104 */
+    "layered",              /* 105 */
+    "latent",               /* 106 */
+    "lackluster",           /* 107 */
+    "jagged",               /* 108 */
+    "irregular",            /* 109 */
+    "iridescent",           /* 110 */
+    "intangible",           /* 111 */
+    "infinite",             /* 112 */
+    "inept",                /* 113 */
+    "incomprehensible",     /* 114 */
+    "in-between",           /* 115 */
+    "improper",             /* 116 */
+    "idle",                 /* 117 */
+    "hunted",               /* 118 */
+    "hideous",              /* 119 */
+    "heavy",                /* 120 */
+    "hairy",                /* 121 */
+    "guilty",               /* 122 */
+    "grotesque",            /* 123 */
+    "grey",                 /* 124 */
+    "greedy",               /* 125 */
+    "gory",                 /* 126 */
+    "gorgeous",             /* 127 */
+    "gooey",                /* 128 */
+    "golden-brown",         /* 129 */
+    "golden",               /* 130 */
+    "ghastly",              /* 131 */
+    "frostbitten",          /* 132 */
+    "fresh-cut",            /* 133 */
+    "freakish",             /* 134 */
+    "frantic",              /* 135 */
+    "fossilized",           /* 136 */
+    "formless",             /* 137 */
+    "formidable",           /* 138 */
+    "floccose",             /* 139 */
+    "five-lobed",           /* 140 */
+    "firstborn",            /* 141 */
+    "filthy",               /* 142 */
+    "fickle",               /* 143 */
+    "fetid",                /* 144 */
+    "fertile",              /* 145 */
+    "fearful",              /* 146 */
+    "fatal",                /* 147 */
+    "familiar",             /* 148 */
+    "fallen",               /* 149 */
+    "fallacious",           /* 150 */
+    "faint",                /* 151 */
+    "faceless",             /* 152 */
+    "extinct",              /* 153 */
+    "esoteric",             /* 154 */
+    "errant",               /* 155 */
+    "emergent",             /* 156 */
+    "elastic",              /* 157 */
+    "eight-sided",          /* 158 */
+    "eerie",                /* 159 */
+    "ebon",                 /* 160 */
+    "dysphoric",            /* 161 */
+    "dying",                /* 162 */
+    "dumb",                 /* 163 */
+    "dull-purple",          /* 164 */
+    "dull",                 /* 165 */
+    "dull",                 /* 166 */
+    "dull",                 /* 167 */
+    "dormant",              /* 168 */
+    "doomed",               /* 169 */
+    "disfigured",           /* 170 */
+    "dirty",                /* 171 */
+    "defenseless",          /* 172 */
+    "deep-pink",            /* 173 */
+    "deep",                 /* 174 */
+    "deconsecrated",        /* 175 */
+    "deathlike",            /* 176 */
+    "deadly",               /* 177 */
+    "dead",                 /* 178 */
+    "dark-blue",            /* 179 */
+    "dark",                 /* 180 */
+    "curly",                /* 181 */
+    "curious",              /* 182 */
+    "cured",                /* 183 */
+    "cunning",              /* 184 */
+    "crystalline",          /* 185 */
+    "cryptic",              /* 186 */
+    "crying",               /* 187 */
+    "crumbly",              /* 188 */
+    "crimson",              /* 189 */
+    "crested",              /* 190 */
+    "creepy",               /* 191 */
+    "crazy",                /* 192 */
+    "corrupt",              /* 193 */
+    "corporeal",            /* 194 */
+    "contemptible",         /* 195 */
+    "contained",            /* 196 */
+    "concrete",             /* 197 */
+    "cloudy",               /* 198 */
+    "chopped",              /* 199 */
+    "chained",              /* 200 */
+    "caustic",              /* 201 */
+    "catholic",             /* 202 */
+    "cathartic",            /* 203 */
+    "captive",              /* 204 */
+    "cancerous",            /* 205 */
+    "cabalistic",           /* 206 */
+    "burnt",                /* 207 */
+    "buoyant",              /* 208 */
+    "bronze-red",           /* 209 */
+    "bronze",               /* 210 */
+    "broken",               /* 211 */
+    "bright-red",           /* 212 */
+    "breathless",           /* 213 */
+    "bound",                /* 214 */
+    "bound",                /* 215 */
+    "bottomless",           /* 216 */
+    "bony",                 /* 217 */
+    "bodiless",             /* 218 */
+    "blue-lilac",           /* 219 */
+    "blue",                 /* 220 */
+    "bloody",               /* 221 */
+    "bloodthirsty",         /* 222 */
+    "bloodsucking",         /* 223 */
+    "bloodstained",         /* 224 */
+    "bloodcurdling",        /* 225 */
+    "blonde",               /* 226 */
+    "blistered",            /* 227 */
+    "blank",                /* 228 */
+    "bitter",               /* 229 */
+    "bilgy",                /* 230 */
+    "bewitched",            /* 231 */
+    "befouled",             /* 232 */
+    "beardless",            /* 233 */
+    "bastardly",            /* 234 */
+    "barbed",               /* 235 */
+    "baleful",              /* 236 */
+    "balding",              /* 237 */
+    "awkward",              /* 238 */
+    "awful",                /* 239 */
+    "atrocious",            /* 240 */
+    "arcane",               /* 241 */
+    "appalling",            /* 242 */
+    "antic",                /* 243 */
+    "anonymous",            /* 244 */
+    "angry",                /* 245 */
+    "ample",                /* 246 */
+    "ambiguous",            /* 247 */
+    "amber-green",          /* 248 */
+    "amber",                /* 249 */
+    "aghast",               /* 250 */
+    "activated",            /* 251 */
+    "acidic",               /* 252 */
+    "abused",               /* 253 */
+    "abstruse",             /* 254 */
+    "abject",               /* 255 */
+};
+
diff --git a/src/demo.c b/src/demo.c
index d080844..3a76a5d 100644
--- a/src/demo.c
+++ b/src/demo.c
@@ -28,6 +28,8 @@
 #include "rand_stm32.h"

 #include "packet_interface.h"

 #include "noise.h"

+#include "hid_keycodes.h"

+#include "words.h"

 

 #include <libopencm3/stm32/rcc.h>

 #include <libopencm3/stm32/gpio.h>

@@ -40,13 +42,21 @@
 #include <libopencmsis/core_cm3.h>

 

 #include <stdint.h>

-#include <string.h>

 #include <stdlib.h>

+#include <string.h>

 

 #ifndef USE_STM32F4_USBH_DRIVER_FS

 #error The full-speed USB driver must be enabled with USE_STM32F4_USBH_DRIVER_FS in usbh_config.h!

 #endif

 

+#ifndef MAX_FAILED_HANDSHAKES

+#define MAX_FAILED_HANDSHAKES 3

+#endif

+

+

+static struct NoiseState noise_state;

+static uint8_t remote_key_reference[CURVE25519_KEY_LEN];

+

 

 void _fini(void);

 

@@ -113,17 +123,99 @@ static void gpio_setup(void)
 	gpio_mode_setup(GPIOE, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, GPIO3 | GPIO4);

 }

 

-enum packet_types {

-    _RESERVED = 0,

-    HID_KEYBOARD_REPORT = 1,

-    HID_MOUSE_REPORT = 2

-};

+struct hid_report {

+    uint8_t modifiers;

+    uint8_t _reserved;

+    uint8_t keycodes[6];

+} __attribute__((__packed__));

+

+static char pairing_buf[512];

+static size_t pairing_buf_pos = 0;

+

+int pairing_check(struct NoiseState *st, const char *buf);

+void pairing_input(uint8_t keycode);

+void pairing_parse_report(struct hid_report *buf, uint8_t len);

+

+int pairing_check(struct NoiseState *st, const char *buf) {

+    const char *p = buf;

+    int idx = 0;

+    do {

+        const char *found = strchr(p, ' ');

+        size_t plen = found ? (size_t)(found - p) : strlen(p); /* p >= found */

+        int num = -1;

+        for (int i=0; i<256; i++) {

+            if (!strncmp(p, adjectives[i], plen) || !strncmp(p, nouns[i], plen)) {

+                num = i;

+                break;

+            }

+        }

+        if (num == -1) {

+            LOG_PRINTF("Pairing word not found in dictionary\n");

+            return -1;

+        }

+        if (st->handshake_hash[idx] != num) {

+            LOG_PRINTF("Pairing data does not match hash\n");

+            return -1;

+        }

+        idx++;

+        p = strchr(p, ' ');

+    } while (p != NULL && idx < BLAKE2S_HASH_SIZE);

+

+    if (idx < 8) {

+        LOG_PRINTF("Pairing sequence too short, only %d bytes of hash checked\n", idx);

+        return -1;

+    }

 

-struct hid_report_packet {

-    uint8_t type;

-    uint8_t len;

-    uint8_t report[8];

-};

+    return 0;

+}

+

+void pairing_input(uint8_t keycode) {

+    switch (keycode) {

+        case KEY_ENTER:

+            pairing_buf[pairing_buf_pos++] = '\0';

+            if (!pairing_check(&noise_state, pairing_buf)) {

+                persist_remote_key(&noise_state);

+                /* FIXME write key to backup memory */

+            }

+            break;

+

+        case KEY_BACKSPACE:

+            if (pairing_buf_pos > 0)

+                pairing_buf_pos--;

+            break;

+

+        default:

+            for (size_t i=0; i<sizeof(keycode_mapping)/sizeof(keycode_mapping[0]); i++) {

+                if (keycode_mapping[i].kc == keycode) {

+                    if (pairing_buf_pos < sizeof(pairing_buf)-1) /* allow for terminating null byte */

+                        pairing_buf[pairing_buf_pos++] = keycode_mapping[i].ch;

+                    break;

+                }

+            }

+            break;

+    }

+}

+

+void pairing_parse_report(struct hid_report *buf, uint8_t len) {

+    static uint8_t old_keycodes[6] = {0};

+

+    for (int i=0; i<len-2; i++) {

+        if (!buf->keycodes[i])

+            break; /* keycodes are always populated from low to high */

+

+        int found = 0;

+        for (int j=0; j<6; j++) {

+            if (old_keycodes[j] == buf->keycodes[i]) {

+                found = 1;

+                break;

+            }

+        }

+        if (!found) /* key pressed */

+            pairing_input(buf->keycodes[i]);

+    }

+

+    memcpy(old_keycodes, buf->keycodes, 6);

+}

 

 static void hid_in_message_handler(uint8_t device_id, const uint8_t *data, uint32_t length)

 {

@@ -136,21 +228,34 @@ static void hid_in_message_handler(uint8_t device_id, const uint8_t *data, uint3
 		return;

 	}

 

-	int type = hid_get_type(device_id);

-    if (type != HID_TYPE_KEYBOARD && type != HID_TYPE_MOUSE) {

-        LOG_PRINTF("Unsupported HID report type %x\n", type);

-        return;

-    }

-

 	LOG_PRINTF("Sending event %02X %02X %02X %02X\n", data[0], data[1], data[2], data[3]);

     struct hid_report_packet pkt = {

-        .type = type == HID_TYPE_KEYBOARD ? HID_KEYBOARD_REPORT : HID_MOUSE_REPORT,

         .len = length,

         .report = {0}

     };

     memcpy(pkt.report, data, length);

 

-    if (send_encrypted_message((uint8_t *)&pkt, sizeof(pkt))) {

+	int type = hid_get_type(device_id);

+    if (type == HID_TYPE_KEYBOARD) {

+        if (noise_state.handshake_state == HANDSHAKE_DONE_UNKNOWN_HOST) {

+            pkt.type = PAIRING;

+            pairing_parse_report((struct hid_report *)data, length);

+        } else {

+            pkt.type = HID_KEYBOARD_REPORT;

+        }

+    } else if (type == HID_TYPE_MOUSE) {

+        if (noise_state.handshake_state == HANDSHAKE_DONE_UNKNOWN_HOST) {

+            LOG_PRINTF("Not sending HID mouse report during pairing\n");

+            return;

+        } else {

+            pkt.type = HID_MOUSE_REPORT;

+        }

+    } else {

+        LOG_PRINTF("Unsupported HID report type %x\n", type);

+        return;

+    }

+

+    if (send_encrypted_message(&noise_state, (uint8_t *)&pkt, sizeof(pkt))) {

         LOG_PRINTF("Error sending HID report packet\n");

         return;

     }

@@ -213,21 +318,52 @@ int main(void)
 	LOG_PRINTF("Initializing RNG...\n");

     rand_init();

 

+    noise_state_init(&noise_state, remote_key_reference);

+    /* FIXME load remote key from backup memory */

     /* FIXME only run this on first boot and persist key in backup sram. Allow reset via jumper-triggered factory reset function. */

     LOG_PRINTF("Generating identity key...\n");

-    if (generate_identity_key())

+    if (generate_identity_key(&noise_state))

         LOG_PRINTF("Error generating identiy key\n");

 

-    LOG_PRINTF("Starting noise protocol handshake...\n");

-    NoiseHandshakeState *handshake = start_protocol_handshake();

-    if (!handshake)

-        LOG_PRINTF("Error starting protocol handshake.\n");

-

 	while (23) {

 		usbh_poll(tim6_get_time_us());

 

-        if (handshake)

-            handshake = try_continue_noise_handshake(handshake);

+        if (host_packet_length > 0) {

+            struct control_packet *pkt = (struct control_packet *)host_packet_buf;

+            size_t payload_length = host_packet_length - 1;

+

+            if (pkt->type == HOST_INITIATE_HANDSHAKE) {

+                /* It is important that we acknowledge this command right away. Starting the handshake involves key

+                 * generation which takes a few milliseconds. If we'd acknowledge this later, we might run into an

+                 * overrun here since we would be blocking the buffer during key generation. */

+                host_packet_length = 0; /* Acknowledge to USART ISR the buffer has been handled */

+

+                if (payload_length > 0) {

+                    LOG_PRINTF("Extraneous data in INITIATE_HANDSHAKE message\n");

+                } else if (noise_state.failed_handshakes < MAX_FAILED_HANDSHAKES) {

+                    LOG_PRINTF("Starting noise protocol handshake...\n");

+                    if (reset_protocol_handshake(&noise_state))

+                        LOG_PRINTF("Error starting protocol handshake.\n");

+                    pairing_buf_pos = 0; /* Reset channel binding keyboard input buffer */

+                } else {

+                    LOG_PRINTF("Too many failed handshake attempts, not starting another one\n");

+                }

+            } else if (pkt->type == HOST_HANDSHAKE) {

+                LOG_PRINTF("Handling handshake packet of length %d\n", payload_length);

+                int consumed = 0;

+                try_continue_noise_handshake(&noise_state, pkt->payload, payload_length, &consumed);

+                if (consumed)

+                    host_packet_length = 0; /* Acknowledge to USART ISR the buffer has been handled */

+                else /* Otherwise this gets called again in the next iteration of the main loop. Usually that should not happen. */

+                    LOG_PRINTF("Handshake buffer unhandled. Waiting for next iteration.\n");

+

+            } else {

+                host_packet_length = 0; /* Acknowledge to USART ISR the buffer has been handled */

+            }

+        }

+

+        if (noise_state.handshake_state == HANDSHAKE_IN_PROGRESS)

+            try_continue_noise_handshake(&noise_state, NULL, 0, NULL); /* handle outgoing messages */

 

 		delay_ms_busy_loop(1); /* approx 1ms interval between usbh_poll() */

 	}

diff --git a/src/hid_keycodes.c b/src/hid_keycodes.c
new file mode 100644
index 0000000..19b6f69
--- /dev/null
+++ b/src/hid_keycodes.c
@@ -0,0 +1,43 @@
+
+#include "hid_keycodes.h"
+
+struct keymap_entry keycode_mapping[37] = {
+    { KEY_A, 'A' },
+    { KEY_B, 'B' },
+    { KEY_C, 'C' },
+    { KEY_D, 'D' },
+    { KEY_E, 'E' },
+    { KEY_F, 'F' },
+    { KEY_G, 'G' },
+    { KEY_H, 'H' },
+    { KEY_I, 'I' },
+    { KEY_J, 'J' },
+    { KEY_K, 'K' },
+    { KEY_L, 'L' },
+    { KEY_M, 'M' },
+    { KEY_N, 'N' },
+    { KEY_O, 'O' },
+    { KEY_P, 'P' },
+    { KEY_Q, 'Q' },
+    { KEY_R, 'R' },
+    { KEY_S, 'S' },
+    { KEY_T, 'T' },
+    { KEY_U, 'U' },
+    { KEY_V, 'V' },
+    { KEY_W, 'W' },
+    { KEY_X, 'X' },
+    { KEY_Y, 'Y' },
+    { KEY_Z, 'Z' },
+    { KEY_1, '1' },
+    { KEY_2, '2' },
+    { KEY_3, '3' },
+    { KEY_4, '4' },
+    { KEY_5, '5' },
+    { KEY_6, '6' },
+    { KEY_7, '7' },
+    { KEY_8, '8' },
+    { KEY_9, '9' },
+    { KEY_0, '0' },
+    { KEY_SPACE, ' ' },
+};
+
diff --git a/src/hid_keycodes.h b/src/hid_keycodes.h
new file mode 100644
index 0000000..a7f590a
--- /dev/null
+++ b/src/hid_keycodes.h
@@ -0,0 +1,194 @@
+#ifndef __HID_KEYCODES_H__
+#define __HID_KEYCODES_H__
+
+struct keymap_entry {
+    unsigned char kc;
+    char ch;
+};
+
+extern struct keymap_entry keycode_mapping[37];
+
+enum hid_keycode {
+    KEY_NONE = 0x00, // No key pressed
+    KEY_ERR_OVF = 0x01, //  Keyboard Error Roll Over - used for all slots if too many keys are pressed ("Phantom key")
+    KEY_A = 0x04, // Keyboard a and A
+    KEY_B = 0x05, // Keyboard b and B
+    KEY_C = 0x06, // Keyboard c and C
+    KEY_D = 0x07, // Keyboard d and D
+    KEY_E = 0x08, // Keyboard e and E
+    KEY_F = 0x09, // Keyboard f and F
+    KEY_G = 0x0a, // Keyboard g and G
+    KEY_H = 0x0b, // Keyboard h and H
+    KEY_I = 0x0c, // Keyboard i and I
+    KEY_J = 0x0d, // Keyboard j and J
+    KEY_K = 0x0e, // Keyboard k and K
+    KEY_L = 0x0f, // Keyboard l and L
+    KEY_M = 0x10, // Keyboard m and M
+    KEY_N = 0x11, // Keyboard n and N
+    KEY_O = 0x12, // Keyboard o and O
+    KEY_P = 0x13, // Keyboard p and P
+    KEY_Q = 0x14, // Keyboard q and Q
+    KEY_R = 0x15, // Keyboard r and R
+    KEY_S = 0x16, // Keyboard s and S
+    KEY_T = 0x17, // Keyboard t and T
+    KEY_U = 0x18, // Keyboard u and U
+    KEY_V = 0x19, // Keyboard v and V
+    KEY_W = 0x1a, // Keyboard w and W
+    KEY_X = 0x1b, // Keyboard x and X
+    KEY_Y = 0x1c, // Keyboard y and Y
+    KEY_Z = 0x1d, // Keyboard z and Z
+
+    KEY_1 = 0x1e, // Keyboard 1 and !
+    KEY_2 = 0x1f, // Keyboard 2 and @
+    KEY_3 = 0x20, // Keyboard 3 and #
+    KEY_4 = 0x21, // Keyboard 4 and $
+    KEY_5 = 0x22, // Keyboard 5 and %
+    KEY_6 = 0x23, // Keyboard 6 and ^
+    KEY_7 = 0x24, // Keyboard 7 and &
+    KEY_8 = 0x25, // Keyboard 8 and *
+    KEY_9 = 0x26, // Keyboard 9 and (
+    KEY_0 = 0x27, // Keyboard 0 and )
+
+    KEY_ENTER = 0x28, // Keyboard Return (ENTER)
+    KEY_ESC = 0x29, // Keyboard ESCAPE
+    KEY_BACKSPACE = 0x2a, // Keyboard DELETE (Backspace)
+    KEY_TAB = 0x2b, // Keyboard Tab
+    KEY_SPACE = 0x2c, // Keyboard Spacebar
+    KEY_MINUS = 0x2d, // Keyboard - and _
+    KEY_EQUAL = 0x2e, // Keyboard = and +
+    KEY_LEFTBRACE = 0x2f, // Keyboard [ and {
+    KEY_RIGHTBRACE = 0x30, // Keyboard ] and }
+    KEY_BACKSLASH = 0x31, // Keyboard \ and |
+    KEY_HASHTILDE = 0x32, // Keyboard Non-US # and ~
+    KEY_SEMICOLON = 0x33, // Keyboard ; and :
+    KEY_APOSTROPHE = 0x34, // Keyboard ' and "
+    KEY_GRAVE = 0x35, // Keyboard ` and ~
+    KEY_COMMA = 0x36, // Keyboard , and <
+    KEY_DOT = 0x37, // Keyboard . and >
+    KEY_SLASH = 0x38, // Keyboard / and ?
+    KEY_CAPSLOCK = 0x39, // Keyboard Caps Lock
+
+    KEY_F1 = 0x3a, // Keyboard F1
+    KEY_F2 = 0x3b, // Keyboard F2
+    KEY_F3 = 0x3c, // Keyboard F3
+    KEY_F4 = 0x3d, // Keyboard F4
+    KEY_F5 = 0x3e, // Keyboard F5
+    KEY_F6 = 0x3f, // Keyboard F6
+    KEY_F7 = 0x40, // Keyboard F7
+    KEY_F8 = 0x41, // Keyboard F8
+    KEY_F9 = 0x42, // Keyboard F9
+    KEY_F10 = 0x43, // Keyboard F10
+    KEY_F11 = 0x44, // Keyboard F11
+    KEY_F12 = 0x45, // Keyboard F12
+
+    KEY_SYSRQ = 0x46, // Keyboard Print Screen
+    KEY_SCROLLLOCK = 0x47, // Keyboard Scroll Lock
+    KEY_PAUSE = 0x48, // Keyboard Pause
+    KEY_INSERT = 0x49, // Keyboard Insert
+    KEY_HOME = 0x4a, // Keyboard Home
+    KEY_PAGEUP = 0x4b, // Keyboard Page Up
+    KEY_DELETE = 0x4c, // Keyboard Delete Forward
+    KEY_END = 0x4d, // Keyboard End
+    KEY_PAGEDOWN = 0x4e, // Keyboard Page Down
+    KEY_RIGHT = 0x4f, // Keyboard Right Arrow
+    KEY_LEFT = 0x50, // Keyboard Left Arrow
+    KEY_DOWN = 0x51, // Keyboard Down Arrow
+    KEY_UP = 0x52, // Keyboard Up Arrow
+
+    KEY_NUMLOCK = 0x53, // Keyboard Num Lock and Clear
+    KEY_KPSLASH = 0x54, // Keypad /
+    KEY_KPASTERISK = 0x55, // Keypad *
+    KEY_KPMINUS = 0x56, // Keypad -
+    KEY_KPPLUS = 0x57, // Keypad +
+    KEY_KPENTER = 0x58, // Keypad ENTER
+    KEY_KP1 = 0x59, // Keypad 1 and End
+    KEY_KP2 = 0x5a, // Keypad 2 and Down Arrow
+    KEY_KP3 = 0x5b, // Keypad 3 and PageDn
+    KEY_KP4 = 0x5c, // Keypad 4 and Left Arrow
+    KEY_KP5 = 0x5d, // Keypad 5
+    KEY_KP6 = 0x5e, // Keypad 6 and Right Arrow
+    KEY_KP7 = 0x5f, // Keypad 7 and Home
+    KEY_KP8 = 0x60, // Keypad 8 and Up Arrow
+    KEY_KP9 = 0x61, // Keypad 9 and Page Up
+    KEY_KP0 = 0x62, // Keypad 0 and Insert
+    KEY_KPDOT = 0x63, // Keypad . and Delete
+
+    KEY_102ND = 0x64, // Keyboard Non-US \ and |
+    KEY_COMPOSE = 0x65, // Keyboard Application
+    KEY_POWER = 0x66, // Keyboard Power
+    KEY_KPEQUAL = 0x67, // Keypad =
+
+    KEY_F13 = 0x68, // Keyboard F13
+    KEY_F14 = 0x69, // Keyboard F14
+    KEY_F15 = 0x6a, // Keyboard F15
+    KEY_F16 = 0x6b, // Keyboard F16
+    KEY_F17 = 0x6c, // Keyboard F17
+    KEY_F18 = 0x6d, // Keyboard F18
+    KEY_F19 = 0x6e, // Keyboard F19
+    KEY_F20 = 0x6f, // Keyboard F20
+    KEY_F21 = 0x70, // Keyboard F21
+    KEY_F22 = 0x71, // Keyboard F22
+    KEY_F23 = 0x72, // Keyboard F23
+    KEY_F24 = 0x73, // Keyboard F24
+
+    KEY_OPEN = 0x74, // Keyboard Execute
+    KEY_HELP = 0x75, // Keyboard Help
+    KEY_PROPS = 0x76, // Keyboard Menu
+    KEY_FRONT = 0x77, // Keyboard Select
+    KEY_STOP = 0x78, // Keyboard Stop
+    KEY_AGAIN = 0x79, // Keyboard Again
+    KEY_UNDO = 0x7a, // Keyboard Undo
+    KEY_CUT = 0x7b, // Keyboard Cut
+    KEY_COPY = 0x7c, // Keyboard Copy
+    KEY_PASTE = 0x7d, // Keyboard Paste
+    KEY_FIND = 0x7e, // Keyboard Find
+    KEY_MUTE = 0x7f, // Keyboard Mute
+    KEY_VOLUMEUP = 0x80, // Keyboard Volume Up
+    KEY_VOLUMEDOWN = 0x81, // Keyboard Volume Down
+    KEY_KPCOMMA = 0x85, // Keypad Comma
+    KEY_RO = 0x87, // Keyboard International1
+    KEY_KATAKANAHIRAGANA = 0x88, // Keyboard International2
+    KEY_YEN = 0x89, // Keyboard International3
+    KEY_HENKAN = 0x8a, // Keyboard International4
+    KEY_MUHENKAN = 0x8b, // Keyboard International5
+    KEY_KPJPCOMMA = 0x8c, // Keyboard International6
+    KEY_HANGEUL = 0x90, // Keyboard LANG1
+    KEY_HANJA = 0x91, // Keyboard LANG2
+    KEY_KATAKANA = 0x92, // Keyboard LANG3
+    KEY_HIRAGANA = 0x93, // Keyboard LANG4
+    KEY_ZENKAKUHANKAKU = 0x94, // Keyboard LANG5
+    KEY_KPLEFTPAREN = 0xb6, // Keypad (
+    KEY_KPRIGHTPAREN = 0xb7, // Keypad )
+
+    KEY_LEFTCTRL = 0xe0, // Keyboard Left Control
+    KEY_LEFTSHIFT = 0xe1, // Keyboard Left Shift
+    KEY_LEFTALT = 0xe2, // Keyboard Left Alt
+    KEY_LEFTMETA = 0xe3, // Keyboard Left GUI
+    KEY_RIGHTCTRL = 0xe4, // Keyboard Right Control
+    KEY_RIGHTSHIFT = 0xe5, // Keyboard Right Shift
+    KEY_RIGHTALT = 0xe6, // Keyboard Right Alt
+    KEY_RIGHTMETA = 0xe7, // Keyboard Right GUI
+
+    KEY_MEDIA_PLAYPAUSE = 0xe8,
+    KEY_MEDIA_STOPCD = 0xe9,
+    KEY_MEDIA_PREVIOUSSONG = 0xea,
+    KEY_MEDIA_NEXTSONG = 0xeb,
+    KEY_MEDIA_EJECTCD = 0xec,
+    KEY_MEDIA_VOLUMEUP = 0xed,
+    KEY_MEDIA_VOLUMEDOWN = 0xee,
+    KEY_MEDIA_MUTE = 0xef,
+    KEY_MEDIA_WWW = 0xf0,
+    KEY_MEDIA_BACK = 0xf1,
+    KEY_MEDIA_FORWARD = 0xf2,
+    KEY_MEDIA_STOP = 0xf3,
+    KEY_MEDIA_FIND = 0xf4,
+    KEY_MEDIA_SCROLLUP = 0xf5,
+    KEY_MEDIA_SCROLLDOWN = 0xf6,
+    KEY_MEDIA_EDIT = 0xf7,
+    KEY_MEDIA_SLEEP = 0xf8,
+    KEY_MEDIA_COFFEE = 0xf9,
+    KEY_MEDIA_REFRESH = 0xfa,
+    KEY_MEDIA_CALC = 0xfb,
+};
+
+#endif
diff --git a/src/noise.c b/src/noise.c
index 83f2e4c..09a4c47 100644
--- a/src/noise.c
+++ b/src/noise.c
@@ -19,11 +19,22 @@
 volatile uint8_t host_packet_buf[MAX_HOST_PACKET_SIZE];
 volatile uint8_t host_packet_length = 0;
 
-static uint8_t local_key[CURVE25519_KEY_LEN];
-static NoiseCipherState *tx_cipher = NULL, *rx_cipher = NULL;
 
+void noise_state_init(struct NoiseState *st, uint8_t *remote_key_reference) {
+    st->handshake_state = HANDSHAKE_UNINITIALIZED;
+    st->handshake = NULL;
+    st->tx_cipher = NULL;
+    st->rx_cipher = NULL;
+    st->remote_key_reference = remote_key_reference;
+    st->failed_handshakes = 0;
+}
+
+int reset_protocol_handshake(struct NoiseState *st) {
+    uninit_handshake(st, HANDSHAKE_UNINITIALIZED);
+    return start_protocol_handshake(st);
+}
 
-NoiseHandshakeState *start_protocol_handshake() {
+int start_protocol_handshake(struct NoiseState *st) {
     /* TODO Noise-C is nice for prototyping, but we should really get rid of it for mostly three reasons:
      *   * We don't need cipher/protocol agility, and by baking the final protocol into the firmware we can save a lot
      *     of flash space by not including all the primitives we don't need as well as noise's dynamic protocol
@@ -40,18 +51,20 @@ NoiseHandshakeState *start_protocol_handshake() {
     HANDLE_NOISE_ERROR(noise_handshakestate_new_by_name(&handshake, "Noise_XX_25519_ChaChaPoly_BLAKE2s", NOISE_ROLE_RESPONDER), "instantiating handshake pattern");
 
     NoiseDHState *dh = noise_handshakestate_get_local_keypair_dh(handshake);
-    HANDLE_NOISE_ERROR(noise_dhstate_set_keypair_private(dh, local_key, sizeof(local_key)), "loading local private keys");
+    HANDLE_NOISE_ERROR(noise_dhstate_set_keypair_private(dh, st->local_key, sizeof(st->local_key)), "loading local private keys");
 
     HANDLE_NOISE_ERROR(noise_handshakestate_start(handshake), "starting handshake");
 
-    return handshake;
+    st->handshake = handshake;
+    st->handshake_state = HANDSHAKE_IN_PROGRESS;
+    return 0;
 
 errout:
     noise_handshakestate_free(handshake);
-    return 0;
+    return -1;
 }
 
-int generate_identity_key() {
+int generate_identity_key(struct NoiseState *st) {
     NoiseDHState *dh;
     int err;
 
@@ -59,84 +72,129 @@ int generate_identity_key() {
     HANDLE_NOISE_ERROR(noise_dhstate_generate_keypair(dh), "generating key pair");
 
     uint8_t unused[CURVE25519_KEY_LEN]; /* the noise api is a bit bad here. */
-    memset(local_key, 0, sizeof(local_key));
+    memset(st->local_key, 0, sizeof(st->local_key));
 
-    HANDLE_NOISE_ERROR(noise_dhstate_get_keypair(dh, local_key, sizeof(local_key), unused, sizeof(unused)), "saving key pair");
+    HANDLE_NOISE_ERROR(noise_dhstate_get_keypair(dh, st->local_key, sizeof(st->local_key), unused, sizeof(unused)), "saving key pair");
 
     return 0;
-
 errout:
     if (dh)
         noise_dhstate_free(dh);
     return -1;
 }
 
-NoiseHandshakeState *try_continue_noise_handshake(NoiseHandshakeState *handshake) {
+void uninit_handshake(struct NoiseState *st, enum handshake_state new_state) {
+    if (st->handshake)
+        noise_handshakestate_free(st->handshake);
+    st->handshake_state = new_state;
+    st->handshake = NULL;
+}
+
+enum handshake_state try_continue_noise_handshake(struct NoiseState *st, uint8_t *buf, size_t len, int *buf_consumed) {
     int err;
-    uint8_t message[MAX_HOST_PACKET_SIZE];
+    struct {
+        struct control_packet header;
+        uint8_t payload[MAX_HOST_PACKET_SIZE];
+    } pkt;
     NoiseBuffer noise_msg;
+
+    if (!st->handshake || st->handshake_state != HANDSHAKE_IN_PROGRESS) {
+        LOG_PRINTF("Error: Invalid handshake state\n");
+        goto errout;
+    }
+
     /* Run the protocol handshake */
-    switch (noise_handshakestate_get_action(handshake)) {
+    switch (noise_handshakestate_get_action(st->handshake)) {
     case NOISE_ACTION_WRITE_MESSAGE:
-        /* Write the next handshake message with a zero-length payload */
-        noise_buffer_set_output(noise_msg, message, sizeof(message));
-        HANDLE_NOISE_ERROR(noise_handshakestate_write_message(handshake, &noise_msg, NULL), "writing handshake message");
-        send_packet(usart2_out, message, noise_msg.size);
+        /* Write the next handshake message with a zero-length noise payload */
+        pkt.header.type = HOST_HANDSHAKE;
+        noise_buffer_set_output(noise_msg, &pkt.payload, sizeof(pkt.payload));
+        HANDLE_NOISE_ERROR(noise_handshakestate_write_message(st->handshake, &noise_msg, NULL), "writing handshake message");
+        send_packet(usart2_out, (uint8_t *)&pkt, noise_msg.size + sizeof(pkt.header));
         break;
 
     case NOISE_ACTION_READ_MESSAGE:
-        if (host_packet_length > 0) {
+        if (buf) {
             /* Read the next handshake message and discard the payload */
-            noise_buffer_set_input(noise_msg, (uint8_t *)host_packet_buf, host_packet_length);
-            HANDLE_NOISE_ERROR(noise_handshakestate_read_message(handshake, &noise_msg, NULL), "reading handshake message");
-            host_packet_length = 0; /* Acknowledge to USART ISR the buffer has been handled */
+            *buf_consumed = 1;
+            noise_buffer_set_input(noise_msg, buf, len);
+            HANDLE_NOISE_ERROR(noise_handshakestate_read_message(st->handshake, &noise_msg, NULL), "reading handshake message");
         }
         break;
 
     case NOISE_ACTION_SPLIT:
-        HANDLE_NOISE_ERROR(noise_handshakestate_split(handshake, &tx_cipher, &rx_cipher), "splitting handshake state");
+        HANDLE_NOISE_ERROR(noise_handshakestate_split(st->handshake, &st->tx_cipher, &st->rx_cipher), "splitting handshake state");
         LOG_PRINTF("Noise protocol handshake completed successfully, handshake hash:\n");
 
-        uint8_t buf[BLAKE2S_HASH_SIZE];
-        if (noise_handshakestate_get_handshake_hash(handshake, buf, sizeof(buf)) != NOISE_ERROR_NONE) {
+        if (noise_handshakestate_get_handshake_hash(st->handshake, st->handshake_hash, sizeof(st->handshake_hash)) != NOISE_ERROR_NONE) {
             LOG_PRINTF("Error fetching noise handshake state\n");
         } else {
             LOG_PRINTF("    ");
-            for (size_t i=0; i<sizeof(buf); i++)
-                LOG_PRINTF("%02x ", buf[i]);
+            for (size_t i=0; i<sizeof(st->handshake_hash); i++)
+                LOG_PRINTF("%02x ", st->handshake_hash[i]);
             LOG_PRINTF("\n");
         }
 
-        noise_handshakestate_free(handshake);
-        return NULL;
+        
+        NoiseDHState *remote_dh = noise_handshakestate_get_remote_public_key_dh(st->handshake);
+        if (!remote_dh) {
+            LOG_PRINTF("Error: Host has not identified itself\n");
+            goto errout;
+        }
+
+
+        HANDLE_NOISE_ERROR(noise_dhstate_get_public_key(remote_dh, st->remote_key, sizeof(st->remote_key)), "getting remote pubkey");
+
+        if (!memcmp(st->remote_key, st->remote_key_reference, sizeof(st->remote_key))) { /* keys match */
+            uninit_handshake(st, HANDSHAKE_DONE_KNOWN_HOST);
+            st->failed_handshakes = 0;
+        } else { /* keys don't match */
+            uninit_handshake(st, HANDSHAKE_DONE_UNKNOWN_HOST);
+            st->failed_handshakes++;
+        }
+        break;
 
     default:
-        LOG_PRINTF("Noise protocol handshake failed\n");
         goto errout;
     }
 
-    return handshake;
-
+    return st->handshake_state;
 errout:
-    noise_handshakestate_free(handshake);
-    return NULL;
+    uninit_handshake(st, HANDSHAKE_UNINITIALIZED);
+    st->failed_handshakes++;
+    LOG_PRINTF("Noise protocol handshake failed, %d failed attempts\n", st->failed_handshakes);
+    return st->handshake_state;
+}
+
+void persist_remote_key(struct NoiseState *st) {
+    memcpy(st->remote_key_reference, st->remote_key, sizeof(st->remote_key));
+    st->handshake_state = HANDSHAKE_DONE_KNOWN_HOST;
 }
 
-int send_encrypted_message(uint8_t *msg, size_t len) {
+int send_encrypted_message(struct NoiseState *st, uint8_t *msg, size_t len) {
     int err;
     NoiseBuffer noise_buf;
-    uint8_t raw_buf[MAX_HOST_PACKET_SIZE];
+    struct {
+        struct control_packet header;
+        uint8_t payload[MAX_HOST_PACKET_SIZE];
+    } pkt;
 
-    if (!tx_cipher) {
+    if (!st->tx_cipher) {
         LOG_PRINTF("Cannot send encrypted packet: Data ciphers not yet initialized\n");
         return -1;
     }
 
-    memcpy(raw_buf, msg, len); /* This is necessary because noises API doesn't support separate in and out buffers. D'oh! */
-    noise_buffer_set_inout(noise_buf, raw_buf, len, sizeof(raw_buf));
+    if (len > sizeof(pkt.payload)) {
+        LOG_PRINTF("Packet too long\n");
+        return -3;
+    }
+
+    pkt.header.type = HOST_DATA;
+    memcpy(pkt.payload, msg, len); /* This is necessary because noises API doesn't support separate in and out buffers. D'oh! */
+    noise_buffer_set_inout(noise_buf, pkt.payload, len, sizeof(pkt.payload));
 
-    HANDLE_NOISE_ERROR(noise_cipherstate_encrypt(tx_cipher, &noise_buf), "encrypting data");
-    send_packet(usart2_out, raw_buf, noise_buf.size);
+    HANDLE_NOISE_ERROR(noise_cipherstate_encrypt(st->tx_cipher, &noise_buf), "encrypting data");
+    send_packet(usart2_out, (uint8_t *)&pkt, noise_buf.size + sizeof(pkt.header));
 
     return 0;
 errout:
diff --git a/src/noise.h b/src/noise.h
index fb1f93d..c777a0b 100644
--- a/src/noise.h
+++ b/src/noise.h
@@ -16,10 +16,35 @@
 extern volatile uint8_t host_packet_buf[MAX_HOST_PACKET_SIZE];
 extern volatile uint8_t host_packet_length;
 
-
-NoiseHandshakeState *start_protocol_handshake(void);
-int generate_identity_key(void);
-NoiseHandshakeState *try_continue_noise_handshake(NoiseHandshakeState *handshake);
-int send_encrypted_message(uint8_t *msg, size_t len);
+enum handshake_state {
+    HANDSHAKE_UNINITIALIZED,
+    HANDSHAKE_NOT_STARTED,
+    HANDSHAKE_IN_PROGRESS,
+    HANDSHAKE_DONE_UNKNOWN_HOST,
+    HANDSHAKE_DONE_KNOWN_HOST,
+};
+
+extern volatile enum handshake_state handshake_state;
+
+struct NoiseState {
+    NoiseHandshakeState *handshake;
+    enum handshake_state handshake_state;
+    NoiseCipherState *tx_cipher, *rx_cipher;
+    uint8_t local_key[CURVE25519_KEY_LEN];
+    uint8_t remote_key[CURVE25519_KEY_LEN];
+    uint8_t *remote_key_reference;
+    uint8_t handshake_hash[BLAKE2S_HASH_SIZE];
+    int failed_handshakes;
+};
+
+
+void uninit_handshake(struct NoiseState *st, enum handshake_state new_state);
+void noise_state_init(struct NoiseState *st, uint8_t *remote_key_reference);
+void persist_remote_key(struct NoiseState *st);
+int start_protocol_handshake(struct NoiseState *st);
+int reset_protocol_handshake(struct NoiseState *st);
+int generate_identity_key(struct NoiseState *st);
+enum handshake_state try_continue_noise_handshake(struct NoiseState *st, uint8_t *buf, size_t len, int *buf_consumed);
+int send_encrypted_message(struct NoiseState *st, uint8_t *msg, size_t len);
 
 #endif
diff --git a/src/nouns.c b/src/nouns.c
new file mode 100644
index 0000000..65cae90
--- /dev/null
+++ b/src/nouns.c
@@ -0,0 +1,262 @@
+
+#include "words.h"
+
+const char * const nouns[256] = {
+    "yolk",             /* 0   */
+    "writing",          /* 1   */
+    "wrath",            /* 2   */
+    "wound",            /* 3   */
+    "worm",             /* 4   */
+    "wings",            /* 5   */
+    "whistle",          /* 6   */
+    "watchdog",         /* 7   */
+    "waste",            /* 8   */
+    "vomit",            /* 9   */
+    "vermin",           /* 10  */
+    "variation",        /* 11  */
+    "underachievement", /* 12  */
+    "tusk",             /* 13  */
+    "troll",            /* 14  */
+    "trick",            /* 15  */
+    "transplant",       /* 16  */
+    "transgression",    /* 17  */
+    "tooth",            /* 18  */
+    "tongue",           /* 19  */
+    "tickle",           /* 20  */
+    "tick",             /* 21  */
+    "thorn",            /* 22  */
+    "thistle",          /* 23  */
+    "thing",            /* 24  */
+    "terror",           /* 25  */
+    "tentacle",         /* 26  */
+    "tease",            /* 27  */
+    "surrender",        /* 28  */
+    "surge",            /* 29  */
+    "sucker",           /* 30  */
+    "substance",        /* 31  */
+    "storm",            /* 32  */
+    "stone",            /* 33  */
+    "stew",             /* 34  */
+    "stalk",            /* 35  */
+    "squid",            /* 36  */
+    "sprout",           /* 37  */
+    "sponge",           /* 38  */
+    "spill",            /* 39  */
+    "spider",           /* 40  */
+    "sphere",           /* 41  */
+    "spectacle",        /* 42  */
+    "speck",            /* 43  */
+    "spawn",            /* 44  */
+    "soul",             /* 45  */
+    "solution",         /* 46  */
+    "snout",            /* 47  */
+    "snake",            /* 48  */
+    "smell",            /* 49  */
+    "sloth",            /* 50  */
+    "slime",            /* 51  */
+    "slice",            /* 52  */
+    "sleeper",          /* 53  */
+    "slave",            /* 54  */
+    "sinew",            /* 55  */
+    "shell",            /* 56  */
+    "shape",            /* 57  */
+    "seizure",          /* 58  */
+    "seed",             /* 59  */
+    "schism",           /* 60  */
+    "scam",             /* 61  */
+    "scale",            /* 62  */
+    "sainthood",        /* 63  */
+    "root",             /* 64  */
+    "robe",             /* 65  */
+    "roach",            /* 66  */
+    "rinse",            /* 67  */
+    "remains",          /* 68  */
+    "relay",            /* 69  */
+    "rejuvenation",     /* 70  */
+    "realization",      /* 71  */
+    "reaction",         /* 72  */
+    "ransom",           /* 73  */
+    "pupa",             /* 74  */
+    "pride",            /* 75  */
+    "prey",             /* 76  */
+    "predator",         /* 77  */
+    "potion",           /* 78  */
+    "pornography",      /* 79  */
+    "polyp",            /* 80  */
+    "plum",             /* 81  */
+    "pleasure",         /* 82  */
+    "pitch",            /* 83  */
+    "pigeon",           /* 84  */
+    "phenomenon",       /* 85  */
+    "pest",             /* 86  */
+    "periwinkle",       /* 87  */
+    "percolation",      /* 88  */
+    "parasite",         /* 89  */
+    "pair",             /* 90  */
+    "oyster",           /* 91  */
+    "orphan",           /* 92  */
+    "orgasm",           /* 93  */
+    "organism",         /* 94  */
+    "orchid",           /* 95  */
+    "object",           /* 96  */
+    "nail",             /* 97  */
+    "mushroom",         /* 98  */
+    "murder",           /* 99  */
+    "mucus",            /* 100 */
+    "movement",         /* 101 */
+    "mother",           /* 102 */
+    "mold",             /* 103 */
+    "mist",             /* 104 */
+    "mildew",           /* 105 */
+    "metal",            /* 106 */
+    "mesh",             /* 107 */
+    "meddling",         /* 108 */
+    "mayhem",           /* 109 */
+    "masterpiece",      /* 110 */
+    "masonry",          /* 111 */
+    "mask",             /* 112 */
+    "manhood",          /* 113 */
+    "maggot",           /* 114 */
+    "lust",             /* 115 */
+    "loop",             /* 116 */
+    "living_thing",     /* 117 */
+    "liquor",           /* 118 */
+    "liquid",           /* 119 */
+    "lining",           /* 120 */
+    "laceration",       /* 121 */
+    "knife",            /* 122 */
+    "kitten",           /* 123 */
+    "kiss",             /* 124 */
+    "jumper",           /* 125 */
+    "jest",             /* 126 */
+    "instrument",       /* 127 */
+    "injustice",        /* 128 */
+    "injury",           /* 129 */
+    "influence",        /* 130 */
+    "indulgence",       /* 131 */
+    "incursion",        /* 132 */
+    "impulse",          /* 133 */
+    "imago",            /* 134 */
+    "hound",            /* 135 */
+    "horn",             /* 136 */
+    "hook",             /* 137 */
+    "hoof",             /* 138 */
+    "heirloom",         /* 139 */
+    "heart",            /* 140 */
+    "hawk",             /* 141 */
+    "hare",             /* 142 */
+    "hair",             /* 143 */
+    "gulp",             /* 144 */
+    "guardian",         /* 145 */
+    "grass",            /* 146 */
+    "goat",             /* 147 */
+    "gnat",             /* 148 */
+    "gluttony",         /* 149 */
+    "glowworm",         /* 150 */
+    "gasp",             /* 151 */
+    "game",             /* 152 */
+    "fusion",           /* 153 */
+    "fungus",           /* 154 */
+    "frustration",      /* 155 */
+    "frog",             /* 156 */
+    "foul",             /* 157 */
+    "foot",             /* 158 */
+    "food",             /* 159 */
+    "fog",              /* 160 */
+    "foal",             /* 161 */
+    "fluke",            /* 162 */
+    "fluff",            /* 163 */
+    "flower",           /* 164 */
+    "flicker",          /* 165 */
+    "flea",             /* 166 */
+    "flattery",         /* 167 */
+    "flask",            /* 168 */
+    "flare",            /* 169 */
+    "firefly",          /* 170 */
+    "finger",           /* 171 */
+    "filtration",       /* 172 */
+    "female",           /* 173 */
+    "feeder",           /* 174 */
+    "feather",          /* 175 */
+    "fart",             /* 176 */
+    "fang",             /* 177 */
+    "failure",          /* 178 */
+    "face",             /* 179 */
+    "fabrication",      /* 180 */
+    "extract",          /* 181 */
+    "exodus",           /* 182 */
+    "evil",             /* 183 */
+    "envy",             /* 184 */
+    "enema",            /* 185 */
+    "embryo",           /* 186 */
+    "egress",           /* 187 */
+    "echo",             /* 188 */
+    "eater",            /* 189 */
+    "ear",              /* 190 */
+    "dwarf",            /* 191 */
+    "dust",             /* 192 */
+    "drop",             /* 193 */
+    "draft",            /* 194 */
+    "domestication",    /* 195 */
+    "distortion",       /* 196 */
+    "dew",              /* 197 */
+    "depravity",        /* 198 */
+    "deity",            /* 199 */
+    "death",            /* 200 */
+    "daughter",         /* 201 */
+    "dash",             /* 202 */
+    "dagger",           /* 203 */
+    "culture",          /* 204 */
+    "crutch",           /* 205 */
+    "crow",             /* 206 */
+    "critter",          /* 207 */
+    "creeper",          /* 208 */
+    "creation",         /* 209 */
+    "crab",             /* 210 */
+    "corruption",       /* 211 */
+    "cocoon",           /* 212 */
+    "claw",             /* 213 */
+    "chip",             /* 214 */
+    "child",            /* 215 */
+    "cell",             /* 216 */
+    "catch",            /* 217 */
+    "carving",          /* 218 */
+    "carrot",           /* 219 */
+    "carnival",         /* 220 */
+    "cancer",           /* 221 */
+    "butterfly",        /* 222 */
+    "burn",             /* 223 */
+    "buildup",          /* 224 */
+    "brush",            /* 225 */
+    "brew",             /* 226 */
+    "bottle",           /* 227 */
+    "boot",             /* 228 */
+    "book",             /* 229 */
+    "bone",             /* 230 */
+    "blunder",          /* 231 */
+    "blot",             /* 232 */
+    "blood",            /* 233 */
+    "blink",            /* 234 */
+    "bite",             /* 235 */
+    "bird",             /* 236 */
+    "benthos",          /* 237 */
+    "beak",             /* 238 */
+    "basket",           /* 239 */
+    "bark",             /* 240 */
+    "ball",             /* 241 */
+    "baby",             /* 242 */
+    "axolotl",          /* 243 */
+    "ashes",            /* 244 */
+    "artifact",         /* 245 */
+    "arson",            /* 246 */
+    "armor",            /* 247 */
+    "apparition",       /* 248 */
+    "antenna",          /* 249 */
+    "alms",             /* 250 */
+    "alienation",       /* 251 */
+    "advent",           /* 252 */
+    "adornment",        /* 253 */
+    "abomination",      /* 254 */
+    "abandonment",      /* 255 */
+};
+
diff --git a/src/packet_interface.h b/src/packet_interface.h
index 546918b..9e1327d 100644
--- a/src/packet_interface.h
+++ b/src/packet_interface.h
@@ -3,8 +3,35 @@
 
 #include "usart_helpers.h"
 
+
 extern struct dma_usart_file *usart2_out;
 
+enum control_packet_types {
+    _HOST_RESERVED = 0,
+    HOST_INITIATE_HANDSHAKE = 1,
+    HOST_HANDSHAKE = 2,
+    HOST_DATA = 3,
+};
+
+enum packet_types {
+    _PACKET_RESERVED = 0,
+    HID_KEYBOARD_REPORT = 1,
+    HID_MOUSE_REPORT = 2,
+    PAIRING = 3,
+};
+
+struct hid_report_packet {
+    uint8_t type;
+    uint8_t len;
+    uint8_t report[8];
+} __attribute__((__packed__));
+
+struct control_packet {
+    uint8_t type;
+    uint8_t payload[0];
+} __attribute__((__packed__));
+
+
 void send_packet(struct dma_usart_file *f, const uint8_t *data, size_t len);
 
 #endif
diff --git a/src/words.h b/src/words.h
new file mode 100644
index 0000000..e8cb628
--- /dev/null
+++ b/src/words.h
@@ -0,0 +1,7 @@
+#ifndef __ADJECTIVES_H__
+#define __ADJECTIVES_H__
+
+extern const char * const adjectives[256];
+extern const char * const nouns[256];
+
+#endif