main.ino 3.25 KB
Newer Older
1 2 3 4
#include "crypto_aead.h"
#include "api.h"
#include "uartp.h"

5 6
#define MAX_BYTES 172
#define CMDBUF_LEN 200
7
static uint8_t cmdbuf[CMDBUF_LEN];
8 9

#define CRYPTO_BUSY 12
10
#define SerialOut Serial
11 12 13 14 15 16 17

uint8_t npub[CRYPTO_NPUBBYTES];
uint8_t nsec[CRYPTO_NSECBYTES];
uint8_t k[CRYPTO_KEYBYTES];
uint8_t ad[MAX_BYTES];
uint8_t m[MAX_BYTES];
uint8_t c[MAX_BYTES];
18 19 20 21
unsigned long long int adlen = 0;
unsigned long long int mlen = 0;
unsigned long long int clen = 0;
int res = 0;
22 23 24 25 26 27 28 29

void setup();
void loop();

#ifdef __cplusplus
extern "C" {
#endif

30 31
void uart_wbyte(uint8_t x) {
    SerialOut.write((uint8_t) (x));
32 33
}

34
uint8_t uart_rbyte() {
35 36
    int r;
    do {
37
        r = SerialOut.read();
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
    } while (r == -1);
    return (uint8_t) (0xff & r);
}

#ifdef __cplusplus
}
#endif

void my_assert(bool b) {
    if (b)
        return;
    for(;;)
        yield();
}

void setup() {
Enrico Pozzobon committed
54
    SerialOut.begin(500000);
55 56 57
    pinMode(CRYPTO_BUSY, OUTPUT);
    digitalWrite(CRYPTO_BUSY, HIGH);
    delay(100);
58 59 60 61 62 63
    memset(npub, 0, CRYPTO_NPUBBYTES);
    memset(nsec, 0, CRYPTO_NSECBYTES);
    memset(k, 0, CRYPTO_KEYBYTES);
    memset(ad, 0, MAX_BYTES);
    memset(m, 0, MAX_BYTES);
    memset(c, 0, MAX_BYTES);
64 65 66 67
    mlen = 8;
    adlen = 0;
    crypto_aead_encrypt(c, &clen, m, mlen, ad, adlen, nsec, npub, k);
    crypto_aead_decrypt(m, &mlen, nsec, c, clen, ad, adlen, npub, k);
68
    SerialOut.print("Hello, World!");
69 70 71 72
}

void loop() {
    int res;
73
    portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
74 75 76
    uint16_t len = uartp_recv(cmdbuf, CMDBUF_LEN - 1);
    uint8_t action = cmdbuf[0];
    if (len == 0 || len > CMDBUF_LEN - 1)
77 78 79 80
        return;

    uint16_t l = len - 1;
    uint16_t rl = 0;
81
    uint8_t *var = cmdbuf+1;
82 83 84 85 86 87 88 89
    switch (action) {
        case 'm': my_assert(l <= MAX_BYTES);        memcpy(m,    var, l); mlen = l; break;
        case 'c': my_assert(l <= MAX_BYTES);        memcpy(c,    var, l); clen = l; break;
        case 'a': my_assert(l <= MAX_BYTES);        memcpy(ad,   var, l); adlen = l; break;
        case 'k': my_assert(l == CRYPTO_KEYBYTES);  memcpy(k,    var, l); break;
        case 'p': my_assert(l == CRYPTO_NPUBBYTES); memcpy(npub, var, l); break;
        case 's': my_assert(l == CRYPTO_NSECBYTES); memcpy(nsec, var, l); break;
        case 'e':
90
            portENTER_CRITICAL(&mux);
91 92 93
            digitalWrite(CRYPTO_BUSY, LOW);
            res = crypto_aead_encrypt(c, &clen, m, mlen, ad, adlen, nsec, npub, k);
            digitalWrite(CRYPTO_BUSY, HIGH);
94
            portEXIT_CRITICAL(&mux);
95 96
            break;
        case 'd':
97
            portENTER_CRITICAL(&mux);
98 99 100
            digitalWrite(CRYPTO_BUSY, LOW);
            res = crypto_aead_decrypt(m, &mlen, nsec, c, clen, ad, adlen, npub, k);
            digitalWrite(CRYPTO_BUSY, HIGH);
101
            portEXIT_CRITICAL(&mux);
102 103 104 105 106 107 108
            break;
        case'M': var = m;    rl = mlen; break;
        case'C': var = c;    rl = clen; break;
        case'A': var = ad;   rl = adlen; break;
        case'K': var = k;    rl = CRYPTO_KEYBYTES; break;
        case'P': var = npub; rl = CRYPTO_NPUBBYTES; break;
        case'S': var = nsec; rl = CRYPTO_NSECBYTES; break;
109
        case'R': var = (uint8_t *) &res; rl = sizeof(res); break;
110 111 112
        default:
            my_assert(false);
    }
113 114 115
    cmdbuf[0] = action;
    memcpy(cmdbuf+1, var, rl);
    uartp_send(cmdbuf, rl+1);
116
}