EncryptedAudio/sender.c at master · pmaene/EncryptedAudio · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#include "sender.h"

// RSA
const unsigned char Enc_SenderPrivateExp[ENC_PRIVATE_KEY_CHARS] =
    "\x07\x8e\x74\x79\x5c\xb9\xa9\xda\x98\xf8\x0e\xf0\xad\xa4\xed"
    "\xa9\xe9\x29\xe7\x93\x37\x40\xf1\x73\xb4\xc4\x46\x6b\x65\x57"
    "\xae\xfd\x53\x84\x34\xf6\x3d\x1d\x83\x78\x76\x12\xe8\xde\xad"
    "\xd5\x69\xa0\xd7\x67\x92\x60\x34\x5b\x1c\x97\x8f\xee\x5c\x3b"
    "\xaf\x61\x05\xb5\x26\xbd\x17\xda\x87\x28\x14\x29\x36\xe6\xa2"
    "\xb3\xc4\xd8\x06\xaf\x49\xc0\x5e\x4b\x8a\xea\xb5\x50\x58\xa1"
    "\x93\x1a\x34\xb7\xb1\x1b\x4f\xf9\x6c\xc0\xed\xad\xdf\xa1\xa0"
    "\xe3\x9e\x87\x28\x65\x3f\xf2\x6f\x40\xa4\x0c\xe6\x13\x63\xd9"
    "\x59\x1f\x7c\x31\x31\x73\xfc\xf7\xda\x68\xc8\x23\xff\xc3\x19"
    "\x4f\x85\x17\x63\xce\xf1\x7a\xe6\xb1\xde\xb0\xb9\x65\xfd\x2a"
    "\x83\xeb\x6d\xf6\x5a\x41";

digit_t senderSecret[ENC_PRIVATE_KEY_DIGITS];
digit_t sender_senderModExp[ENC_PRIVATE_KEY_DIGITS];
digit_t sender_receiverModExp[ENC_PRIVATE_KEY_DIGITS];

uint8_t senderAESKey[ENC_AES_KEY_CHARS];
uint8_t senderHashKey[ENC_HMAC_KEY_CHARS];
uint8_t senderCTRNonce[ENC_CTR_NONCE_CHARS];

uint32_t senderPacketCounter[1];

void sender_construct() {
    memset(senderSecret, 0, ENC_PRIVATE_KEY_DIGITS*sizeof(digit_t));
    memset(sender_receiverModExp, 0, ENC_PRIVATE_KEY_DIGITS*sizeof(digit_t));

    memset(senderAESKey, 0, ENC_AES_KEY_CHARS);
    memset(senderHashKey, 0, ENC_HMAC_KEY_CHARS);
    memset(senderCTRNonce, 0, ENC_CTR_NONCE_CHARS);

    memset(senderPacketCounter, 0, sizeof(uint32_t));
}

void sender_senderHello() {
    field_t sendPacket[ENC_KEY_PACKET_CHARS];

    #ifndef __ENC_NO_PRINTS__
        printf("--> sender_senderHello\n");
    #endif
    senderHello(sendPacket, sender_senderModExp, senderSecret);

    channel_write(sendPacket, ENC_KEY_PACKET_CHARS);
}

int sender_senderAcknowledge() {
    int returnStatus;

    field_t receivedPacket[ENC_KEY_PACKET_CHARS];
    field_t sendPacket[ENC_KEY_PACKET_CHARS];

    channel_read(receivedPacket, ENC_KEY_PACKET_CHARS);

    #ifndef __ENC_NO_PRINTS__
        printf("--> sender_senderAcknowledge\n");
    #endif

    returnStatus = senderAcknowledge(sendPacket, receivedPacket, senderSecret, sender_receiverModExp, sender_senderModExp, (unsigned char *) Enc_SenderPrivateExp);

    channel_write(sendPacket, ENC_KEY_PACKET_CHARS);

    return returnStatus;
}

void sender_deriveKey(uint8_t *restrict aesKey, uint8_t *restrict CTRNonce, digit_t *restrict modExp) {
	digit_t symmetricKey[ENC_PRIVATE_KEY_DIGITS];

    #ifndef __ENC_NO_PRINTS__
        printf("--> sender_deriveKey\n");
    #endif

    memcpy(sender_receiverModExp, modExp, ENC_PRIVATE_KEY_DIGITS);
	_calculateSymmetricKey(symmetricKey, sender_receiverModExp, senderSecret);
	_deriveKeys(senderAESKey, senderHashKey, senderCTRNonce, symmetricKey);
    memcpy(aesKey, senderAESKey, ENC_AES_KEY_CHARS);
    memcpy(CTRNonce, senderCTRNonce, ENC_CTR_NONCE_CHARS);
}

int sender_sendData() {
    unsigned char encryptedData[ENC_DATA_SIZE_CHARS];

    #ifndef __ENC_NO_ENCRYPTION_PRINTS__
        digit_t dataDigits[ENC_DATA_SIZE_DIGITS];
    #endif
    field_t data[ENC_DATA_SIZE_CHARS];
    field_t dataPacket[ENC_DATA_PACKET_CHARS];

    #ifndef __ENC_NO_PRINTS__
        size_t i;
    #endif
    uint8_t hmac[ENC_HMAC_CHARS];

    #ifndef __ENC_NO_PRINTS__
        printf("\n\n# Sender\n");
        printf("--------\n");
    #endif

    buffer_read(data, ENC_DATA_SIZE_CHARS);

    #ifndef __ENC_NO_PRINTS__
        printf("--| senderPacketCounter: %d\n", *senderPacketCounter);
    #endif

    #ifndef __ENC_NO_ENCRYPTION_PRINTS__
        printf("--| data\n");
        mpConvFromOctets(dataDigits, ENC_DATA_SIZE_DIGITS, data, ENC_DATA_SIZE_CHARS);
        mpPrintNL(dataDigits, ENC_DATA_SIZE_DIGITS);
    #endif

    _encryptData(encryptedData, senderAESKey, senderCTRNonce, *senderPacketCounter, data, ENC_DATA_SIZE_CHARS);

    #ifndef __ENC_NO_ENCRYPTION_PRINTS__
        printf("--| encryptedData\n");
        mpConvFromOctets(dataDigits, ENC_DATA_SIZE_DIGITS, encryptedData, ENC_DATA_SIZE_CHARS);
        mpPrintNL(dataDigits, ENC_DATA_SIZE_DIGITS);
    #endif

    dataPacket[0] = 0x03;
    memcpy(dataPacket+1, senderPacketCounter, sizeof(uint32_t));
    memcpy(dataPacket+5, encryptedData, ENC_DATA_SIZE_CHARS);

    // Calculate HMAC
    _hmac(hmac, dataPacket, senderHashKey);
    memcpy(dataPacket+5+ENC_DATA_SIZE_CHARS, hmac, ENC_HMAC_CHARS);

    #ifndef __ENC_NO_PRINTS__
        printf("--| hmac\n");
        for (i = 0; i < ENC_HMAC_CHARS; i++)
            printf("%x", hmac[i]);
        printf("\n");
    #endif

    #ifndef __ENC_NO_PRINTS__
        printf("--| senderPacketCounter: %d\n", *senderPacketCounter);
    #endif

    channel_write(dataPacket, ENC_DATA_PACKET_CHARS);

    return increaseCounter(senderPacketCounter);
}