Logo AND Algorithmique Numérique Distribuée

Private GIT Repository
new
[Cipher_code.git] / Arduino / libraries / Arduino-crypto-master / Crypto.h~
1 /**
2  * An extremely minimal crypto library for Arduino devices.
3  * 
4  * The SHA256 and AES implementations are derived from axTLS 
5  * (http://axtls.sourceforge.net/), Copyright (c) 2008, Cameron Rich.
6  * 
7  * Ported and refactored by Chris Ellis 2016.
8  * 
9  */
10
11 #ifndef CRYPTO_h
12 #define CRYPTO_h
13
14 #include <Arduino.h>
15 #include <osapi.h>
16
17 #define SHA256_SIZE             32
18 #define SHA256HMAC_SIZE         32
19 #define SHA256HMAC_BLOCKSIZE    64
20 #define AES_MAXROUNDS           14
21 #define AES_BLOCKSIZE           16
22 #define AES_IV_SIZE             16
23 #define AES_IV_LENGTH           16
24 #define AES_128_KEY_LENGTH      16
25 #define AES_256_KEY_LENGTH      16
26
27 /**
28  * Compute a SHA256 hash
29  */
30 class SHA256
31 {
32     public:
33         SHA256();
34         /**
35          * Update the hash with new data
36          */
37         void doUpdate(const byte *msg, int len);
38         void doUpdate(const char *msg, unsigned int len) { doUpdate((byte*) msg, len); }
39         void doUpdate(const char *msg) { doUpdate((byte*) msg, strlen(msg)); }
40         /**
41          * Compute the final hash and store it in [digest], digest must be 
42          * at least 32 bytes
43          */
44         void doFinal(byte *digest);
45         /**
46          * Compute the final hash and check it matches this given expected hash
47          */
48         bool matches(const byte *expected);
49     private:
50         void SHA256_Process(const byte digest[64]);
51         uint32_t total[2];
52         uint32_t state[8];
53         uint8_t  buffer[64];
54 };
55
56 #define HMAC_OPAD 0x5C
57 #define HMAC_IPAD 0x36
58
59 /**
60  * Compute a HMAC using SHA256
61  */
62 class SHA256HMAC
63 {
64     public:
65         /**
66          * Compute a SHA256 HMAC with the given [key] key of [length] bytes 
67          * for authenticity
68          */
69         SHA256HMAC(const byte *key, unsigned int keyLen);
70         /**
71          * Update the hash with new data
72          */
73         void doUpdate(const byte *msg, unsigned int len);
74         void doUpdate(const char *msg, unsigned int len) { doUpdate((byte*) msg, len); }
75         void doUpdate(const char *msg) { doUpdate((byte*) msg, strlen(msg)); }
76         /**
77          * Compute the final hash and store it in [digest], digest must be 
78          * at least 32 bytes
79          */
80         void doFinal(byte *digest);
81         /**
82          * Compute the final hash and check it matches this given expected hash
83          */
84         bool matches(const byte *expected);
85     private:
86         void blockXor(const byte *in, byte *out, byte val, byte len);
87         SHA256 _hash;
88         byte _innerKey[SHA256HMAC_BLOCKSIZE];
89         byte _outerKey[SHA256HMAC_BLOCKSIZE];
90 };
91
92 /**
93  * AES 128 and 256, based on code from axTLS
94  */
95 class AES
96 {
97     public:
98         typedef enum
99         {
100             AES_MODE_128,
101             AES_MODE_256
102         } AES_MODE;
103         typedef enum
104         {
105             CIPHER_ENCRYPT = 0x01,
106             CIPHER_DECRYPT = 0x02
107         } CIPHER_MODE;
108         /**
109          * Create this cipher instance in either encrypt or decrypt mode
110          * 
111          * Use the given [key] which must be 16 bytes long for AES 128 and 
112          *  32 bytes for AES 256
113          * 
114          * Use the given [iv] initialistion vection which must be 16 bytes long
115          * 
116          * Use the either AES 128 or AES 256 as specified by [mode]
117          * 
118          * Either encrypt or decrypt as specified by [cipherMode]
119          */
120         AES(const uint8_t *key, const uint8_t *iv, AES_MODE mode, CIPHER_MODE cipherMode);
121         /**
122          * Either encrypt or decrypt [in] and store into [out] for [length] bytes.
123          * 
124          * Note: the length must be a multiple of 16 bytes
125          */
126         void process(const uint8_t *in, uint8_t *out, int length);
127     private:
128         void encryptCBC(const uint8_t *in, uint8_t *out, int length);
129         void decryptCBC(const uint8_t *in, uint8_t *out, int length);
130         void convertKey();
131         void encrypt(uint32_t *data);
132         void decrypt(uint32_t *data);
133         uint16_t _rounds;
134         uint16_t _key_size;
135         uint32_t _ks[(AES_MAXROUNDS+1)*8];
136         uint8_t _iv[AES_IV_SIZE];
137         CIPHER_MODE _cipherMode;
138 };
139
140 /**
141  * ESP8266 specific random number generator
142  */
143 class RNG
144 {
145     public:
146         /**
147          * Fill the [dst] array with [length] random bytes
148          */
149         static void fill(uint8_t *dst, unsigned int length);
150         /**
151          * Get a random byte
152          */
153         static byte get();
154         /**
155          * Get a 32bit random number
156          */
157         static uint32_t getLong();
158     private:
159 };
160
161 #endif